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

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <poll.h>
   5 #include <sys/inotify.h>
   6
   7 #include "sd-network.h"
   8
   9 #include "alloc-util.h"
  10 #include "env-file.h"
  11 #include "fd-util.h"
  12 #include "fs-util.h"
  13 #include "macro.h"
  14 #include "parse-util.h"
  15 #include "stdio-util.h"
  16 #include "string-util.h"
  17 #include "strv.h"
  18 #include "util.h"
  19
  20 static int network_get_string(const char *field, char **ret) {
  21         _cleanup_free_ char *s = NULL;
  22         int r;
  23
  24         assert_return(ret, -EINVAL);
  25
  26         r = parse_env_file(NULL, "/run/systemd/netif/state", field, &s);
  27         if (r == -ENOENT)
  28                 return -ENODATA;
  29         if (r < 0)
  30                 return r;
  31         if (isempty(s))
  32                 return -ENODATA;
  33
  34         *ret = TAKE_PTR(s);
  35
  36         return 0;
  37 }
  38
  39 _public_ int sd_network_get_operational_state(char **state) {
  40         return network_get_string("OPER_STATE", state);
  41 }
  42
  43 _public_ int sd_network_get_carrier_state(char **state) {
  44         return network_get_string("CARRIER_STATE", state);
  45 }
  46
  47 _public_ int sd_network_get_address_state(char **state) {
  48         return network_get_string("ADDRESS_STATE", state);
  49 }
  50
  51 _public_ int sd_network_get_ipv4_address_state(char **state) {
  52         return network_get_string("IPV4_ADDRESS_STATE", state);
  53 }
  54
  55 _public_ int sd_network_get_ipv6_address_state(char **state) {
  56         return network_get_string("IPV6_ADDRESS_STATE", state);
  57 }
  58
  59 static int network_get_strv(const char *key, char ***ret) {
  60         _cleanup_strv_free_ char **a = NULL;
  61         _cleanup_free_ char *s = NULL;
  62         int r;
  63
  64         assert_return(ret, -EINVAL);
  65
  66         r = parse_env_file(NULL, "/run/systemd/netif/state", key, &s);
  67         if (r == -ENOENT)
  68                 return -ENODATA;
  69         if (r < 0)
  70                 return r;
  71         if (isempty(s)) {
  72                 *ret = NULL;
  73                 return 0;
  74         }
  75
  76         a = strv_split(s, " ");
  77         if (!a)
  78                 return -ENOMEM;
  79
  80         strv_uniq(a);
  81         r = (int) strv_length(a);
  82
  83         *ret = TAKE_PTR(a);
  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         char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
 106         _cleanup_free_ char *s = NULL;
 107         int r;
 108
 109         assert_return(ifindex > 0, -EINVAL);
 110         assert_return(ret, -EINVAL);
 111
 112         xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
 113
 114         r = parse_env_file(NULL, path, field, &s);
 115         if (r == -ENOENT)
 116                 return -ENODATA;
 117         if (r < 0)
 118                 return r;
 119         if (isempty(s))
 120                 return -ENODATA;
 121
 122         *ret = TAKE_PTR(s);
 123
 124         return 0;
 125 }
 126
 127 static int network_link_get_strv(int ifindex, const char *key, char ***ret) {
 128         char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
 129         _cleanup_strv_free_ char **a = NULL;
 130         _cleanup_free_ char *s = NULL;
 131         int r;
 132
 133         assert_return(ifindex > 0, -EINVAL);
 134         assert_return(ret, -EINVAL);
 135
 136         xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
 137         r = parse_env_file(NULL, path, key, &s);
 138         if (r == -ENOENT)
 139                 return -ENODATA;
 140         if (r < 0)
 141                 return r;
 142         if (isempty(s)) {
 143                 *ret = NULL;
 144                 return 0;
 145         }
 146
 147         a = strv_split(s, " ");
 148         if (!a)
 149                 return -ENOMEM;
 150
 151         strv_uniq(a);
 152         r = (int) strv_length(a);
 153
 154         *ret = TAKE_PTR(a);
 155
 156         return r;
 157 }
 158
 159 _public_ int sd_network_link_get_setup_state(int ifindex, char **state) {
 160         return network_link_get_string(ifindex, "ADMIN_STATE", state);
 161 }
 162
 163 _public_ int sd_network_link_get_network_file(int ifindex, char **filename) {
 164         return network_link_get_string(ifindex, "NETWORK_FILE", filename);
 165 }
 166
 167 _public_ int sd_network_link_get_operational_state(int ifindex, char **state) {
 168         return network_link_get_string(ifindex, "OPER_STATE", state);
 169 }
 170
 171 _public_ int sd_network_link_get_required_family_for_online(int ifindex, char **state) {
 172         _cleanup_free_ char *s = NULL;
 173         int r;
 174
 175         assert_return(state, -EINVAL);
 176
 177         r = network_link_get_string(ifindex, "REQUIRED_FAMILY_FOR_ONLINE", &s);
 178         if (r < 0) {
 179                 if (r != -ENODATA)
 180                         return r;
 181
 182                 s = strdup("any");
 183                 if (!s)
 184                         return -ENOMEM;
 185         }
 186
 187         *state = TAKE_PTR(s);
 188         return 0;
 189 }
 190
 191 _public_ int sd_network_link_get_carrier_state(int ifindex, char **state) {
 192         return network_link_get_string(ifindex, "CARRIER_STATE", state);
 193 }
 194
 195 _public_ int sd_network_link_get_address_state(int ifindex, char **state) {
 196         return network_link_get_string(ifindex, "ADDRESS_STATE", state);
 197 }
 198
 199 _public_ int sd_network_link_get_ipv4_address_state(int ifindex, char **state) {
 200         return network_link_get_string(ifindex, "IPV4_ADDRESS_STATE", state);
 201 }
 202
 203 _public_ int sd_network_link_get_ipv6_address_state(int ifindex, char **state) {
 204         return network_link_get_string(ifindex, "IPV6_ADDRESS_STATE", state);
 205 }
 206
 207 _public_ int sd_network_link_get_dhcp6_client_iaid_string(int ifindex, char **iaid) {
 208         return network_link_get_string(ifindex, "DHCP6_CLIENT_IAID", iaid);
 209 }
 210
 211 _public_ int sd_network_link_get_dhcp6_client_duid_string(int ifindex, char **duid) {
 212         return network_link_get_string(ifindex, "DHCP6_CLIENT_DUID", duid);
 213 }
 214
 215 _public_ int sd_network_link_get_required_for_online(int ifindex) {
 216         _cleanup_free_ char *s = NULL;
 217         int r;
 218
 219         r = network_link_get_string(ifindex, "REQUIRED_FOR_ONLINE", &s);
 220         if (r < 0) {
 221                 /* Handle -ENODATA as RequiredForOnline=yes, for compatibility */
 222                 if (r == -ENODATA)
 223                         return true;
 224                 return r;
 225         }
 226
 227         return parse_boolean(s);
 228 }
 229
 230 _public_ int sd_network_link_get_required_operstate_for_online(int ifindex, char **state) {
 231         _cleanup_free_ char *s = NULL;
 232         int r;
 233
 234         assert_return(state, -EINVAL);
 235
 236         r = network_link_get_string(ifindex, "REQUIRED_OPER_STATE_FOR_ONLINE", &s);
 237         if (r < 0) {
 238                 if (r != -ENODATA)
 239                         return r;
 240
 241                 /* For compatibility, assuming degraded. */
 242                 s = strdup("degraded");
 243                 if (!s)
 244                         return -ENOMEM;
 245         }
 246
 247         *state = TAKE_PTR(s);
 248         return 0;
 249 }
 250
 251 _public_ int sd_network_link_get_activation_policy(int ifindex, char **policy) {
 252         _cleanup_free_ char *s = NULL;
 253         int r;
 254
 255         assert_return(policy, -EINVAL);
 256
 257         r = network_link_get_string(ifindex, "ACTIVATION_POLICY", &s);
 258         if (r < 0) {
 259                 if (r != -ENODATA)
 260                         return r;
 261
 262                 /* For compatibility, assuming up. */
 263                 s = strdup("up");
 264                 if (!s)
 265                         return -ENOMEM;
 266         }
 267
 268         *policy = TAKE_PTR(s);
 269         return 0;
 270 }
 271
 272 _public_ int sd_network_link_get_llmnr(int ifindex, char **llmnr) {
 273         return network_link_get_string(ifindex, "LLMNR", llmnr);
 274 }
 275
 276 _public_ int sd_network_link_get_mdns(int ifindex, char **mdns) {
 277         return network_link_get_string(ifindex, "MDNS", mdns);
 278 }
 279
 280 _public_ int sd_network_link_get_dns_over_tls(int ifindex, char **dns_over_tls) {
 281         return network_link_get_string(ifindex, "DNS_OVER_TLS", dns_over_tls);
 282 }
 283
 284 _public_ int sd_network_link_get_dnssec(int ifindex, char **dnssec) {
 285         return network_link_get_string(ifindex, "DNSSEC", dnssec);
 286 }
 287
 288 _public_ int sd_network_link_get_dnssec_negative_trust_anchors(int ifindex, char ***nta) {
 289         return network_link_get_strv(ifindex, "DNSSEC_NTA", nta);
 290 }
 291
 292 _public_ int sd_network_link_get_dns(int ifindex, char ***ret) {
 293         return network_link_get_strv(ifindex, "DNS", ret);
 294 }
 295
 296 _public_ int sd_network_link_get_ntp(int ifindex, char ***ret) {
 297         return network_link_get_strv(ifindex, "NTP", ret);
 298 }
 299
 300 _public_ int sd_network_link_get_sip(int ifindex, char ***ret) {
 301         return network_link_get_strv(ifindex, "SIP", ret);
 302 }
 303
 304 _public_ int sd_network_link_get_search_domains(int ifindex, char ***ret) {
 305         return network_link_get_strv(ifindex, "DOMAINS", ret);
 306 }
 307
 308 _public_ int sd_network_link_get_route_domains(int ifindex, char ***ret) {
 309         return network_link_get_strv(ifindex, "ROUTE_DOMAINS", ret);
 310 }
 311
 312 _public_ int sd_network_link_get_dns_default_route(int ifindex) {
 313         char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
 314         _cleanup_free_ char *s = NULL;
 315         int r;
 316
 317         assert_return(ifindex > 0, -EINVAL);
 318
 319         xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
 320
 321         r = parse_env_file(NULL, path, "DNS_DEFAULT_ROUTE", &s);
 322         if (r == -ENOENT)
 323                 return -ENODATA;
 324         if (r < 0)
 325                 return r;
 326         if (isempty(s))
 327                 return -ENODATA;
 328         return parse_boolean(s);
 329 }
 330
 331 static int network_link_get_ifindexes(int ifindex, const char *key, int **ret) {
 332         char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
 333         _cleanup_free_ int *ifis = NULL;
 334         _cleanup_free_ char *s = NULL;
 335         size_t allocated = 0, c = 0;
 336         int r;
 337
 338         assert_return(ifindex > 0, -EINVAL);
 339         assert_return(ret, -EINVAL);
 340
 341         xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
 342         r = parse_env_file(NULL, path, key, &s);
 343         if (r == -ENOENT)
 344                 return -ENODATA;
 345         if (r < 0)
 346                 return r;
 347
 348         for (const char *x = s;;) {
 349                 _cleanup_free_ char *word = NULL;
 350
 351                 r = extract_first_word(&x, &word, NULL, 0);
 352                 if (r < 0)
 353                         return r;
 354                 if (r == 0)
 355                         break;
 356
 357                 if (!GREEDY_REALLOC(ifis, allocated, c + 2))
 358                         return -ENOMEM;
 359
 360                 r = ifis[c++] = parse_ifindex(word);
 361                 if (r < 0)
 362                         return r;
 363         }
 364
 365         if (ifis)
 366                 ifis[c] = 0; /* Let's add a 0 ifindex to the end, to be nice */
 367
 368         *ret = TAKE_PTR(ifis);
 369
 370         return c;
 371 }
 372
 373 _public_ int sd_network_link_get_carrier_bound_to(int ifindex, int **ret) {
 374         return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_TO", ret);
 375 }
 376
 377 _public_ int sd_network_link_get_carrier_bound_by(int ifindex, int **ret) {
 378         return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_BY", ret);
 379 }
 380
 381 static int MONITOR_TO_FD(sd_network_monitor *m) {
 382         return (int) (unsigned long) m - 1;
 383 }
 384
 385 static sd_network_monitor* FD_TO_MONITOR(int fd) {
 386         return (sd_network_monitor*) (unsigned long) (fd + 1);
 387 }
 388
 389 static int monitor_add_inotify_watch(int fd) {
 390         int k;
 391
 392         k = inotify_add_watch(fd, "/run/systemd/netif/links/", IN_MOVED_TO|IN_DELETE);
 393         if (k >= 0)
 394                 return 0;
 395         else if (errno != ENOENT)
 396                 return -errno;
 397
 398         k = inotify_add_watch(fd, "/run/systemd/netif/", IN_CREATE|IN_ISDIR);
 399         if (k >= 0)
 400                 return 0;
 401         else if (errno != ENOENT)
 402                 return -errno;
 403
 404         k = inotify_add_watch(fd, "/run/systemd/", IN_CREATE|IN_ISDIR);
 405         if (k < 0)
 406                 return -errno;
 407
 408         return 0;
 409 }
 410
 411 _public_ int sd_network_monitor_new(sd_network_monitor **m, const char *category) {
 412         _cleanup_close_ int fd = -1;
 413         int k;
 414         bool good = false;
 415
 416         assert_return(m, -EINVAL);
 417
 418         fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
 419         if (fd < 0)
 420                 return -errno;
 421
 422         if (!category || streq(category, "links")) {
 423                 k = monitor_add_inotify_watch(fd);
 424                 if (k < 0)
 425                         return k;
 426
 427                 good = true;
 428         }
 429
 430         if (!good)
 431                 return -EINVAL;
 432
 433         *m = FD_TO_MONITOR(TAKE_FD(fd));
 434         return 0;
 435 }
 436
 437 _public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
 438         if (m)
 439                 close_nointr(MONITOR_TO_FD(m));
 440
 441         return NULL;
 442 }
 443
 444 _public_ int sd_network_monitor_flush(sd_network_monitor *m) {
 445         union inotify_event_buffer buffer;
 446         struct inotify_event *e;
 447         ssize_t l;
 448         int fd, k;
 449
 450         assert_return(m, -EINVAL);
 451
 452         fd = MONITOR_TO_FD(m);
 453
 454         l = read(fd, &buffer, sizeof(buffer));
 455         if (l < 0) {
 456                 if (IN_SET(errno, EAGAIN, EINTR))
 457                         return 0;
 458
 459                 return -errno;
 460         }
 461
 462         FOREACH_INOTIFY_EVENT(e, buffer, l) {
 463                 if (e->mask & IN_ISDIR) {
 464                         k = monitor_add_inotify_watch(fd);
 465                         if (k < 0)
 466                                 return k;
 467
 468                         k = inotify_rm_watch(fd, e->wd);
 469                         if (k < 0)
 470                                 return -errno;
 471                 }
 472         }
 473
 474         return 0;
 475 }
 476
 477 _public_ int sd_network_monitor_get_fd(sd_network_monitor *m) {
 478
 479         assert_return(m, -EINVAL);
 480
 481         return MONITOR_TO_FD(m);
 482 }
 483
 484 _public_ int sd_network_monitor_get_events(sd_network_monitor *m) {
 485
 486         assert_return(m, -EINVAL);
 487
 488         /* For now we will only return POLLIN here, since we don't
 489          * need anything else ever for inotify.  However, let's have
 490          * this API to keep our options open should we later on need
 491          * it. */
 492         return POLLIN;
 493 }
 494
 495 _public_ int sd_network_monitor_get_timeout(sd_network_monitor *m, uint64_t *timeout_usec) {
 496
 497         assert_return(m, -EINVAL);
 498         assert_return(timeout_usec, -EINVAL);
 499
 500         /* For now we will only return UINT64_MAX, since we don't
 501          * need any timeout. However, let's have this API to keep our
 502          * options open should we later on need it. */
 503         *timeout_usec = UINT64_MAX;
 504         return 0;
 505 }