src/libsystemd-network/sd-radv.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2017 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <linux/ipv6.h>
   7 #include <netinet/icmp6.h>
   8 #include <netinet/in.h>
   9
  10 #include "sd-ndisc-protocol.h"
  11 #include "sd-ndisc-router-solicit.h"
  12 #include "sd-radv.h"
  13
  14 #include "alloc-util.h"
  15 #include "event-util.h"
  16 #include "fd-util.h"
  17 #include "icmp6-packet.h"
  18 #include "icmp6-util.h"
  19 #include "in-addr-util.h"
  20 #include "memory-util.h"
  21 #include "ndisc-option.h"
  22 #include "ndisc-router-solicit-internal.h"
  23 #include "network-common.h"
  24 #include "radv-internal.h"
  25 #include "random-util.h"
  26 #include "set.h"
  27 #include "socket-util.h"
  28 #include "string-util.h"
  29
  30 int sd_radv_new(sd_radv **ret) {
  31         _cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
  32
  33         assert_return(ret, -EINVAL);
  34
  35         ra = new(sd_radv, 1);
  36         if (!ra)
  37                 return -ENOMEM;
  38
  39         *ra = (sd_radv) {
  40                 .n_ref = 1,
  41                 .fd = -EBADF,
  42                 .lifetime_usec = RADV_DEFAULT_ROUTER_LIFETIME_USEC,
  43         };
  44
  45         *ret = TAKE_PTR(ra);
  46
  47         return 0;
  48 }
  49
  50 int sd_radv_attach_event(sd_radv *ra, sd_event *event, int64_t priority) {
  51         int r;
  52
  53         assert_return(ra, -EINVAL);
  54         assert_return(!ra->event, -EBUSY);
  55
  56         if (event)
  57                 ra->event = sd_event_ref(event);
  58         else {
  59                 r = sd_event_default(&ra->event);
  60                 if (r < 0)
  61                         return 0;
  62         }
  63
  64         ra->event_priority = priority;
  65
  66         return 0;
  67 }
  68
  69 int sd_radv_detach_event(sd_radv *ra) {
  70         assert_return(ra, -EINVAL);
  71
  72         ra->event = sd_event_unref(ra->event);
  73         return 0;
  74 }
  75
  76 sd_event *sd_radv_get_event(sd_radv *ra) {
  77         assert_return(ra, NULL);
  78
  79         return ra->event;
  80 }
  81
  82 int sd_radv_is_running(sd_radv *ra) {
  83         if (!ra)
  84                 return false;
  85
  86         return ra->state != RADV_STATE_IDLE;
  87 }
  88
  89 static void radv_reset(sd_radv *ra) {
  90         assert(ra);
  91
  92         (void) event_source_disable(ra->timeout_event_source);
  93
  94         ra->recv_event_source = sd_event_source_disable_unref(ra->recv_event_source);
  95
  96         ra->ra_sent = 0;
  97 }
  98
  99 static sd_radv *radv_free(sd_radv *ra) {
 100         if (!ra)
 101                 return NULL;
 102
 103         radv_reset(ra);
 104
 105         sd_event_source_unref(ra->timeout_event_source);
 106         sd_radv_detach_event(ra);
 107
 108         ra->fd = safe_close(ra->fd);
 109         free(ra->ifname);
 110
 111         set_free(ra->options);
 112
 113         return mfree(ra);
 114 }
 115
 116 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv, sd_radv, radv_free);
 117
 118 static bool router_lifetime_is_valid(usec_t lifetime_usec) {
 119         assert_cc(RADV_MAX_ROUTER_LIFETIME_USEC <= UINT16_MAX * USEC_PER_SEC);
 120         return lifetime_usec == 0 ||
 121                 (lifetime_usec >= RADV_MIN_ROUTER_LIFETIME_USEC &&
 122                  lifetime_usec <= RADV_MAX_ROUTER_LIFETIME_USEC);
 123 }
 124
 125 static int radv_send_router_on_stop(sd_radv *ra) {
 126         static const struct nd_router_advert adv = {
 127                 .nd_ra_type = ND_ROUTER_ADVERT,
 128         };
 129
 130         _cleanup_set_free_ Set *options = NULL;
 131         struct ether_addr mac_addr;
 132         usec_t time_now;
 133         int r;
 134
 135         assert(ra);
 136
 137         r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
 138         if (r < 0)
 139                 return r;
 140
 141         /* On stop, we only send source link-layer address option. */
 142         if (ndisc_option_get_mac(ra->options, SD_NDISC_OPTION_SOURCE_LL_ADDRESS, &mac_addr) >= 0) {
 143                 r = ndisc_option_set_link_layer_address(&options, SD_NDISC_OPTION_SOURCE_LL_ADDRESS, &mac_addr);
 144                 if (r < 0)
 145                         return r;
 146         }
 147
 148         return ndisc_send(ra->fd, &IN6_ADDR_ALL_NODES_MULTICAST, &adv.nd_ra_hdr, options, time_now);
 149 }
 150
 151 static int radv_send_router(sd_radv *ra, const struct in6_addr *dst) {
 152         assert(ra);
 153
 154         struct nd_router_advert adv = {
 155                 .nd_ra_type = ND_ROUTER_ADVERT,
 156                 .nd_ra_router_lifetime = usec_to_be16_sec(ra->lifetime_usec),
 157                 .nd_ra_reachable = usec_to_be32_msec(ra->reachable_usec),
 158                 .nd_ra_retransmit = usec_to_be32_msec(ra->retransmit_usec),
 159         };
 160         usec_t time_now;
 161         int r;
 162
 163         r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
 164         if (r < 0)
 165                 return r;
 166
 167         /* The nd_ra_curhoplimit and nd_ra_flags_reserved fields cannot specified with nd_ra_router_lifetime
 168          * simultaneously in the structured initializer in the above. */
 169         adv.nd_ra_curhoplimit = ra->hop_limit;
 170         /* RFC 4191, Section 2.2,
 171          * "...If the Router Lifetime is zero, the preference value MUST be set to (00) by the sender..." */
 172         adv.nd_ra_flags_reserved = ra->flags | (ra->lifetime_usec > 0 ? (ra->preference << 3) : 0);
 173
 174         return ndisc_send(ra->fd,
 175                           (dst && in6_addr_is_set(dst)) ? dst : &IN6_ADDR_ALL_NODES_MULTICAST,
 176                           &adv.nd_ra_hdr, ra->options, time_now);
 177 }
 178
 179 static int radv_process_packet(sd_radv *ra, ICMP6Packet *packet) {
 180         int r;
 181
 182         assert(ra);
 183         assert(packet);
 184
 185         if (icmp6_packet_get_type(packet) != ND_ROUTER_SOLICIT)
 186                 return log_radv_errno(ra, SYNTHETIC_ERRNO(EBADMSG), "Received ICMP6 packet with unexpected type, ignoring.");
 187
 188         _cleanup_(sd_ndisc_router_solicit_unrefp) sd_ndisc_router_solicit *rs = NULL;
 189         rs = ndisc_router_solicit_new(packet);
 190         if (!rs)
 191                 return log_oom_debug();
 192
 193         r = ndisc_router_solicit_parse(ra, rs);
 194         if (r < 0)
 195                 return r;
 196
 197         struct in6_addr src;
 198         r = sd_ndisc_router_solicit_get_sender_address(rs, &src);
 199         if (r == -ENODATA) /* null address is allowed */
 200                 return sd_radv_send(ra); /* When an unsolicited RA, we need to also update timer. */
 201         if (r < 0)
 202                 return log_radv_errno(ra, r, "Failed to get sender address of RS, ignoring: %m");
 203         if (in6_addr_equal(&src, &ra->ipv6ll))
 204                 /* This should be definitely caused by a misconfiguration. If we send RA to ourself, the
 205                  * kernel complains about that. Let's ignore the packet. */
 206                 return log_radv_errno(ra, SYNTHETIC_ERRNO(EADDRINUSE), "Received RS from the same interface, ignoring.");
 207
 208         r = radv_send_router(ra, &src);
 209         if (r < 0)
 210                 return log_radv_errno(ra, r, "Unable to send solicited Router Advertisement to %s, ignoring: %m", IN6_ADDR_TO_STRING(&src));
 211
 212         log_radv(ra, "Sent solicited Router Advertisement to %s.", IN6_ADDR_TO_STRING(&src));
 213         return 0;
 214 }
 215
 216 static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 217         _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
 218         sd_radv *ra = ASSERT_PTR(userdata);
 219         int r;
 220
 221         assert(fd >= 0);
 222
 223         r = icmp6_packet_receive(fd, &packet);
 224         if (r < 0) {
 225                 log_radv_errno(ra, r, "Failed to receive ICMPv6 packet, ignoring: %m");
 226                 return 0;
 227         }
 228
 229         (void) radv_process_packet(ra, packet);
 230         return 0;
 231 }
 232
 233 static int radv_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
 234         sd_radv *ra = ASSERT_PTR(userdata);
 235
 236         if (sd_radv_send(ra) < 0)
 237                 (void) sd_radv_stop(ra);
 238
 239         return 0;
 240 }
 241
 242 int sd_radv_send(sd_radv *ra) {
 243         usec_t min_timeout, max_timeout, time_now, timeout;
 244         int r;
 245
 246         assert_return(ra, -EINVAL);
 247         assert_return(ra->event, -EINVAL);
 248         assert_return(sd_radv_is_running(ra), -EINVAL);
 249         assert(router_lifetime_is_valid(ra->lifetime_usec));
 250
 251         r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
 252         if (r < 0)
 253                 return r;
 254
 255         r = radv_send_router(ra, NULL);
 256         if (r < 0)
 257                 return log_radv_errno(ra, r, "Unable to send Router Advertisement: %m");
 258
 259         ra->ra_sent++;
 260
 261         /* RFC 4861, Section 6.2.4, sending initial Router Advertisements */
 262         if (ra->ra_sent <= RADV_MAX_INITIAL_RTR_ADVERTISEMENTS)
 263                 max_timeout = RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC;
 264         else
 265                 max_timeout = RADV_DEFAULT_MAX_TIMEOUT_USEC;
 266
 267         /* RFC 4861, Section 6.2.1, lifetime must be at least MaxRtrAdvInterval,
 268          * so lower the interval here */
 269         if (ra->lifetime_usec > 0)
 270                 max_timeout = MIN(max_timeout, ra->lifetime_usec);
 271
 272         if (max_timeout >= 9 * USEC_PER_SEC)
 273                 min_timeout = max_timeout / 3;
 274         else
 275                 min_timeout = max_timeout * 3 / 4;
 276
 277         /* RFC 4861, Section 6.2.1.
 278          * MaxRtrAdvInterval MUST be no less than 4 seconds and no greater than 1800 seconds.
 279          * MinRtrAdvInterval MUST be no less than 3 seconds and no greater than .75 * MaxRtrAdvInterval. */
 280         assert(max_timeout >= RADV_MIN_MAX_TIMEOUT_USEC);
 281         assert(max_timeout <= RADV_MAX_MAX_TIMEOUT_USEC);
 282         assert(min_timeout >= RADV_MIN_MIN_TIMEOUT_USEC);
 283         assert(min_timeout <= max_timeout * 3 / 4);
 284
 285         timeout = min_timeout + random_u64_range(max_timeout - min_timeout);
 286         log_radv(ra, "Sent unsolicited Router Advertisement. Next advertisement will be in %s.",
 287                  FORMAT_TIMESPAN(timeout, USEC_PER_SEC));
 288
 289         return event_reset_time(
 290                         ra->event, &ra->timeout_event_source,
 291                         CLOCK_BOOTTIME,
 292                         usec_add(time_now, timeout), MSEC_PER_SEC,
 293                         radv_timeout, ra,
 294                         ra->event_priority, "radv-timeout", true);
 295 }
 296
 297 int sd_radv_stop(sd_radv *ra) {
 298         int r;
 299
 300         if (!sd_radv_is_running(ra))
 301                 return 0; /* Already stopped. */
 302
 303         log_radv(ra, "Stopping IPv6 Router Advertisement daemon");
 304
 305         /* RFC 4861, Section 6.2.5:
 306          * the router SHOULD transmit one or more (but not more than MAX_FINAL_RTR_ADVERTISEMENTS) final
 307          * multicast Router Advertisements on the interface with a Router Lifetime field of zero. */
 308         r = radv_send_router_on_stop(ra);
 309         if (r < 0)
 310                 log_radv_errno(ra, r, "Unable to send last Router Advertisement with router lifetime set to zero, ignoring: %m");
 311
 312         radv_reset(ra);
 313         ra->fd = safe_close(ra->fd);
 314         ra->state = RADV_STATE_IDLE;
 315
 316         return 0;
 317 }
 318
 319 static int radv_setup_recv_event(sd_radv *ra) {
 320         int r;
 321
 322         assert(ra);
 323         assert(ra->event);
 324         assert(ra->ifindex > 0);
 325
 326         _cleanup_close_ int fd = -EBADF;
 327         fd = icmp6_bind(ra->ifindex, /* is_router = */ true);
 328         if (fd < 0)
 329                 return fd;
 330
 331         _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
 332         r = sd_event_add_io(ra->event, &s, fd, EPOLLIN, radv_recv, ra);
 333         if (r < 0)
 334                 return r;
 335
 336         r = sd_event_source_set_priority(s, ra->event_priority);
 337         if (r < 0)
 338                 return r;
 339
 340         (void) sd_event_source_set_description(s, "radv-receive-message");
 341
 342         ra->fd = TAKE_FD(fd);
 343         ra->recv_event_source = TAKE_PTR(s);
 344         return 0;
 345 }
 346
 347 int sd_radv_start(sd_radv *ra) {
 348         int r;
 349
 350         assert_return(ra, -EINVAL);
 351         assert_return(ra->event, -EINVAL);
 352         assert_return(ra->ifindex > 0, -EINVAL);
 353
 354         if (sd_radv_is_running(ra))
 355                 return 0; /* Already started. */
 356
 357         r = radv_setup_recv_event(ra);
 358         if (r < 0)
 359                 goto fail;
 360
 361         r = event_reset_time(ra->event, &ra->timeout_event_source,
 362                              CLOCK_BOOTTIME,
 363                              0, 0,
 364                              radv_timeout, ra,
 365                              ra->event_priority, "radv-timeout", true);
 366         if (r < 0)
 367                 goto fail;
 368
 369         ra->state = RADV_STATE_ADVERTISING;
 370
 371         log_radv(ra, "Started IPv6 Router Advertisement daemon");
 372
 373         return 0;
 374
 375  fail:
 376         radv_reset(ra);
 377
 378         return r;
 379 }
 380
 381 int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
 382         assert_return(ra, -EINVAL);
 383         assert_return(!sd_radv_is_running(ra), -EBUSY);
 384         assert_return(ifindex > 0, -EINVAL);
 385
 386         ra->ifindex = ifindex;
 387         return 0;
 388 }
 389
 390 int sd_radv_set_ifname(sd_radv *ra, const char *ifname) {
 391         assert_return(ra, -EINVAL);
 392         assert_return(ifname, -EINVAL);
 393
 394         if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
 395                 return -EINVAL;
 396
 397         return free_and_strdup(&ra->ifname, ifname);
 398 }
 399
 400 int sd_radv_get_ifname(sd_radv *ra, const char **ret) {
 401         int r;
 402
 403         assert_return(ra, -EINVAL);
 404
 405         r = get_ifname(ra->ifindex, &ra->ifname);
 406         if (r < 0)
 407                 return r;
 408
 409         if (ret)
 410                 *ret = ra->ifname;
 411
 412         return 0;
 413 }
 414
 415 int sd_radv_set_link_local_address(sd_radv *ra, const struct in6_addr *addr) {
 416         assert_return(ra, -EINVAL);
 417         assert_return(!addr || in6_addr_is_link_local(addr), -EINVAL);
 418
 419         if (addr)
 420                 ra->ipv6ll = *addr;
 421         else
 422                 zero(ra->ipv6ll);
 423
 424         return 0;
 425 }
 426
 427 /* Managing RA header. */
 428
 429 int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
 430         assert_return(ra, -EINVAL);
 431
 432         ra->hop_limit = hop_limit;
 433         return 0;
 434 }
 435
 436 int sd_radv_set_reachable_time(sd_radv *ra, uint64_t usec) {
 437         assert_return(ra, -EINVAL);
 438
 439         ra->reachable_usec = usec;
 440         return 0;
 441 }
 442
 443 int sd_radv_set_retransmit(sd_radv *ra, uint64_t usec) {
 444         assert_return(ra, -EINVAL);
 445
 446         ra->retransmit_usec = usec;
 447         return 0;
 448 }
 449
 450 int sd_radv_set_router_lifetime(sd_radv *ra, uint64_t usec) {
 451         assert_return(ra, -EINVAL);
 452
 453         if (!router_lifetime_is_valid(usec))
 454                 return -EINVAL;
 455
 456         ra->lifetime_usec = usec;
 457         return 0;
 458 }
 459
 460 int sd_radv_set_managed_information(sd_radv *ra, int b) {
 461         assert_return(ra, -EINVAL);
 462
 463         SET_FLAG(ra->flags, ND_RA_FLAG_MANAGED, b);
 464         return 0;
 465 }
 466
 467 int sd_radv_set_other_information(sd_radv *ra, int b) {
 468         assert_return(ra, -EINVAL);
 469
 470         SET_FLAG(ra->flags, ND_RA_FLAG_OTHER, b);
 471         return 0;
 472 }
 473
 474 int sd_radv_set_preference(sd_radv *ra, uint8_t preference) {
 475         assert_return(ra, -EINVAL);
 476         assert_return(IN_SET(preference,
 477                              SD_NDISC_PREFERENCE_LOW,
 478                              SD_NDISC_PREFERENCE_MEDIUM,
 479                              SD_NDISC_PREFERENCE_HIGH), -EINVAL);
 480
 481         ra->preference = preference;
 482         return 0;
 483 }
 484
 485 /* Managing options. */
 486
 487 int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
 488         assert_return(ra, -EINVAL);
 489
 490         return ndisc_option_set_link_layer_address(&ra->options, SD_NDISC_OPTION_SOURCE_LL_ADDRESS, mac_addr);
 491 }
 492
 493 void sd_radv_unset_mac(sd_radv *ra) {
 494         if (!ra)
 495                 return;
 496
 497         ndisc_option_remove_by_type(ra->options, SD_NDISC_OPTION_SOURCE_LL_ADDRESS);
 498 }
 499
 500 int sd_radv_add_prefix(
 501                 sd_radv *ra,
 502                 const struct in6_addr *prefix,
 503                 uint8_t prefixlen,
 504                 uint8_t flags,
 505                 uint64_t valid_lifetime_usec,
 506                 uint64_t preferred_lifetime_usec,
 507                 uint64_t valid_until,
 508                 uint64_t preferred_until) {
 509
 510         assert_return(ra, -EINVAL);
 511         assert_return(prefix, -EINVAL);
 512
 513         sd_ndisc_option *opt;
 514         SET_FOREACH(opt, ra->options) {
 515                 if (opt->type != SD_NDISC_OPTION_PREFIX_INFORMATION)
 516                         continue;
 517
 518                 if (!in6_addr_prefix_intersect(&opt->prefix.address, opt->prefix.prefixlen, prefix, prefixlen))
 519                         continue; /* no intersection */
 520
 521                 if (opt->prefix.prefixlen == prefixlen)
 522                         break; /* same prefix */
 523
 524                 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
 525                                       "IPv6 prefix %s conflicts with %s, ignoring.",
 526                                       IN6_ADDR_PREFIX_TO_STRING(prefix, prefixlen),
 527                                       IN6_ADDR_PREFIX_TO_STRING(&opt->prefix.address, opt->prefix.prefixlen));
 528         }
 529
 530         return ndisc_option_set_prefix(
 531                         &ra->options,
 532                         flags,
 533                         prefixlen,
 534                         prefix,
 535                         valid_lifetime_usec,
 536                         preferred_lifetime_usec,
 537                         valid_until,
 538                         preferred_until);
 539 }
 540
 541 void sd_radv_remove_prefix(
 542                 sd_radv *ra,
 543                 const struct in6_addr *prefix,
 544                 uint8_t prefixlen) {
 545
 546         if (!ra || !prefix)
 547                 return;
 548
 549         ndisc_option_remove(ra->options,
 550                             &(sd_ndisc_option) {
 551                                     .type = SD_NDISC_OPTION_PREFIX_INFORMATION,
 552                                     .prefix.prefixlen = prefixlen,
 553                                     .prefix.address = *prefix,
 554                             });
 555 }
 556
 557 int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
 558         assert_return(ra, -EINVAL);
 559         assert_return(mtu >= IPV6_MIN_MTU, -EINVAL);
 560
 561         return ndisc_option_set_mtu(&ra->options, mtu);
 562 }
 563
 564 void sd_radv_unset_mtu(sd_radv *ra) {
 565         if (!ra)
 566                 return;
 567
 568         ndisc_option_remove_by_type(ra->options, SD_NDISC_OPTION_MTU);
 569 }
 570
 571 int sd_radv_set_home_agent(sd_radv *ra, uint16_t preference, uint64_t lifetime_usec, uint64_t valid_until) {
 572         assert_return(ra, -EINVAL);
 573
 574         ra->flags |= ND_RA_FLAG_HOME_AGENT;
 575         return ndisc_option_set_home_agent(&ra->options, preference, lifetime_usec, valid_until);
 576 }
 577
 578 void sd_radv_unset_home_agent(sd_radv *ra) {
 579         if (!ra)
 580                 return;
 581
 582         ra->flags &= ~ND_RA_FLAG_HOME_AGENT;
 583         ndisc_option_remove_by_type(ra->options, SD_NDISC_OPTION_HOME_AGENT);
 584 }
 585
 586 int sd_radv_add_route(
 587                 sd_radv *ra,
 588                 const struct in6_addr *prefix,
 589                 uint8_t prefixlen,
 590                 uint8_t preference,
 591                 uint64_t lifetime_usec,
 592                 uint64_t valid_until) {
 593
 594         assert_return(ra, -EINVAL);
 595         assert_return(prefix, -EINVAL);
 596
 597         return ndisc_option_set_route(
 598                         &ra->options,
 599                         preference,
 600                         prefixlen,
 601                         prefix,
 602                         lifetime_usec,
 603                         valid_until);
 604 }
 605
 606 void sd_radv_remove_route(
 607                 sd_radv *ra,
 608                 const struct in6_addr *prefix,
 609                 uint8_t prefixlen) {
 610
 611         if (!ra || !prefix)
 612                 return;
 613
 614         ndisc_option_remove(ra->options,
 615                             &(sd_ndisc_option) {
 616                                     .type = SD_NDISC_OPTION_ROUTE_INFORMATION,
 617                                     .route.prefixlen = prefixlen,
 618                                     .route.address = *prefix,
 619                             });
 620 }
 621
 622 int sd_radv_add_rdnss(
 623                 sd_radv *ra,
 624                 size_t n_dns,
 625                 const struct in6_addr *dns,
 626                 uint64_t lifetime_usec,
 627                 uint64_t valid_until) {
 628
 629         assert_return(ra, -EINVAL);
 630         assert_return(dns, -EINVAL);
 631
 632         return ndisc_option_set_rdnss(
 633                         &ra->options,
 634                         n_dns,
 635                         dns,
 636                         lifetime_usec,
 637                         valid_until);
 638 }
 639
 640 void sd_radv_clear_rdnss(sd_radv *ra) {
 641         if (!ra)
 642                 return;
 643
 644         sd_ndisc_option *opt;
 645         SET_FOREACH(opt, ra->options)
 646                 if (opt->type == SD_NDISC_OPTION_RDNSS)
 647                         ndisc_option_remove(ra->options, opt);
 648 }
 649
 650 int sd_radv_add_dnssl(
 651                 sd_radv *ra,
 652                 char * const *domains,
 653                 uint64_t lifetime_usec,
 654                 uint64_t valid_until) {
 655
 656         assert_return(ra, -EINVAL);
 657
 658         return ndisc_option_set_dnssl(
 659                         &ra->options,
 660                         domains,
 661                         lifetime_usec,
 662                         valid_until);
 663 }
 664
 665 void sd_radv_clear_dnssl(sd_radv *ra) {
 666         if (!ra)
 667                 return;
 668
 669         sd_ndisc_option *opt;
 670         SET_FOREACH(opt, ra->options)
 671                 if (opt->type == SD_NDISC_OPTION_DNSSL)
 672                         ndisc_option_remove(ra->options, opt);
 673 }
 674
 675 int sd_radv_set_captive_portal(sd_radv *ra, const char *portal) {
 676         assert_return(ra, -EINVAL);
 677         assert_return(portal, -EINVAL);
 678
 679         return ndisc_option_set_captive_portal(&ra->options, portal);
 680 }
 681
 682 void sd_radv_unset_captive_portal(sd_radv *ra) {
 683         if (!ra)
 684                 return;
 685
 686         ndisc_option_remove_by_type(ra->options, SD_NDISC_OPTION_CAPTIVE_PORTAL);
 687 }
 688
 689 int sd_radv_add_prefix64(
 690                 sd_radv *ra,
 691                 const struct in6_addr *prefix,
 692                 uint8_t prefixlen,
 693                 uint64_t lifetime_usec,
 694                 uint64_t valid_until) {
 695
 696         assert_return(ra, -EINVAL);
 697         assert_return(prefix, -EINVAL);
 698
 699         return ndisc_option_set_prefix64(
 700                         &ra->options,
 701                         prefixlen,
 702                         prefix,
 703                         lifetime_usec,
 704                         valid_until);
 705 }
 706
 707 void sd_radv_remove_prefix64(
 708                 sd_radv *ra,
 709                 const struct in6_addr *prefix,
 710                 uint8_t prefixlen) {
 711
 712         if (!ra || !prefix)
 713                 return;
 714
 715         ndisc_option_remove(ra->options,
 716                             &(sd_ndisc_option) {
 717                                     .type = SD_NDISC_OPTION_PREF64,
 718                                     .prefix64.prefixlen = prefixlen,
 719                                     .prefix64.prefix = *prefix,
 720                             });
 721 }