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                 m->enumerating = true;
 529
 530                 k = manager_rtnl_process_link(m->rtnl, link, m);
 531                 if (k < 0)
 532                         r = k;
 533
 534                 m->enumerating = false;
 535         }
 536
 537         return r;
 538 }
 539
 540 int manager_rtnl_enumerate_addresses(Manager *m) {
 541         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
 542         sd_rtnl_message *addr;
 543         int r;
 544
 545         assert(m);
 546         assert(m->rtnl);
 547
 548         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, 0);
 549         if (r < 0)
 550                 return r;
 551
 552         r = sd_rtnl_message_request_dump(req, true);
 553         if (r < 0)
 554                 return r;
 555
 556         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
 557         if (r < 0)
 558                 return r;
 559
 560         for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
 561                 int k;
 562
 563                 m->enumerating = true;
 564
 565                 k = link_rtnl_process_address(m->rtnl, addr, m);
 566                 if (k < 0)
 567                         r = k;
 568
 569                 m->enumerating = false;
 570         }
 571
 572         return r;
 573 }
 574
 575 static int set_put_in_addr(Set *s, const struct in_addr *address) {
 576         char *p;
 577         int r;
 578
 579         assert(s);
 580
 581         r = in_addr_to_string(AF_INET, (const union in_addr_union*) address, &p);
 582         if (r < 0)
 583                 return r;
 584
 585         r = set_consume(s, p);
 586         if (r == -EEXIST)
 587                 return 0;
 588
 589         return r;
 590 }
 591
 592 static int set_put_in_addrv(Set *s, const struct in_addr *addresses, int n) {
 593         int r, i, c = 0;
 594
 595         assert(s);
 596         assert(n <= 0 || addresses);
 597
 598         for (i = 0; i < n; i++) {
 599                 r = set_put_in_addr(s, addresses+i);
 600                 if (r < 0)
 601                         return r;
 602
 603                 c += r;
 604         }
 605
 606         return c;
 607 }
 608
 609 static void print_string_set(FILE *f, const char *field, Set *s) {
 610         bool space = false;
 611         Iterator i;
 612         char *p;
 613
 614         if (set_isempty(s))
 615                 return;
 616
 617         fputs(field, f);
 618
 619         SET_FOREACH(p, s, i) {
 620                 if (space)
 621                         fputc(' ', f);
 622                 fputs(p, f);
 623                 space = true;
 624         }
 625         fputc('\n', f);
 626 }
 627
 628 int manager_save(Manager *m) {
 629         _cleanup_set_free_free_ Set *dns = NULL, *ntp = NULL, *domains = NULL;
 630         Link *link;
 631         Iterator i;
 632         _cleanup_free_ char *temp_path = NULL;
 633         _cleanup_fclose_ FILE *f = NULL;
 634         LinkOperationalState operstate = LINK_OPERSTATE_OFF;
 635         const char *operstate_str;
 636         int r;
 637
 638         assert(m);
 639         assert(m->state_file);
 640
 641         /* We add all NTP and DNS server to a set, to filter out duplicates */
 642         dns = set_new(&string_hash_ops);
 643         if (!dns)
 644                 return -ENOMEM;
 645
 646         ntp = set_new(&string_hash_ops);
 647         if (!ntp)
 648                 return -ENOMEM;
 649
 650         domains = set_new(&string_hash_ops);
 651         if (!domains)
 652                 return -ENOMEM;
 653
 654         HASHMAP_FOREACH(link, m->links, i) {
 655                 if (link->flags & IFF_LOOPBACK)
 656                         continue;
 657
 658                 if (link->operstate > operstate)
 659                         operstate = link->operstate;
 660
 661                 if (!link->network)
 662                         continue;
 663
 664                 /* First add the static configured entries */
 665                 r = set_put_strdupv(dns, link->network->dns);
 666                 if (r < 0)
 667                         return r;
 668
 669                 r = set_put_strdupv(ntp, link->network->ntp);
 670                 if (r < 0)
 671                         return r;
 672
 673                 r = set_put_strdupv(domains, link->network->domains);
 674                 if (r < 0)
 675                         return r;
 676
 677                 if (!link->dhcp_lease)
 678                         continue;
 679
 680                 /* Secondly, add the entries acquired via DHCP */
 681                 if (link->network->dhcp_dns) {
 682                         const struct in_addr *addresses;
 683
 684                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
 685                         if (r > 0) {
 686                                 r = set_put_in_addrv(dns, addresses, r);
 687                                 if (r < 0)
 688                                         return r;
 689                         } else if (r < 0 && r != -ENOENT)
 690                                 return r;
 691                 }
 692
 693                 if (link->network->dhcp_ntp) {
 694                         const struct in_addr *addresses;
 695
 696                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
 697                         if (r > 0) {
 698                                 r = set_put_in_addrv(ntp, addresses, r);
 699                                 if (r < 0)
 700                                         return r;
 701                         } else if (r < 0 && r != -ENOENT)
 702                                 return r;
 703                 }
 704
 705                 if (link->network->dhcp_domains) {
 706                         const char *domainname;
 707
 708                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
 709                         if (r >= 0) {
 710                                 r = set_put_strdup(domains, domainname);
 711                                 if (r < 0)
 712                                         return r;
 713                         } else if (r != -ENOENT)
 714                                 return r;
 715                 }
 716         }
 717
 718         operstate_str = link_operstate_to_string(operstate);
 719         assert(operstate_str);
 720
 721         r = fopen_temporary(m->state_file, &f, &temp_path);
 722         if (r < 0)
 723                 return r;
 724
 725         fchmod(fileno(f), 0644);
 726
 727         fprintf(f,
 728                 "# This is private data. Do not parse.\n"
 729                 "OPER_STATE=%s\n", operstate_str);
 730
 731         print_string_set(f, "DNS=", dns);
 732         print_string_set(f, "NTP=", ntp);
 733         print_string_set(f, "DOMAINS=", domains);
 734
 735         r = fflush_and_check(f);
 736         if (r < 0)
 737                 goto fail;
 738
 739         if (rename(temp_path, m->state_file) < 0) {
 740                 r = -errno;
 741                 goto fail;
 742         }
 743
 744         return 0;
 745
 746 fail:
 747         log_error_errno(r, "Failed to save network state to %s: %m", m->state_file);
 748         unlink(m->state_file);
 749         unlink(temp_path);
 750         return r;
 751 }
 752
 753 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
 754         AddressPool *p;
 755         int r;
 756
 757         assert(m);
 758         assert(prefixlen > 0);
 759         assert(found);
 760
 761         LIST_FOREACH(address_pools, p, m->address_pools) {
 762                 if (p->family != family)
 763                         continue;
 764
 765                 r = address_pool_acquire(p, prefixlen, found);
 766                 if (r != 0)
 767                         return r;
 768         }
 769
 770         return 0;
 771 }
 772
 773 const char *address_family_boolean_to_string(AddressFamilyBoolean b) {
 774         if (b == ADDRESS_FAMILY_YES ||
 775             b == ADDRESS_FAMILY_NO)
 776                 return yes_no(b == ADDRESS_FAMILY_YES);
 777
 778         if (b == ADDRESS_FAMILY_IPV4)
 779                 return "ipv4";
 780         if (b == ADDRESS_FAMILY_IPV6)
 781                 return "ipv6";
 782
 783         return NULL;
 784 }
 785
 786 AddressFamilyBoolean address_family_boolean_from_string(const char *s) {
 787         int r;
 788
 789         /* Make this a true superset of a boolean */
 790
 791         r = parse_boolean(s);
 792         if (r > 0)
 793                 return ADDRESS_FAMILY_YES;
 794         if (r == 0)
 795                 return ADDRESS_FAMILY_NO;
 796
 797         if (streq(s, "ipv4"))
 798                 return ADDRESS_FAMILY_IPV4;
 799         if (streq(s, "ipv6"))
 800                 return ADDRESS_FAMILY_IPV6;
 801
 802         return _ADDRESS_FAMILY_BOOLEAN_INVALID;
 803 }
 804
 805 DEFINE_CONFIG_PARSE_ENUM(config_parse_address_family_boolean, address_family_boolean, AddressFamilyBoolean, "Failed to parse option");