chiark / gitweb /
Fix a few return codes in error paths
[elogind.git] / src / network / sd-network.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2011 Lennart Poettering
7   Copyright 2014 Tom Gundersen
8
9   systemd is free software; you can redistribute it and/or modify it
10   under the terms of the GNU Lesser General Public License as published by
11   the Free Software Foundation; either version 2.1 of the License, or
12   (at your option) any later version.
13
14   systemd is distributed in the hope that it will be useful, but
15   WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17   Lesser General Public License for more details.
18
19   You should have received a copy of the GNU Lesser General Public License
20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <unistd.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <sys/inotify.h>
27 #include <sys/poll.h>
28
29 #include "util.h"
30 #include "macro.h"
31 #include "strv.h"
32 #include "fileio.h"
33 #include "sd-network.h"
34 #include "dhcp-lease-internal.h"
35
36 _public_ int sd_network_get_link_state(unsigned index, char **state) {
37         _cleanup_free_ char *s = NULL, *p = NULL;
38         int r;
39
40         assert_return(index, -EINVAL);
41         assert_return(state, -EINVAL);
42
43         if (asprintf(&p, "/run/systemd/network/links/%u", index) < 0)
44                 return -ENOMEM;
45
46         r = parse_env_file(p, NEWLINE, "STATE", &s, NULL);
47
48         if (r == -ENOENT)
49                 return -ENODATA;
50         else if (r < 0)
51                 return r;
52         else if (!s)
53                 return -EIO;
54
55         if (streq(s, "unmanaged"))
56                 return -EUNATCH;
57
58         *state = s;
59         s = NULL;
60
61         return 0;
62 }
63
64 _public_ int sd_network_get_dhcp_lease(unsigned index, sd_dhcp_lease **ret) {
65         sd_dhcp_lease *lease;
66         char *p, *s = NULL;
67         int r;
68
69         assert_return(index, -EINVAL);
70         assert_return(ret, -EINVAL);
71
72         if (asprintf(&p, "/run/systemd/network/links/%u", index) < 0)
73                 return -ENOMEM;
74
75         r = parse_env_file(p, NEWLINE, "DHCP_LEASE", &s, NULL);
76         free(p);
77
78         if (r < 0) {
79                 free(s);
80                 return r;
81         } else if (!s)
82                 return -EIO;
83
84         r = dhcp_lease_load(s, &lease);
85         if (r < 0)
86                 return r;
87
88         *ret = lease;
89
90         return 0;
91 }
92
93 _public_ int sd_network_get_ifindices(unsigned **indices) {
94         _cleanup_closedir_ DIR *d;
95         int r = 0;
96         unsigned n = 0;
97         _cleanup_free_ uid_t *l = NULL;
98
99         d = opendir("/run/systemd/network/links/");
100         if (!d)
101                 return -errno;
102
103         for (;;) {
104                 struct dirent *de;
105                 int k;
106                 unsigned index;
107
108                 errno = 0;
109                 de = readdir(d);
110                 if (!de && errno != 0)
111                         return -errno;
112
113                 if (!de)
114                         break;
115
116                 dirent_ensure_type(d, de);
117
118                 if (!dirent_is_file(de))
119                         continue;
120
121                 k = safe_atou(de->d_name, &index);
122                 if (k < 0)
123                         continue;
124
125                 if (indices) {
126                         if ((unsigned) r >= n) {
127                                 unsigned *t;
128
129                                 n = MAX(16, 2*r);
130                                 t = realloc(l, sizeof(unsigned) * n);
131                                 if (!t)
132                                         return -ENOMEM;
133
134                                 l = t;
135                         }
136
137                         assert((unsigned) r < n);
138                         l[r++] = index;
139                 } else
140                         r++;
141         }
142
143         if (indices) {
144                 *indices = l;
145                 l = NULL;
146         }
147
148         return r;
149 }
150
151 static inline int MONITOR_TO_FD(sd_network_monitor *m) {
152         return (int) (unsigned long) m - 1;
153 }
154
155 static inline sd_network_monitor* FD_TO_MONITOR(int fd) {
156         return (sd_network_monitor*) (unsigned long) (fd + 1);
157 }
158
159 _public_ int sd_network_monitor_new(const char *category, sd_network_monitor **m) {
160         int fd, k;
161         bool good = false;
162
163         assert_return(m, -EINVAL);
164
165         fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
166         if (fd < 0)
167                 return -errno;
168
169         if (!category || streq(category, "netif")) {
170                 k = inotify_add_watch(fd, "/run/systemd/network/links/", IN_MOVED_TO|IN_DELETE);
171                 if (k < 0) {
172                         safe_close(fd);
173                         return -errno;
174                 }
175
176                 good = true;
177         }
178
179         if (!good) {
180                 close_nointr(fd);
181                 return -EINVAL;
182         }
183
184         *m = FD_TO_MONITOR(fd);
185         return 0;
186 }
187
188 _public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
189         int fd;
190
191         assert_return(m, NULL);
192
193         fd = MONITOR_TO_FD(m);
194         close_nointr(fd);
195
196         return NULL;
197 }
198
199 _public_ int sd_network_monitor_flush(sd_network_monitor *m) {
200
201         assert_return(m, -EINVAL);
202
203         return flush_fd(MONITOR_TO_FD(m));
204 }
205
206 _public_ int sd_network_monitor_get_fd(sd_network_monitor *m) {
207
208         assert_return(m, -EINVAL);
209
210         return MONITOR_TO_FD(m);
211 }
212
213 _public_ int sd_network_monitor_get_events(sd_network_monitor *m) {
214
215         assert_return(m, -EINVAL);
216
217         /* For now we will only return POLLIN here, since we don't
218          * need anything else ever for inotify.  However, let's have
219          * this API to keep our options open should we later on need
220          * it. */
221         return POLLIN;
222 }
223
224 _public_ int sd_network_monitor_get_timeout(sd_network_monitor *m, uint64_t *timeout_usec) {
225
226         assert_return(m, -EINVAL);
227         assert_return(timeout_usec, -EINVAL);
228
229         /* For now we will only return (uint64_t) -1, since we don't
230          * need any timeout. However, let's have this API to keep our
231          * options open should we later on need it. */
232         *timeout_usec = (uint64_t) -1;
233         return 0;
234 }