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