src/network/networkd-radv.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2017 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <netinet/icmp6.h>
   7 #include <arpa/inet.h>
   8
   9 #include "dns-domain.h"
  10 #include "networkd-address.h"
  11 #include "networkd-manager.h"
  12 #include "networkd-radv.h"
  13 #include "parse-util.h"
  14 #include "sd-radv.h"
  15 #include "string-util.h"
  16 #include "string-table.h"
  17 #include "strv.h"
  18
  19 void prefix_free(Prefix *prefix) {
  20         if (!prefix)
  21                 return;
  22
  23         if (prefix->network) {
  24                 LIST_REMOVE(prefixes, prefix->network->static_prefixes, prefix);
  25                 assert(prefix->network->n_static_prefixes > 0);
  26                 prefix->network->n_static_prefixes--;
  27
  28                 if (prefix->section)
  29                         hashmap_remove(prefix->network->prefixes_by_section,
  30                                        prefix->section);
  31         }
  32
  33         network_config_section_free(prefix->section);
  34         prefix->radv_prefix = sd_radv_prefix_unref(prefix->radv_prefix);
  35
  36         free(prefix);
  37 }
  38
  39 int prefix_new(Prefix **ret) {
  40         _cleanup_(prefix_freep) Prefix *prefix = NULL;
  41
  42         prefix = new0(Prefix, 1);
  43         if (!prefix)
  44                 return -ENOMEM;
  45
  46         if (sd_radv_prefix_new(&prefix->radv_prefix) < 0)
  47                 return -ENOMEM;
  48
  49         *ret = TAKE_PTR(prefix);
  50
  51         return 0;
  52 }
  53
  54 static int prefix_new_static(Network *network, const char *filename,
  55                              unsigned section_line, Prefix **ret) {
  56         _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
  57         _cleanup_(prefix_freep) Prefix *prefix = NULL;
  58         int r;
  59
  60         assert(network);
  61         assert(ret);
  62         assert(!!filename == (section_line > 0));
  63
  64         if (filename) {
  65                 r = network_config_section_new(filename, section_line, &n);
  66                 if (r < 0)
  67                         return r;
  68
  69                 if (section_line) {
  70                         prefix = hashmap_get(network->prefixes_by_section, n);
  71                         if (prefix) {
  72                                 *ret = TAKE_PTR(prefix);
  73
  74                                 return 0;
  75                         }
  76                 }
  77         }
  78
  79         r = prefix_new(&prefix);
  80         if (r < 0)
  81                 return r;
  82
  83         prefix->network = network;
  84         LIST_APPEND(prefixes, network->static_prefixes, prefix);
  85         network->n_static_prefixes++;
  86
  87         if (filename) {
  88                 prefix->section = TAKE_PTR(n);
  89
  90                 r = hashmap_ensure_allocated(&network->prefixes_by_section, &network_config_hash_ops);
  91                 if (r < 0)
  92                         return r;
  93
  94                 r = hashmap_put(network->prefixes_by_section, prefix->section, prefix);
  95                 if (r < 0)
  96                         return r;
  97         }
  98
  99         *ret = TAKE_PTR(prefix);
 100
 101         return 0;
 102 }
 103
 104 int route_prefix_new(Prefix **ret) {
 105         _cleanup_(prefix_freep) Prefix *prefix = NULL;
 106
 107         prefix = new0(Prefix, 1);
 108         if (!prefix)
 109                 return -ENOMEM;
 110
 111         if (sd_radv_route_prefix_new(&prefix->radv_route_prefix) < 0)
 112                 return -ENOMEM;
 113
 114         *ret = TAKE_PTR(prefix);
 115
 116         return 0;
 117 }
 118
 119 void route_prefix_free(Prefix *prefix) {
 120         if (!prefix)
 121                 return;
 122
 123         if (prefix->network) {
 124                 LIST_REMOVE(prefixes, prefix->network->static_route_prefixes, prefix);
 125                 assert(prefix->network->n_static_route_prefixes > 0);
 126                 prefix->network->n_static_route_prefixes--;
 127
 128                 if (prefix->section)
 129                         hashmap_remove(prefix->network->route_prefixes_by_section,
 130                                        prefix->section);
 131         }
 132
 133         network_config_section_free(prefix->section);
 134
 135         free(prefix);
 136 }
 137
 138 static int route_prefix_new_static(Network *network, const char *filename,
 139                                    unsigned section_line, Prefix **ret) {
 140         _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
 141         _cleanup_(prefix_freep) Prefix *prefix = NULL;
 142         int r;
 143
 144         assert(network);
 145         assert(ret);
 146         assert(!!filename == (section_line > 0));
 147
 148         if (filename) {
 149                 r = network_config_section_new(filename, section_line, &n);
 150                 if (r < 0)
 151                         return r;
 152
 153                 if (section_line) {
 154                         prefix = hashmap_get(network->route_prefixes_by_section, n);
 155                         if (prefix) {
 156                                 *ret = TAKE_PTR(prefix);
 157
 158                                 return 0;
 159                         }
 160                 }
 161         }
 162
 163         r = route_prefix_new(&prefix);
 164         if (r < 0)
 165                 return r;
 166
 167         prefix->network = network;
 168         LIST_APPEND(prefixes, network->static_route_prefixes, prefix);
 169         network->n_static_route_prefixes++;
 170
 171         if (filename) {
 172                 prefix->section = TAKE_PTR(n);
 173
 174                 r = hashmap_ensure_allocated(&network->route_prefixes_by_section, &network_config_hash_ops);
 175                 if (r < 0)
 176                         return r;
 177
 178                 r = hashmap_put(network->route_prefixes_by_section, prefix->section, prefix);
 179                 if (r < 0)
 180                         return r;
 181         }
 182
 183         *ret = TAKE_PTR(prefix);
 184
 185         return 0;
 186 }
 187
 188 int config_parse_prefix(const char *unit,
 189                         const char *filename,
 190                         unsigned line,
 191                         const char *section,
 192                         unsigned section_line,
 193                         const char *lvalue,
 194                         int ltype,
 195                         const char *rvalue,
 196                         void *data,
 197                         void *userdata) {
 198
 199         Network *network = userdata;
 200         _cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
 201         uint8_t prefixlen = 64;
 202         union in_addr_union in6addr;
 203         int r;
 204
 205         assert(filename);
 206         assert(section);
 207         assert(lvalue);
 208         assert(rvalue);
 209         assert(data);
 210
 211         r = prefix_new_static(network, filename, section_line, &p);
 212         if (r < 0)
 213                 return r;
 214
 215         r = in_addr_prefix_from_string(rvalue, AF_INET6, &in6addr, &prefixlen);
 216         if (r < 0) {
 217                 log_syntax(unit, LOG_ERR, filename, line, r, "Prefix is invalid, ignoring assignment: %s", rvalue);
 218                 return 0;
 219         }
 220
 221         if (sd_radv_prefix_set_prefix(p->radv_prefix, &in6addr.in6, prefixlen) < 0)
 222                 return -EADDRNOTAVAIL;
 223
 224         log_syntax(unit, LOG_INFO, filename, line, r, "Found prefix %s", rvalue);
 225
 226         p = NULL;
 227
 228         return 0;
 229 }
 230
 231 int config_parse_prefix_flags(const char *unit,
 232                               const char *filename,
 233                               unsigned line,
 234                               const char *section,
 235                               unsigned section_line,
 236                               const char *lvalue,
 237                               int ltype,
 238                               const char *rvalue,
 239                               void *data,
 240                               void *userdata) {
 241         Network *network = userdata;
 242         _cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
 243         int r, val;
 244
 245         assert(filename);
 246         assert(section);
 247         assert(lvalue);
 248         assert(rvalue);
 249         assert(data);
 250
 251         r = prefix_new_static(network, filename, section_line, &p);
 252         if (r < 0)
 253                 return r;
 254
 255         r = parse_boolean(rvalue);
 256         if (r < 0) {
 257                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse address flag, ignoring: %s", rvalue);
 258                 return 0;
 259         }
 260
 261         val = r;
 262
 263         if (streq(lvalue, "OnLink"))
 264                 r = sd_radv_prefix_set_onlink(p->radv_prefix, val);
 265         else if (streq(lvalue, "AddressAutoconfiguration"))
 266                 r = sd_radv_prefix_set_address_autoconfiguration(p->radv_prefix, val);
 267         if (r < 0)
 268                 return r;
 269
 270         p = NULL;
 271
 272         return 0;
 273 }
 274
 275 int config_parse_prefix_lifetime(const char *unit,
 276                                  const char *filename,
 277                                  unsigned line,
 278                                  const char *section,
 279                                  unsigned section_line,
 280                                  const char *lvalue,
 281                                  int ltype,
 282                                  const char *rvalue,
 283                                  void *data,
 284                                  void *userdata) {
 285         Network *network = userdata;
 286         _cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
 287         usec_t usec;
 288         int r;
 289
 290         assert(filename);
 291         assert(section);
 292         assert(lvalue);
 293         assert(rvalue);
 294         assert(data);
 295
 296         r = prefix_new_static(network, filename, section_line, &p);
 297         if (r < 0)
 298                 return r;
 299
 300         r = parse_sec(rvalue, &usec);
 301         if (r < 0) {
 302                 log_syntax(unit, LOG_ERR, filename, line, r, "Lifetime is invalid, ignoring assignment: %s", rvalue);
 303                 return 0;
 304         }
 305
 306         /* a value of 0xffffffff represents infinity */
 307         if (streq(lvalue, "PreferredLifetimeSec"))
 308                 r = sd_radv_prefix_set_preferred_lifetime(p->radv_prefix,
 309                                                           DIV_ROUND_UP(usec, USEC_PER_SEC));
 310         else if (streq(lvalue, "ValidLifetimeSec"))
 311                 r = sd_radv_prefix_set_valid_lifetime(p->radv_prefix,
 312                                                       DIV_ROUND_UP(usec, USEC_PER_SEC));
 313         if (r < 0)
 314                 return r;
 315
 316         p = NULL;
 317
 318         return 0;
 319 }
 320
 321 int config_parse_route_prefix(const char *unit,
 322                               const char *filename,
 323                               unsigned line,
 324                               const char *section,
 325                               unsigned section_line,
 326                               const char *lvalue,
 327                               int ltype,
 328                               const char *rvalue,
 329                               void *data,
 330                               void *userdata) {
 331
 332         Network *network = userdata;
 333         _cleanup_(route_prefix_free_or_set_invalidp) Prefix *p = NULL;
 334         uint8_t prefixlen = 64;
 335         union in_addr_union in6addr;
 336         int r;
 337
 338         assert(filename);
 339         assert(section);
 340         assert(lvalue);
 341         assert(rvalue);
 342         assert(data);
 343
 344         r = route_prefix_new_static(network, filename, section_line, &p);
 345         if (r < 0)
 346                 return r;
 347
 348         r = in_addr_prefix_from_string(rvalue, AF_INET6, &in6addr, &prefixlen);
 349         if (r < 0) {
 350                 log_syntax(unit, LOG_ERR, filename, line, r, "Route prefix is invalid, ignoring assignment: %s", rvalue);
 351                 return 0;
 352         }
 353
 354         if (sd_radv_prefix_set_route_prefix(p->radv_route_prefix, &in6addr.in6, prefixlen) < 0)
 355                 return -EADDRNOTAVAIL;
 356
 357         log_syntax(unit, LOG_INFO, filename, line, r, "Found route prefix %s", rvalue);
 358
 359         p = NULL;
 360
 361         return 0;
 362 }
 363
 364 int config_parse_route_prefix_lifetime(const char *unit,
 365                                        const char *filename,
 366                                        unsigned line,
 367                                        const char *section,
 368                                        unsigned section_line,
 369                                        const char *lvalue,
 370                                        int ltype,
 371                                        const char *rvalue,
 372                                        void *data,
 373                                        void *userdata) {
 374         Network *network = userdata;
 375         _cleanup_(route_prefix_free_or_set_invalidp) Prefix *p = NULL;
 376         usec_t usec;
 377         int r;
 378
 379         assert(filename);
 380         assert(section);
 381         assert(lvalue);
 382         assert(rvalue);
 383         assert(data);
 384
 385         r = route_prefix_new_static(network, filename, section_line, &p);
 386         if (r < 0)
 387                 return r;
 388
 389         r = parse_sec(rvalue, &usec);
 390         if (r < 0) {
 391                 log_syntax(unit, LOG_ERR, filename, line, r, "Roure lifetime is invalid, ignoring assignment: %s", rvalue);
 392                 return 0;
 393         }
 394
 395         /* a value of 0xffffffff represents infinity */
 396         r = sd_radv_route_prefix_set_lifetime(p->radv_route_prefix, DIV_ROUND_UP(usec, USEC_PER_SEC));
 397         if (r < 0)
 398                 return r;
 399
 400         p = NULL;
 401
 402         return 0;
 403 }
 404
 405 static int radv_get_ip6dns(Network *network, struct in6_addr **dns,
 406                            size_t *n_dns) {
 407         _cleanup_free_ struct in6_addr *addresses = NULL;
 408         size_t i, n_addresses = 0, n_allocated = 0;
 409
 410         assert(network);
 411         assert(dns);
 412         assert(n_dns);
 413
 414         for (i = 0; i < network->n_dns; i++) {
 415                 union in_addr_union *addr;
 416
 417                 if (network->dns[i].family != AF_INET6)
 418                         continue;
 419
 420                 addr = &network->dns[i].address;
 421
 422                 if (in_addr_is_null(AF_INET6, addr) ||
 423                     in_addr_is_link_local(AF_INET6, addr) ||
 424                     in_addr_is_localhost(AF_INET6, addr))
 425                         continue;
 426
 427                 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
 428                         return -ENOMEM;
 429
 430                 addresses[n_addresses++] = addr->in6;
 431         }
 432
 433         if (addresses) {
 434                 *dns = TAKE_PTR(addresses);
 435
 436                 *n_dns = n_addresses;
 437         }
 438
 439         return n_addresses;
 440 }
 441
 442 static int radv_set_dns(Link *link, Link *uplink) {
 443         _cleanup_free_ struct in6_addr *dns = NULL;
 444         size_t n_dns;
 445         usec_t lifetime_usec;
 446         int r;
 447
 448         if (!link->network->router_emit_dns)
 449                 return 0;
 450
 451         if (link->network->router_dns) {
 452                 dns = newdup(struct in6_addr, link->network->router_dns,
 453                              link->network->n_router_dns);
 454                 if (!dns)
 455                         return -ENOMEM;
 456
 457                 n_dns = link->network->n_router_dns;
 458                 lifetime_usec = link->network->router_dns_lifetime_usec;
 459
 460                 goto set_dns;
 461         }
 462
 463         lifetime_usec = SD_RADV_DEFAULT_DNS_LIFETIME_USEC;
 464
 465         r = radv_get_ip6dns(link->network, &dns, &n_dns);
 466         if (r > 0)
 467                 goto set_dns;
 468
 469         if (uplink) {
 470                 if (!uplink->network) {
 471                         log_link_debug(uplink, "Cannot fetch DNS servers as uplink interface is not managed by us");
 472                         return 0;
 473                 }
 474
 475                 r = radv_get_ip6dns(uplink->network, &dns, &n_dns);
 476                 if (r > 0)
 477                         goto set_dns;
 478         }
 479
 480         return 0;
 481
 482  set_dns:
 483         return sd_radv_set_rdnss(link->radv,
 484                                  DIV_ROUND_UP(lifetime_usec, USEC_PER_SEC),
 485                                  dns, n_dns);
 486 }
 487
 488 static int radv_set_domains(Link *link, Link *uplink) {
 489         OrderedSet *search_domains;
 490         usec_t lifetime_usec;
 491         _cleanup_free_ char **s = NULL; /* just free() because the strings are owned by the set */
 492
 493         if (!link->network->router_emit_domains)
 494                 return 0;
 495
 496         search_domains = link->network->router_search_domains;
 497         lifetime_usec = link->network->router_dns_lifetime_usec;
 498
 499         if (search_domains)
 500                 goto set_domains;
 501
 502         lifetime_usec = SD_RADV_DEFAULT_DNS_LIFETIME_USEC;
 503
 504         search_domains = link->network->search_domains;
 505         if (search_domains)
 506                 goto set_domains;
 507
 508         if (uplink) {
 509                 if (!uplink->network) {
 510                         log_link_debug(uplink, "Cannot fetch DNS search domains as uplink interface is not managed by us");
 511                         return 0;
 512                 }
 513
 514                 search_domains = uplink->network->search_domains;
 515                 if (search_domains)
 516                         goto set_domains;
 517         }
 518
 519         return 0;
 520
 521  set_domains:
 522         s = ordered_set_get_strv(search_domains);
 523         if (!s)
 524                 return log_oom();
 525
 526         return sd_radv_set_dnssl(link->radv,
 527                                  DIV_ROUND_UP(lifetime_usec, USEC_PER_SEC),
 528                                  s);
 529
 530 }
 531
 532 int radv_emit_dns(Link *link) {
 533         Link *uplink;
 534         int r;
 535
 536         uplink = manager_find_uplink(link->manager, link);
 537
 538         r = radv_set_dns(link, uplink);
 539         if (r < 0)
 540                 log_link_warning_errno(link, r, "Could not set RA DNS: %m");
 541
 542         r = radv_set_domains(link, uplink);
 543         if (r < 0)
 544                 log_link_warning_errno(link, r, "Could not set RA Domains: %m");
 545
 546         return 0;
 547 }
 548
 549 int radv_configure(Link *link) {
 550         int r;
 551         Prefix *p;
 552
 553         assert(link);
 554         assert(link->network);
 555
 556         r = sd_radv_new(&link->radv);
 557         if (r < 0)
 558                 return r;
 559
 560         r = sd_radv_attach_event(link->radv, NULL, 0);
 561         if (r < 0)
 562                 return r;
 563
 564         r = sd_radv_set_mac(link->radv, &link->mac);
 565         if (r < 0)
 566                 return r;
 567
 568         r = sd_radv_set_ifindex(link->radv, link->ifindex);
 569         if (r < 0)
 570                 return r;
 571
 572         r = sd_radv_set_managed_information(link->radv, link->network->router_managed);
 573         if (r < 0)
 574                 return r;
 575
 576         r = sd_radv_set_other_information(link->radv, link->network->router_other_information);
 577         if (r < 0)
 578                 return r;
 579
 580         /* a value of 0xffffffff represents infinity, 0x0 means this host is
 581            not a router */
 582         r = sd_radv_set_router_lifetime(link->radv,
 583                                         DIV_ROUND_UP(link->network->router_lifetime_usec, USEC_PER_SEC));
 584         if (r < 0)
 585                 return r;
 586
 587         if (link->network->router_lifetime_usec > 0) {
 588                 r = sd_radv_set_preference(link->radv,
 589                                            link->network->router_preference);
 590                 if (r < 0)
 591                         return r;
 592         }
 593
 594         if (IN_SET(link->network->router_prefix_delegation,
 595                    RADV_PREFIX_DELEGATION_STATIC,
 596                    RADV_PREFIX_DELEGATION_BOTH)) {
 597
 598                 LIST_FOREACH(prefixes, p, link->network->static_prefixes) {
 599                         r = sd_radv_add_prefix(link->radv, p->radv_prefix, false);
 600                         if (r == -EEXIST)
 601                                 continue;
 602                         if (r == -ENOEXEC) {
 603                                 log_link_warning_errno(link, r, "[IPv6Prefix] section configured without Prefix= setting, ignoring section.");
 604                                 continue;
 605                         }
 606                         if (r < 0)
 607                                 return r;
 608                 }
 609
 610                 LIST_FOREACH(prefixes, p, link->network->static_route_prefixes) {
 611                         r = sd_radv_add_route_prefix(link->radv, p->radv_route_prefix, false);
 612                         if (r == -EEXIST)
 613                                 continue;
 614                         if (r < 0)
 615                                 return r;
 616                 }
 617
 618         }
 619
 620         return radv_emit_dns(link);
 621 }
 622
 623 int config_parse_radv_dns(
 624                 const char *unit,
 625                 const char *filename,
 626                 unsigned line,
 627                 const char *section,
 628                 unsigned section_line,
 629                 const char *lvalue,
 630                 int ltype,
 631                 const char *rvalue,
 632                 void *data,
 633                 void *userdata) {
 634
 635         Network *n = data;
 636         const char *p = rvalue;
 637         int r;
 638
 639         assert(filename);
 640         assert(lvalue);
 641         assert(rvalue);
 642
 643         for (;;) {
 644                 _cleanup_free_ char *w = NULL;
 645                 union in_addr_union a;
 646
 647                 r = extract_first_word(&p, &w, NULL, 0);
 648                 if (r == -ENOMEM)
 649                         return log_oom();
 650                 if (r < 0) {
 651                         log_syntax(unit, LOG_ERR, filename, line, r,
 652                                    "Failed to extract word, ignoring: %s", rvalue);
 653                         return 0;
 654                 }
 655                 if (r == 0)
 656                         break;
 657
 658                 if (in_addr_from_string(AF_INET6, w, &a) >= 0) {
 659                         struct in6_addr *m;
 660
 661                         m = reallocarray(n->router_dns, n->n_router_dns + 1, sizeof(struct in6_addr));
 662                         if (!m)
 663                                 return log_oom();
 664
 665                         m[n->n_router_dns++] = a.in6;
 666                         n->router_dns = m;
 667
 668                 } else
 669                         log_syntax(unit, LOG_ERR, filename, line, 0,
 670                                    "Failed to parse DNS server address, ignoring: %s", w);
 671         }
 672
 673         return 0;
 674 }
 675
 676 int config_parse_radv_search_domains(
 677                 const char *unit,
 678                 const char *filename,
 679                 unsigned line,
 680                 const char *section,
 681                 unsigned section_line,
 682                 const char *lvalue,
 683                 int ltype,
 684                 const char *rvalue,
 685                 void *data,
 686                 void *userdata) {
 687
 688         Network *n = data;
 689         const char *p = rvalue;
 690         int r;
 691
 692         assert(filename);
 693         assert(lvalue);
 694         assert(rvalue);
 695
 696         for (;;) {
 697                 _cleanup_free_ char *w = NULL, *idna = NULL;
 698
 699                 r = extract_first_word(&p, &w, NULL, 0);
 700                 if (r == -ENOMEM)
 701                         return log_oom();
 702                 if (r < 0) {
 703                         log_syntax(unit, LOG_ERR, filename, line, r,
 704                                    "Failed to extract word, ignoring: %s", rvalue);
 705                         return 0;
 706                 }
 707                 if (r == 0)
 708                         break;
 709
 710                 r = dns_name_apply_idna(w, &idna);
 711                 if (r < 0) {
 712                         log_syntax(unit, LOG_ERR, filename, line, r,
 713                                    "Failed to apply IDNA to domain name '%s', ignoring: %m", w);
 714                         continue;
 715                 } else if (r == 0)
 716                         /* transfer ownership to simplify subsequent operations */
 717                         idna = TAKE_PTR(w);
 718
 719                 r = ordered_set_ensure_allocated(&n->router_search_domains, &string_hash_ops);
 720                 if (r < 0)
 721                         return r;
 722
 723                 r = ordered_set_consume(n->router_search_domains, TAKE_PTR(idna));
 724                 if (r < 0)
 725                         return r;
 726         }
 727
 728         return 0;
 729 }
 730
 731 static const char * const radv_prefix_delegation_table[_RADV_PREFIX_DELEGATION_MAX] = {
 732         [RADV_PREFIX_DELEGATION_NONE] = "no",
 733         [RADV_PREFIX_DELEGATION_STATIC] = "static",
 734         [RADV_PREFIX_DELEGATION_DHCP6] = "dhcpv6",
 735         [RADV_PREFIX_DELEGATION_BOTH] = "yes",
 736 };
 737
 738 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(
 739                 radv_prefix_delegation,
 740                 RADVPrefixDelegation,
 741                 RADV_PREFIX_DELEGATION_BOTH);
 742
 743 int config_parse_router_prefix_delegation(
 744                 const char *unit,
 745                 const char *filename,
 746                 unsigned line,
 747                 const char *section,
 748                 unsigned section_line,
 749                 const char *lvalue,
 750                 int ltype,
 751                 const char *rvalue,
 752                 void *data,
 753                 void *userdata) {
 754
 755         Network *network = userdata;
 756         RADVPrefixDelegation d;
 757
 758         assert(filename);
 759         assert(section);
 760         assert(lvalue);
 761         assert(rvalue);
 762         assert(data);
 763
 764         d = radv_prefix_delegation_from_string(rvalue);
 765         if (d < 0) {
 766                 log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Invalid router prefix delegation '%s', ignoring assignment.", rvalue);
 767                 return 0;
 768         }
 769
 770         network->router_prefix_delegation = d;
 771
 772         return 0;
 773 }
 774
 775 int config_parse_router_preference(const char *unit,
 776                                    const char *filename,
 777                                    unsigned line,
 778                                    const char *section,
 779                                    unsigned section_line,
 780                                    const char *lvalue,
 781                                    int ltype,
 782                                    const char *rvalue,
 783                                    void *data,
 784                                    void *userdata) {
 785         Network *network = userdata;
 786
 787         assert(filename);
 788         assert(section);
 789         assert(lvalue);
 790         assert(rvalue);
 791         assert(data);
 792
 793         if (streq(rvalue, "high"))
 794                 network->router_preference = SD_NDISC_PREFERENCE_HIGH;
 795         else if (STR_IN_SET(rvalue, "medium", "normal", "default"))
 796                 network->router_preference = SD_NDISC_PREFERENCE_MEDIUM;
 797         else if (streq(rvalue, "low"))
 798                 network->router_preference = SD_NDISC_PREFERENCE_LOW;
 799         else
 800                 log_syntax(unit, LOG_ERR, filename, line, -EINVAL, "Router preference '%s' is invalid, ignoring assignment: %m", rvalue);
 801
 802         return 0;
 803 }