src/libsystemd/sd-network/sd-network.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2011 Lennart Poettering
   5   Copyright 2014 Tom Gundersen
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <poll.h>
  23 #include <string.h>
  24 #include <sys/inotify.h>
  25
  26 #include "sd-network.h"
  27
  28 #include "alloc-util.h"
  29 #include "fd-util.h"
  30 #include "fileio.h"
  31 #include "fs-util.h"
  32 #include "macro.h"
  33 #include "parse-util.h"
  34 #include "string-util.h"
  35 #include "strv.h"
  36 #include "util.h"
  37
  38 _public_ int sd_network_get_operational_state(char **state) {
  39         _cleanup_free_ char *s = NULL;
  40         int r;
  41
  42         assert_return(state, -EINVAL);
  43
  44         r = parse_env_file("/run/systemd/netif/state", NEWLINE, "OPER_STATE", &s, NULL);
  45         if (r == -ENOENT)
  46                 return -ENODATA;
  47         if (r < 0)
  48                 return r;
  49         if (isempty(s))
  50                 return -ENODATA;
  51
  52         *state = s;
  53         s = NULL;
  54
  55         return 0;
  56 }
  57
  58 static int network_get_strv(const char *key, char ***ret) {
  59         _cleanup_strv_free_ char **a = NULL;
  60         _cleanup_free_ char *s = NULL;
  61         int r;
  62
  63         assert_return(ret, -EINVAL);
  64
  65         r = parse_env_file("/run/systemd/netif/state", NEWLINE, key, &s, NULL);
  66         if (r == -ENOENT)
  67                 return -ENODATA;
  68         if (r < 0)
  69                 return r;
  70         if (isempty(s)) {
  71                 *ret = NULL;
  72                 return 0;
  73         }
  74
  75         a = strv_split(s, " ");
  76         if (!a)
  77                 return -ENOMEM;
  78
  79         strv_uniq(a);
  80         r = strv_length(a);
  81
  82         *ret = a;
  83         a = NULL;
  84
  85         return r;
  86 }
  87
  88 _public_ int sd_network_get_dns(char ***ret) {
  89         return network_get_strv("DNS", ret);
  90 }
  91
  92 _public_ int sd_network_get_ntp(char ***ret) {
  93         return network_get_strv("NTP", ret);
  94 }
  95
  96 _public_ int sd_network_get_search_domains(char ***ret) {
  97         return network_get_strv("DOMAINS", ret);
  98 }
  99
 100 _public_ int sd_network_get_route_domains(char ***ret) {
 101         return network_get_strv("ROUTE_DOMAINS", ret);
 102 }
 103
 104 static int network_link_get_string(int ifindex, const char *field, char **ret) {
 105         _cleanup_free_ char *s = NULL, *p = NULL;
 106         int r;
 107
 108         assert_return(ifindex > 0, -EINVAL);
 109         assert_return(ret, -EINVAL);
 110
 111         if (asprintf(&p, "/run/systemd/netif/links/%i", ifindex) < 0)
 112                 return -ENOMEM;
 113
 114         r = parse_env_file(p, NEWLINE, field, &s, NULL);
 115         if (r == -ENOENT)
 116                 return -ENODATA;
 117         if (r < 0)
 118                 return r;
 119         if (isempty(s))
 120                 return -ENODATA;
 121
 122         *ret = s;
 123         s = NULL;
 124
 125         return 0;
 126 }
 127
 128 static int network_link_get_strv(int ifindex, const char *key, char ***ret) {
 129         _cleanup_free_ char *p = NULL, *s = NULL;
 130         _cleanup_strv_free_ char **a = NULL;
 131         int r;
 132
 133         assert_return(ifindex > 0, -EINVAL);
 134         assert_return(ret, -EINVAL);
 135
 136         if (asprintf(&p, "/run/systemd/netif/links/%d", ifindex) < 0)
 137                 return -ENOMEM;
 138
 139         r = parse_env_file(p, NEWLINE, key, &s, NULL);
 140         if (r == -ENOENT)
 141                 return -ENODATA;
 142         if (r < 0)
 143                 return r;
 144         if (isempty(s)) {
 145                 *ret = NULL;
 146                 return 0;
 147         }
 148
 149         a = strv_split(s, " ");
 150         if (!a)
 151                 return -ENOMEM;
 152
 153         strv_uniq(a);
 154         r = strv_length(a);
 155
 156         *ret = a;
 157         a = NULL;
 158
 159         return r;
 160 }
 161
 162 _public_ int sd_network_link_get_setup_state(int ifindex, char **state) {
 163         return network_link_get_string(ifindex, "ADMIN_STATE", state);
 164 }
 165
 166 _public_ int sd_network_link_get_network_file(int ifindex, char **filename) {
 167         return network_link_get_string(ifindex, "NETWORK_FILE", filename);
 168 }
 169
 170 _public_ int sd_network_link_get_operational_state(int ifindex, char **state) {
 171         return network_link_get_string(ifindex, "OPER_STATE", state);
 172 }
 173
 174 _public_ int sd_network_link_get_llmnr(int ifindex, char **llmnr) {
 175         return network_link_get_string(ifindex, "LLMNR", llmnr);
 176 }
 177
 178 _public_ int sd_network_link_get_mdns(int ifindex, char **mdns) {
 179         return network_link_get_string(ifindex, "MDNS", mdns);
 180 }
 181
 182 _public_ int sd_network_link_get_dnssec(int ifindex, char **dnssec) {
 183         return network_link_get_string(ifindex, "DNSSEC", dnssec);
 184 }
 185
 186 _public_ int sd_network_link_get_dnssec_negative_trust_anchors(int ifindex, char ***nta) {
 187         return network_link_get_strv(ifindex, "DNSSEC_NTA", nta);
 188 }
 189
 190 _public_ int sd_network_link_get_lldp(int ifindex, char **lldp) {
 191         _cleanup_free_ char *s = NULL, *p = NULL;
 192         size_t size;
 193         int r;
 194
 195         assert_return(ifindex > 0, -EINVAL);
 196         assert_return(lldp, -EINVAL);
 197
 198         if (asprintf(&p, "/run/systemd/netif/lldp/%d", ifindex) < 0)
 199                 return -ENOMEM;
 200
 201         r = read_full_file(p, &s, &size);
 202         if (r == -ENOENT)
 203                 return -ENODATA;
 204         if (r < 0)
 205                 return r;
 206         if (size <= 0)
 207                 return -ENODATA;
 208
 209         *lldp = s;
 210         s = NULL;
 211
 212         return 0;
 213 }
 214
 215 int sd_network_link_get_timezone(int ifindex, char **ret) {
 216         return network_link_get_string(ifindex, "TIMEZONE", ret);
 217 }
 218
 219 _public_ int sd_network_link_get_dns(int ifindex, char ***ret) {
 220         return network_link_get_strv(ifindex, "DNS", ret);
 221 }
 222
 223 _public_ int sd_network_link_get_ntp(int ifindex, char ***ret) {
 224         return network_link_get_strv(ifindex, "NTP", ret);
 225 }
 226
 227 _public_ int sd_network_link_get_search_domains(int ifindex, char ***ret) {
 228         return network_link_get_strv(ifindex, "DOMAINS", ret);
 229 }
 230
 231 _public_ int sd_network_link_get_route_domains(int ifindex, char ***ret) {
 232         return network_link_get_strv(ifindex, "ROUTE_DOMAINS", ret);
 233 }
 234
 235 _public_ int sd_network_link_get_carrier_bound_to(int ifindex, char ***ret) {
 236         return network_link_get_strv(ifindex, "CARRIER_BOUND_TO", ret);
 237 }
 238
 239 _public_ int sd_network_link_get_carrier_bound_by(int ifindex, char ***ret) {
 240         return network_link_get_strv(ifindex, "CARRIER_BOUND_BY", ret);
 241 }
 242
 243 static inline int MONITOR_TO_FD(sd_network_monitor *m) {
 244         return (int) (unsigned long) m - 1;
 245 }
 246
 247 static inline sd_network_monitor* FD_TO_MONITOR(int fd) {
 248         return (sd_network_monitor*) (unsigned long) (fd + 1);
 249 }
 250
 251 static int monitor_add_inotify_watch(int fd) {
 252         int k;
 253
 254         k = inotify_add_watch(fd, "/run/systemd/netif/links/", IN_MOVED_TO|IN_DELETE);
 255         if (k >= 0)
 256                 return 0;
 257         else if (errno != ENOENT)
 258                 return -errno;
 259
 260         k = inotify_add_watch(fd, "/run/systemd/netif/", IN_CREATE|IN_ISDIR);
 261         if (k >= 0)
 262                 return 0;
 263         else if (errno != ENOENT)
 264                 return -errno;
 265
 266         k = inotify_add_watch(fd, "/run/systemd/", IN_CREATE|IN_ISDIR);
 267         if (k < 0)
 268                 return -errno;
 269
 270         return 0;
 271 }
 272
 273 _public_ int sd_network_monitor_new(sd_network_monitor **m, const char *category) {
 274         _cleanup_close_ int fd = -1;
 275         int k;
 276         bool good = false;
 277
 278         assert_return(m, -EINVAL);
 279
 280         fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
 281         if (fd < 0)
 282                 return -errno;
 283
 284         if (!category || streq(category, "links")) {
 285                 k = monitor_add_inotify_watch(fd);
 286                 if (k < 0)
 287                         return k;
 288
 289                 good = true;
 290         }
 291
 292         if (!good)
 293                 return -EINVAL;
 294
 295         *m = FD_TO_MONITOR(fd);
 296         fd = -1;
 297
 298         return 0;
 299 }
 300
 301 _public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
 302         int fd;
 303
 304         if (m) {
 305                 fd = MONITOR_TO_FD(m);
 306                 close_nointr(fd);
 307         }
 308
 309         return NULL;
 310 }
 311
 312 _public_ int sd_network_monitor_flush(sd_network_monitor *m) {
 313         union inotify_event_buffer buffer;
 314         struct inotify_event *e;
 315         ssize_t l;
 316         int fd, k;
 317
 318         assert_return(m, -EINVAL);
 319
 320         fd = MONITOR_TO_FD(m);
 321
 322         l = read(fd, &buffer, sizeof(buffer));
 323         if (l < 0) {
 324                 if (errno == EAGAIN || errno == EINTR)
 325                         return 0;
 326
 327                 return -errno;
 328         }
 329
 330         FOREACH_INOTIFY_EVENT(e, buffer, l) {
 331                 if (e->mask & IN_ISDIR) {
 332                         k = monitor_add_inotify_watch(fd);
 333                         if (k < 0)
 334                                 return k;
 335
 336                         k = inotify_rm_watch(fd, e->wd);
 337                         if (k < 0)
 338                                 return -errno;
 339                 }
 340         }
 341
 342         return 0;
 343 }
 344
 345 _public_ int sd_network_monitor_get_fd(sd_network_monitor *m) {
 346
 347         assert_return(m, -EINVAL);
 348
 349         return MONITOR_TO_FD(m);
 350 }
 351
 352 _public_ int sd_network_monitor_get_events(sd_network_monitor *m) {
 353
 354         assert_return(m, -EINVAL);
 355
 356         /* For now we will only return POLLIN here, since we don't
 357          * need anything else ever for inotify.  However, let's have
 358          * this API to keep our options open should we later on need
 359          * it. */
 360         return POLLIN;
 361 }
 362
 363 _public_ int sd_network_monitor_get_timeout(sd_network_monitor *m, uint64_t *timeout_usec) {
 364
 365         assert_return(m, -EINVAL);
 366         assert_return(timeout_usec, -EINVAL);
 367
 368         /* For now we will only return (uint64_t) -1, since we don't
 369          * need any timeout. However, let's have this API to keep our
 370          * options open should we later on need it. */
 371         *timeout_usec = (uint64_t) -1;
 372         return 0;
 373 }