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

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