src/network/networkd-manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20  ***/
  21
  22 #include <sys/socket.h>
  23 #include <linux/if.h>
  24
  25 #include "conf-parser.h"
  26 #include "path-util.h"
  27 #include "networkd.h"
  28 #include "networkd-netdev.h"
  29 #include "networkd-link.h"
  30 #include "network-internal.h"
  31 #include "libudev-private.h"
  32 #include "udev-util.h"
  33 #include "rtnl-util.h"
  34 #include "mkdir.h"
  35 #include "virt.h"
  36
  37 #include "sd-rtnl.h"
  38 #include "sd-daemon.h"
  39
  40 /* use 8 MB for receive socket kernel queue. */
  41 #define RCVBUF_SIZE    (8*1024*1024)
  42
  43 const char* const network_dirs[] = {
  44         "/etc/systemd/network",
  45         "/run/systemd/network",
  46         "/usr/lib/systemd/network",
  47 #ifdef HAVE_SPLIT_USR
  48         "/lib/systemd/network",
  49 #endif
  50         NULL};
  51
  52 static int setup_default_address_pool(Manager *m) {
  53         AddressPool *p;
  54         int r;
  55
  56         assert(m);
  57
  58         /* Add in the well-known private address ranges. */
  59
  60         r = address_pool_new_from_string(m, &p, AF_INET6, "fc00::", 7);
  61         if (r < 0)
  62                 return r;
  63
  64         r = address_pool_new_from_string(m, &p, AF_INET, "192.168.0.0", 16);
  65         if (r < 0)
  66                 return r;
  67
  68         r = address_pool_new_from_string(m, &p, AF_INET, "172.16.0.0", 12);
  69         if (r < 0)
  70                 return r;
  71
  72         r = address_pool_new_from_string(m, &p, AF_INET, "10.0.0.0", 8);
  73         if (r < 0)
  74                 return r;
  75
  76         return 0;
  77 }
  78
  79 int manager_connect_bus(Manager *m);
  80
  81 static int on_bus_retry(sd_event_source *s, usec_t usec, void *userdata) {
  82         Manager *m = userdata;
  83
  84         assert(s);
  85         assert(m);
  86
  87         m->bus_retry_event_source = sd_event_source_unref(m->bus_retry_event_source);
  88
  89         manager_connect_bus(m);
  90
  91         return 0;
  92 }
  93
  94 static int manager_reset_all(Manager *m) {
  95         Link *link;
  96         Iterator i;
  97         int r;
  98
  99         assert(m);
 100
 101         HASHMAP_FOREACH(link, m->links, i) {
 102                 r = link_carrier_reset(link);
 103                 if (r < 0)
 104                         log_link_warning_errno(link, r, "could not reset carrier: %m");
 105         }
 106
 107         return 0;
 108 }
 109
 110 static int match_prepare_for_sleep(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
 111         Manager *m = userdata;
 112         int b, r;
 113
 114         assert(bus);
 115         assert(bus);
 116
 117         r = sd_bus_message_read(message, "b", &b);
 118         if (r < 0) {
 119                 log_debug_errno(r, "Failed to parse PrepareForSleep signal: %m");
 120                 return 0;
 121         }
 122
 123         if (b)
 124                 return 0;
 125
 126         log_debug("Coming back from suspend, resetting all connections...");
 127
 128         manager_reset_all(m);
 129
 130         return 0;
 131 }
 132
 133 int manager_connect_bus(Manager *m) {
 134         int r;
 135
 136         assert(m);
 137
 138         r = sd_bus_default_system(&m->bus);
 139         if (r == -ENOENT) {
 140                 /* We failed to connect? Yuck, we must be in early
 141                  * boot. Let's try in 5s again. As soon as we have
 142                  * kdbus we can stop doing this... */
 143
 144                 log_debug_errno(r, "Failed to connect to bus, trying again in 5s: %m");
 145
 146                 r = sd_event_add_time(m->event, &m->bus_retry_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 5*USEC_PER_SEC, 0, on_bus_retry, m);
 147                 if (r < 0)
 148                         return log_error_errno(r, "Failed to install bus reconnect time event: %m");
 149
 150                 return 0;
 151         } if (r < 0)
 152                 return r;
 153
 154         r = sd_bus_attach_event(m->bus, m->event, 0);
 155         if (r < 0)
 156                 return r;
 157
 158         r = sd_bus_add_match(m->bus, &m->prepare_for_sleep_slot,
 159                              "type='signal',"
 160                              "sender='org.freedesktop.login1',"
 161                              "interface='org.freedesktop.login1.Manager',"
 162                              "member='PrepareForSleep',"
 163                              "path='/org/freedesktop/login1'",
 164                              match_prepare_for_sleep,
 165                              m);
 166         if (r < 0)
 167                 return log_error_errno(r, "Failed to add match for PrepareForSleep: %m");
 168
 169         return 0;
 170 }
 171
 172 static int manager_udev_process_link(Manager *m, struct udev_device *device) {
 173         Link *link = NULL;
 174         int r, ifindex;
 175
 176         assert(m);
 177         assert(device);
 178
 179         if (!streq_ptr(udev_device_get_action(device), "add"))
 180                 return 0;
 181
 182         ifindex = udev_device_get_ifindex(device);
 183         if (ifindex <= 0) {
 184                 log_debug("ignoring udev ADD event for device with invalid ifindex");
 185                 return 0;
 186         }
 187
 188         r = link_get(m, ifindex, &link);
 189         if (r == -ENODEV)
 190                 return 0;
 191         else if (r < 0)
 192                 return r;
 193
 194         r = link_initialized(link, device);
 195         if (r < 0)
 196                 return r;
 197
 198         return 0;
 199 }
 200
 201 static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 202         Manager *m = userdata;
 203         struct udev_monitor *monitor = m->udev_monitor;
 204         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 205
 206         device = udev_monitor_receive_device(monitor);
 207         if (!device)
 208                 return -ENOMEM;
 209
 210         manager_udev_process_link(m, device);
 211         return 0;
 212 }
 213
 214 static int manager_connect_udev(Manager *m) {
 215         int r;
 216
 217         /* udev does not initialize devices inside containers,
 218          * so we rely on them being already initialized before
 219          * entering the container */
 220         if (detect_container(NULL) > 0)
 221                 return 0;
 222
 223         m->udev = udev_new();
 224         if (!m->udev)
 225                 return -ENOMEM;
 226
 227         m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 228         if (!m->udev_monitor)
 229                 return -ENOMEM;
 230
 231         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "net", NULL);
 232         if (r < 0)
 233                 return log_error_errno(r, "Could not add udev monitor filter: %m");
 234
 235         r = udev_monitor_enable_receiving(m->udev_monitor);
 236         if (r < 0) {
 237                 log_error("Could not enable udev monitor");
 238                 return r;
 239         }
 240
 241         r = sd_event_add_io(m->event,
 242                         &m->udev_event_source,
 243                         udev_monitor_get_fd(m->udev_monitor),
 244                         EPOLLIN, manager_dispatch_link_udev,
 245                         m);
 246         if (r < 0)
 247                 return r;
 248
 249         r = sd_event_source_set_description(m->udev_event_source, "networkd-udev");
 250         if (r < 0)
 251                 return r;
 252
 253         return 0;
 254 }
 255
 256 static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
 257         Manager *m = userdata;
 258         Link *link = NULL;
 259         NetDev *netdev = NULL;
 260         uint16_t type;
 261         const char *name;
 262         int r, ifindex;
 263
 264         assert(rtnl);
 265         assert(message);
 266         assert(m);
 267
 268         if (sd_rtnl_message_is_error(message)) {
 269                 r = sd_rtnl_message_get_errno(message);
 270                 if (r < 0)
 271                         log_warning_errno(r, "rtnl: could not receive link: %m");
 272
 273                 return 0;
 274         }
 275
 276         r = sd_rtnl_message_get_type(message, &type);
 277         if (r < 0) {
 278                 log_warning_errno(r, "rtnl: could not get message type: %m");
 279                 return 0;
 280         }
 281
 282         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 283         if (r < 0) {
 284                 log_warning_errno(r, "rtnl: could not get ifindex: %m");
 285                 return 0;
 286         } else if (ifindex <= 0) {
 287                 log_warning("rtnl: received link message with invalid ifindex: %d", ifindex);
 288                 return 0;
 289         } else
 290                 link_get(m, ifindex, &link);
 291
 292         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
 293         if (r < 0) {
 294                 log_warning_errno(r, "rtnl: received link message without ifname: %m");
 295                 return 0;
 296         } else
 297                 netdev_get(m, name, &netdev);
 298
 299         switch (type) {
 300         case RTM_NEWLINK:
 301                 if (!link) {
 302                         /* link is new, so add it */
 303                         r = link_add(m, message, &link);
 304                         if (r < 0) {
 305                                 log_warning_errno(r, "could not add new link: %m");
 306                                 return 0;
 307                         }
 308                 }
 309
 310                 if (netdev) {
 311                         /* netdev exists, so make sure the ifindex matches */
 312                         r = netdev_set_ifindex(netdev, message);
 313                         if (r < 0) {
 314                                 log_warning_errno(r, "could not set ifindex on netdev: %m");
 315                                 return 0;
 316                         }
 317                 }
 318
 319                 r = link_update(link, message);
 320                 if (r < 0)
 321                         return 0;
 322
 323                 break;
 324
 325         case RTM_DELLINK:
 326                 link_drop(link);
 327                 netdev_drop(netdev);
 328
 329                 break;
 330
 331         default:
 332                 assert_not_reached("Received invalid RTNL message type.");
 333         }
 334
 335         return 1;
 336 }
 337
 338 static int systemd_netlink_fd(void) {
 339         int n, fd, rtnl_fd = -EINVAL;
 340
 341         n = sd_listen_fds(true);
 342         if (n <= 0)
 343                 return -EINVAL;
 344
 345         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) {
 346                 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
 347                         if (rtnl_fd >= 0)
 348                                 return -EINVAL;
 349
 350                         rtnl_fd = fd;
 351                 }
 352         }
 353
 354         return rtnl_fd;
 355 }
 356
 357 static int manager_connect_rtnl(Manager *m) {
 358         int fd, r;
 359
 360         assert(m);
 361
 362         fd = systemd_netlink_fd();
 363         if (fd < 0)
 364                 r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
 365         else
 366                 r = sd_rtnl_open_fd(&m->rtnl, fd, 0);
 367         if (r < 0)
 368                 return r;
 369
 370         r = sd_rtnl_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
 371         if (r < 0)
 372                 return r;
 373
 374         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
 375         if (r < 0)
 376                 return r;
 377
 378         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
 379         if (r < 0)
 380                 return r;
 381
 382         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
 383         if (r < 0)
 384                 return r;
 385
 386         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
 387         if (r < 0)
 388                 return r;
 389
 390         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
 391         if (r < 0)
 392                 return r;
 393
 394         return 0;
 395 }
 396
 397 int manager_new(Manager **ret) {
 398         _cleanup_manager_free_ Manager *m = NULL;
 399         int r;
 400
 401         m = new0(Manager, 1);
 402         if (!m)
 403                 return -ENOMEM;
 404
 405         m->state_file = strdup("/run/systemd/netif/state");
 406         if (!m->state_file)
 407                 return -ENOMEM;
 408
 409         r = sd_event_default(&m->event);
 410         if (r < 0)
 411                 return r;
 412
 413         sd_event_set_watchdog(m->event, true);
 414
 415         sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
 416         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
 417
 418         r = manager_connect_rtnl(m);
 419         if (r < 0)
 420                 return r;
 421
 422         r = manager_connect_bus(m);
 423         if (r < 0)
 424                 return r;
 425
 426         r = manager_connect_udev(m);
 427         if (r < 0)
 428                 return r;
 429
 430         m->netdevs = hashmap_new(&string_hash_ops);
 431         if (!m->netdevs)
 432                 return -ENOMEM;
 433
 434         LIST_HEAD_INIT(m->networks);
 435
 436         r = setup_default_address_pool(m);
 437         if (r < 0)
 438                 return r;
 439
 440         *ret = m;
 441         m = NULL;
 442
 443         return 0;
 444 }
 445
 446 void manager_free(Manager *m) {
 447         Network *network;
 448         NetDev *netdev;
 449         Link *link;
 450         AddressPool *pool;
 451
 452         if (!m)
 453                 return;
 454
 455         free(m->state_file);
 456
 457         udev_monitor_unref(m->udev_monitor);
 458         udev_unref(m->udev);
 459         sd_bus_unref(m->bus);
 460         sd_bus_slot_unref(m->prepare_for_sleep_slot);
 461         sd_event_source_unref(m->udev_event_source);
 462         sd_event_source_unref(m->bus_retry_event_source);
 463         sd_event_unref(m->event);
 464
 465         while ((link = hashmap_first(m->links)))
 466                 link_unref(link);
 467         hashmap_free(m->links);
 468
 469         while ((network = m->networks))
 470                 network_free(network);
 471
 472         while ((netdev = hashmap_first(m->netdevs)))
 473                 netdev_unref(netdev);
 474         hashmap_free(m->netdevs);
 475
 476         while ((pool = m->address_pools))
 477                 address_pool_free(pool);
 478
 479         sd_rtnl_unref(m->rtnl);
 480
 481         free(m);
 482 }
 483
 484 int manager_load_config(Manager *m) {
 485         int r;
 486
 487         /* update timestamp */
 488         paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, true);
 489
 490         r = netdev_load(m);
 491         if (r < 0)
 492                 return r;
 493
 494         r = network_load(m);
 495         if (r < 0)
 496                 return r;
 497
 498         return 0;
 499 }
 500
 501 bool manager_should_reload(Manager *m) {
 502         return paths_check_timestamp(network_dirs, &m->network_dirs_ts_usec, false);
 503 }
 504
 505 int manager_rtnl_enumerate_links(Manager *m) {
 506         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 507         sd_rtnl_message *link;
 508         int r;
 509
 510         assert(m);
 511         assert(m->rtnl);
 512
 513         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
 514         if (r < 0)
 515                 return r;
 516
 517         r = sd_rtnl_message_request_dump(req, true);
 518         if (r < 0)
 519                 return r;
 520
 521         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 522         if (r < 0)
 523                 return r;
 524
 525         for (link = reply; link; link = sd_rtnl_message_next(link)) {
 526                 int k;
 527
 528                 k = manager_rtnl_process_link(m->rtnl, link, m);
 529                 if (k < 0)
 530                         r = k;
 531         }
 532
 533         return r;
 534 }
 535
 536 int manager_rtnl_enumerate_addresses(Manager *m) {
 537         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 538         sd_rtnl_message *addr;
 539         int r;
 540
 541         assert(m);
 542         assert(m->rtnl);
 543
 544         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
 545         if (r < 0)
 546                 return r;
 547
 548         r = sd_rtnl_message_request_dump(req, true);
 549         if (r < 0)
 550                 return r;
 551
 552         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 553         if (r < 0)
 554                 return r;
 555
 556         for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
 557                 int k;
 558
 559                 k = link_rtnl_process_address(m->rtnl, addr, m);
 560                 if (k < 0)
 561                         r = k;
 562         }
 563
 564         return r;
 565 }
 566
 567 static int set_put_in_addr(Set *s, const struct in_addr *address) {
 568         char *p;
 569         int r;
 570
 571         assert(s);
 572
 573         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 574         if (r < 0)
 575                 return r;
 576
 577         r = set_consume(s, p);
 578         if (r == -EEXIST)
 579                 return 0;
 580
 581         return r;
 582 }
 583
 584 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
 585         int r, i, c = 0;
 586
 587         assert(s);
 588         assert(n <= 0 || addresses);
 589
 590         for (i = 0; i < n; i++) {
 591                 r = set_put_in_addr(s, addresses+i);
 592                 if (r < 0)
 593                         return r;
 594
 595                 c += r;
 596         }
 597
 598         return c;
 599 }
 600
 601 static void print_string_set(FILE *f, const char *field, Set *s) {
 602         bool space = false;
 603         Iterator i;
 604         char *p;
 605
 606         if (set_isempty(s))
 607                 return;
 608
 609         fputs(field, f);
 610
 611         SET_FOREACH(p, s, i) {
 612                 if (space)
 613                         fputc(' ', f);
 614                 fputs(p, f);
 615                 space = true;
 616         }
 617         fputc('\n', f);
 618 }
 619
 620 int manager_save(Manager *m) {
 621         _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
 622         Link *link;
 623         Iterator i;
 624         _cleanup_free_ char *temp_path = NULL;
 625         _cleanup_fclose_ FILE *f = NULL;
 626         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 627         const char *operstate_str;
 628         int r;
 629
 630         assert(m);
 631         assert(m->state_file);
 632
 633         /* We add all NTP and DNS server to a set, to filter out duplicates */
 634         dns = set_new(&string_hash_ops);
 635         if (!dns)
 636                 return -ENOMEM;
 637
 638         ntp = set_new(&string_hash_ops);
 639         if (!ntp)
 640                 return -ENOMEM;
 641
 642         domains = set_new(&string_hash_ops);
 643         if (!domains)
 644                 return -ENOMEM;
 645
 646         HASHMAP_FOREACH(link, m->links, i) {
 647                 if (link->flags & IFF_LOOPBACK)
 648                         continue;
 649
 650                 if (link->operstate > operstate)
 651                         operstate = link->operstate;
 652
 653                 if (!link->network)
 654                         continue;
 655
 656                 /* First add the static configured entries */
 657                 r = set_put_strdupv(dns, link->network->dns);
 658                 if (r < 0)
 659                         return r;
 660
 661                 r = set_put_strdupv(ntp, link->network->ntp);
 662                 if (r < 0)
 663                         return r;
 664
 665                 r = set_put_strdupv(domains, link->network->domains);
 666                 if (r < 0)
 667                         return r;
 668
 669                 if (!link->dhcp_lease)
 670                         continue;
 671
 672                 /* Secondly, add the entries acquired via DHCP */
 673                 if (link->network->dhcp_dns) {
 674                         const struct in_addr *addresses;
 675
 676                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 677                         if (r > 0) {
 678                                 r = set_put_in_addrv(dns, addresses, r);
 679                                 if (r < 0)
 680                                         return r;
 681                         } else if (r < 0 && r != -ENOENT)
 682                                 return r;
 683                 }
 684
 685                 if (link->network->dhcp_ntp) {
 686                         const struct in_addr *addresses;
 687
 688                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 689                         if (r > 0) {
 690                                 r = set_put_in_addrv(ntp, addresses, r);
 691                                 if (r < 0)
 692                                         return r;
 693                         } else if (r < 0 && r != -ENOENT)
 694                                 return r;
 695                 }
 696
 697                 if (link->network->dhcp_domains) {
 698                         const char *domainname;
 699
 700                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 701                         if (r >= 0) {
 702                                 r = set_put_strdup(domains, domainname);
 703                                 if (r < 0)
 704                                         return r;
 705                         } else if (r != -ENOENT)
 706                                 return r;
 707                 }
 708         }
 709
 710         operstate_str = link_operstate_to_string(operstate);
 711         assert(operstate_str);
 712
 713         r = fopen_temporary(m->state_file, &f, &temp_path);
 714         if (r < 0)
 715                 return r;
 716
 717         fchmod(fileno(f), 0644);
 718
 719         fprintf(f,
 720                 "# This is private data. Do not parse.\n"
 721                 "OPER_STATE=%s\n", operstate_str);
 722
 723         print_string_set(f, "DNS=", dns);
 724         print_string_set(f, "NTP=", ntp);
 725         print_string_set(f, "DOMAINS=", domains);
 726
 727         r = fflush_and_check(f);
 728         if (r < 0)
 729                 goto fail;
 730
 731         if (rename(temp_path, m->state_file) < 0) {
 732                 r = -errno;
 733                 goto fail;
 734         }
 735
 736         return 0;
 737
 738 fail:
 739         log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 740         unlink(m->state_file);
 741         unlink(temp_path);
 742         return r;
 743 }
 744
 745 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
 746         AddressPool *p;
 747         int r;
 748
 749         assert(m);
 750         assert(prefixlen > 0);
 751         assert(found);
 752
 753         LIST_FOREACH(address_pools, p, m->address_pools) {
 754                 if (p->family != family)
 755                         continue;
 756
 757                 r = address_pool_acquire(p, prefixlen, found);
 758                 if (r != 0)
 759                         return r;
 760         }
 761
 762         return 0;
 763 }
 764
 765 const char *address_family_boolean_to_string(AddressFamilyBoolean b) {
 766         if (b == ADDRESS_FAMILY_YES ||
 767             b == ADDRESS_FAMILY_NO)
 768                 return yes_no(b == ADDRESS_FAMILY_YES);
 769
 770         if (b == ADDRESS_FAMILY_IPV4)
 771                 return "ipv4";
 772         if (b == ADDRESS_FAMILY_IPV6)
 773                 return "ipv6";
 774
 775         return NULL;
 776 }
 777
 778 AddressFamilyBoolean address_family_boolean_from_string(const char *s) {
 779         int r;
 780
 781         /* Make this a true superset of a boolean */
 782
 783         r = parse_boolean(s);
 784         if (r > 0)
 785                 return ADDRESS_FAMILY_YES;
 786         if (r == 0)
 787                 return ADDRESS_FAMILY_NO;
 788
 789         if (streq(s, "ipv4"))
 790                 return ADDRESS_FAMILY_IPV4;
 791         if (streq(s, "ipv6"))
 792                 return ADDRESS_FAMILY_IPV6;
 793
 794         return _ADDRESS_FAMILY_BOOLEAN_INVALID;
 795 }
 796
 797 DEFINE_CONFIG_PARSE_ENUM(config_parse_address_family_boolean, address_family_boolean, AddressFamilyBoolean, "Failed to parse option");