[thirdparty/systemd.git] / src / libsystemd-network / sd-radv.c

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  Copyright © 2017 Intel Corporation. All rights reserved.
***/

#include <netinet/icmp6.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "sd-radv.h"

#include "alloc-util.h"
#include "dns-domain.h"
#include "ether-addr-util.h"
#include "event-util.h"
#include "fd-util.h"
#include "icmp6-util.h"
#include "in-addr-util.h"
#include "io-util.h"
#include "macro.h"
#include "memory-util.h"
#include "radv-internal.h"
#include "random-util.h"
#include "socket-util.h"
#include "string-util.h"
#include "strv.h"

_public_ int sd_radv_new(sd_radv **ret) {
        _cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;

        assert_return(ret, -EINVAL);

        ra = new(sd_radv, 1);
        if (!ra)
                return -ENOMEM;

        *ra = (sd_radv) {
                .n_ref = 1,
                .fd = -1,
        };

        *ret = TAKE_PTR(ra);

        return 0;
}

_public_ int sd_radv_attach_event(sd_radv *ra, sd_event *event, int64_t priority) {
        int r;

        assert_return(ra, -EINVAL);
        assert_return(!ra->event, -EBUSY);

        if (event)
                ra->event = sd_event_ref(event);
        else {
                r = sd_event_default(&ra->event);
                if (r < 0)
                        return 0;
        }

        ra->event_priority = priority;

        return 0;
}

_public_ int sd_radv_detach_event(sd_radv *ra) {

        assert_return(ra, -EINVAL);

        ra->event = sd_event_unref(ra->event);
        return 0;
}

_public_ sd_event *sd_radv_get_event(sd_radv *ra) {
        assert_return(ra, NULL);

        return ra->event;
}

static void radv_reset(sd_radv *ra) {
        assert(ra);

        (void) event_source_disable(ra->timeout_event_source);

        ra->recv_event_source =
                sd_event_source_unref(ra->recv_event_source);

        ra->ra_sent = 0;
}

static sd_radv *radv_free(sd_radv *ra) {
        if (!ra)
                return NULL;

        while (ra->prefixes) {
                sd_radv_prefix *p = ra->prefixes;

                LIST_REMOVE(prefix, ra->prefixes, p);
                sd_radv_prefix_unref(p);
        }

        free(ra->rdnss);
        free(ra->dnssl);

        ra->timeout_event_source = sd_event_source_unref(ra->timeout_event_source);

        radv_reset(ra);

        sd_radv_detach_event(ra);

        ra->fd = safe_close(ra->fd);

        return mfree(ra);
}

DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv, sd_radv, radv_free);

static int radv_send(sd_radv *ra, const struct in6_addr *dst, uint32_t router_lifetime) {
        sd_radv_prefix *p;
        struct sockaddr_in6 dst_addr = {
                .sin6_family = AF_INET6,
                .sin6_addr = IN6ADDR_ALL_NODES_MULTICAST_INIT,
        };
        struct nd_router_advert adv = {};
        struct {
                struct nd_opt_hdr opthdr;
                struct ether_addr slladdr;
        } _packed_ opt_mac = {
                .opthdr = {
                        .nd_opt_type = ND_OPT_SOURCE_LINKADDR,
                        .nd_opt_len = (sizeof(struct nd_opt_hdr) +
                                       sizeof(struct ether_addr) - 1) /8 + 1,
                },
        };
        struct nd_opt_mtu opt_mtu =  {
                .nd_opt_mtu_type = ND_OPT_MTU,
                .nd_opt_mtu_len = 1,
        };
        /* Reserve iov space for RA header, linkaddr, MTU, N prefixes, RDNSS
           and DNSSL */
        struct iovec iov[5 + ra->n_prefixes];
        struct msghdr msg = {
                .msg_name = &dst_addr,
                .msg_namelen = sizeof(dst_addr),
                .msg_iov = iov,
        };
        usec_t time_now;
        int r;

        assert(ra);

        r = sd_event_now(ra->event, clock_boottime_or_monotonic(), &time_now);
        if (r < 0)
                return r;

        if (dst && !IN6_IS_ADDR_UNSPECIFIED(dst))
                dst_addr.sin6_addr = *dst;

        adv.nd_ra_type = ND_ROUTER_ADVERT;
        adv.nd_ra_curhoplimit = ra->hop_limit;
        adv.nd_ra_flags_reserved = ra->flags;
        adv.nd_ra_router_lifetime = htobe16(router_lifetime);
        iov[msg.msg_iovlen++] = IOVEC_MAKE(&adv, sizeof(adv));

        /* MAC address is optional, either because the link does not use L2
           addresses or load sharing is desired. See RFC 4861, Section 4.2 */
        if (!ether_addr_is_null(&ra->mac_addr)) {
                opt_mac.slladdr = ra->mac_addr;
                iov[msg.msg_iovlen++] = IOVEC_MAKE(&opt_mac, sizeof(opt_mac));
        }

        if (ra->mtu) {
                opt_mtu.nd_opt_mtu_mtu = htobe32(ra->mtu);
                iov[msg.msg_iovlen++] = IOVEC_MAKE(&opt_mtu, sizeof(opt_mtu));
        }

        LIST_FOREACH(prefix, p, ra->prefixes) {
                if (p->valid_until) {

                        if (time_now > p->valid_until)
                                p->opt.valid_lifetime = 0;
                        else
                                p->opt.valid_lifetime = htobe32((p->valid_until - time_now) / USEC_PER_SEC);

                        if (time_now > p->preferred_until)
                                p->opt.preferred_lifetime = 0;
                        else
                                p->opt.preferred_lifetime = htobe32((p->preferred_until - time_now) / USEC_PER_SEC);
                }
                iov[msg.msg_iovlen++] = IOVEC_MAKE(&p->opt, sizeof(p->opt));
        }

        if (ra->rdnss)
                iov[msg.msg_iovlen++] = IOVEC_MAKE(ra->rdnss, ra->rdnss->length * 8);

        if (ra->dnssl)
                iov[msg.msg_iovlen++] = IOVEC_MAKE(ra->dnssl, ra->dnssl->length * 8);

        if (sendmsg(ra->fd, &msg, 0) < 0)
                return -errno;

        return 0;
}

static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
        sd_radv *ra = userdata;
        _cleanup_free_ char *addr = NULL;
        struct in6_addr src;
        triple_timestamp timestamp;
        int r;
        ssize_t buflen;
        _cleanup_free_ char *buf = NULL;

        assert(s);
        assert(ra);
        assert(ra->event);

        buflen = next_datagram_size_fd(fd);
        if (buflen < 0)
                return (int) buflen;

        buf = new0(char, buflen);
        if (!buf)
                return -ENOMEM;

        r = icmp6_receive(fd, buf, buflen, &src, &timestamp);
        if (r < 0) {
                switch (r) {
                case -EADDRNOTAVAIL:
                        (void) in_addr_to_string(AF_INET6, (union in_addr_union*) &src, &addr);
                        log_radv("Received RS from non-link-local address %s. Ignoring", addr);
                        break;

                case -EMULTIHOP:
                        log_radv("Received RS with invalid hop limit. Ignoring.");
                        break;

                case -EPFNOSUPPORT:
                        log_radv("Received invalid source address from ICMPv6 socket. Ignoring.");
                        break;

                case -EAGAIN: /* ignore spurious wakeups */
                        break;

                default:
                        log_radv_errno(r, "Unexpected error receiving from ICMPv6 socket: %m");
                        break;
                }

                return 0;
        }

        if ((size_t) buflen < sizeof(struct nd_router_solicit)) {
                log_radv("Too short packet received");
                return 0;
        }

        (void) in_addr_to_string(AF_INET6, (union in_addr_union*) &src, &addr);

        r = radv_send(ra, &src, ra->lifetime);
        if (r < 0)
                log_radv_errno(r, "Unable to send solicited Router Advertisement to %s: %m", strnull(addr));
        else
                log_radv("Sent solicited Router Advertisement to %s", strnull(addr));

        return 0;
}

static usec_t radv_compute_timeout(usec_t min, usec_t max) {
        assert_return(min <= max, SD_RADV_DEFAULT_MIN_TIMEOUT_USEC);

        return min + (random_u32() % (max - min));
}

static int radv_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
        int r;
        sd_radv *ra = userdata;
        usec_t min_timeout = SD_RADV_DEFAULT_MIN_TIMEOUT_USEC;
        usec_t max_timeout = SD_RADV_DEFAULT_MAX_TIMEOUT_USEC;
        usec_t time_now, timeout;
        char time_string[FORMAT_TIMESPAN_MAX];

        assert(s);
        assert(ra);
        assert(ra->event);

        r = sd_event_now(ra->event, clock_boottime_or_monotonic(), &time_now);
        if (r < 0)
                goto fail;

        r = radv_send(ra, NULL, ra->lifetime);
        if (r < 0)
                log_radv_errno(r, "Unable to send Router Advertisement: %m");

        /* RFC 4861, Section 6.2.4, sending initial Router Advertisements */
        if (ra->ra_sent < SD_RADV_MAX_INITIAL_RTR_ADVERTISEMENTS) {
                max_timeout = SD_RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC;
                min_timeout = SD_RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC / 3;
        }

        timeout = radv_compute_timeout(min_timeout, max_timeout);

        log_radv("Next Router Advertisement in %s",
                 format_timespan(time_string, FORMAT_TIMESPAN_MAX,
                                 timeout, USEC_PER_SEC));

        r = event_reset_time(ra->event, &ra->timeout_event_source,
                             clock_boottime_or_monotonic(),
                             time_now + timeout, MSEC_PER_SEC,
                             radv_timeout, ra,
                             ra->event_priority, "radv-timeout", true);
        if (r < 0)
                goto fail;

        ra->ra_sent++;

        return 0;

fail:
        sd_radv_stop(ra);

        return 0;
}

_public_ int sd_radv_stop(sd_radv *ra) {
        int r;

        assert_return(ra, -EINVAL);

        if (ra->state == SD_RADV_STATE_IDLE)
                return 0;

        log_radv("Stopping IPv6 Router Advertisement daemon");

        /* RFC 4861, Section 6.2.5, send at least one Router Advertisement
           with zero lifetime  */
        r = radv_send(ra, NULL, 0);
        if (r < 0)
                log_radv_errno(r, "Unable to send last Router Advertisement with router lifetime set to zero: %m");

        radv_reset(ra);
        ra->fd = safe_close(ra->fd);
        ra->state = SD_RADV_STATE_IDLE;

        return 0;
}

_public_ int sd_radv_start(sd_radv *ra) {
        int r;

        assert_return(ra, -EINVAL);
        assert_return(ra->event, -EINVAL);
        assert_return(ra->ifindex > 0, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return 0;

        r = event_reset_time(ra->event, &ra->timeout_event_source,
                             clock_boottime_or_monotonic(),
                             0, 0,
                             radv_timeout, ra,
                             ra->event_priority, "radv-timeout", true);
        if (r < 0)
                goto fail;

        r = icmp6_bind_router_advertisement(ra->ifindex);
        if (r < 0)
                goto fail;

        ra->fd = r;

        r = sd_event_add_io(ra->event, &ra->recv_event_source, ra->fd, EPOLLIN, radv_recv, ra);
        if (r < 0)
                goto fail;

        r = sd_event_source_set_priority(ra->recv_event_source, ra->event_priority);
        if (r < 0)
                goto fail;

        (void) sd_event_source_set_description(ra->recv_event_source, "radv-receive-message");

        ra->state = SD_RADV_STATE_ADVERTISING;

        log_radv("Started IPv6 Router Advertisement daemon");

        return 0;

 fail:
        radv_reset(ra);

        return r;
}

_public_ int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
        assert_return(ra, -EINVAL);
        assert_return(ifindex >= -1, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return -EBUSY;

        ra->ifindex = ifindex;

        return 0;
}

_public_ int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
        assert_return(ra, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return -EBUSY;

        if (mac_addr)
                ra->mac_addr = *mac_addr;
        else
                zero(ra->mac_addr);

        return 0;
}

_public_ int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
        assert_return(ra, -EINVAL);
        assert_return(mtu >= 1280, -EINVAL);

        ra->mtu = mtu;

        return 0;
}

_public_ int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
        assert_return(ra, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return -EBUSY;

        ra->hop_limit = hop_limit;

        return 0;
}

_public_ int sd_radv_set_router_lifetime(sd_radv *ra, uint32_t router_lifetime) {
        assert_return(ra, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return -EBUSY;

        /* RFC 4191, Section 2.2, "...If the Router Lifetime is zero, the
           preference value MUST be set to (00) by the sender..." */
        if (router_lifetime == 0 &&
            (ra->flags & (0x3 << 3)) != (SD_NDISC_PREFERENCE_MEDIUM << 3))
                return -ETIME;

        ra->lifetime = router_lifetime;

        return 0;
}

_public_ int sd_radv_set_managed_information(sd_radv *ra, int managed) {
        assert_return(ra, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return -EBUSY;

        SET_FLAG(ra->flags, ND_RA_FLAG_MANAGED, managed);

        return 0;
}

_public_ int sd_radv_set_other_information(sd_radv *ra, int other) {
        assert_return(ra, -EINVAL);

        if (ra->state != SD_RADV_STATE_IDLE)
                return -EBUSY;

        SET_FLAG(ra->flags, ND_RA_FLAG_OTHER, other);

        return 0;
}

_public_ int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
        int r = 0;

        assert_return(ra, -EINVAL);
        assert_return(IN_SET(preference,
                             SD_NDISC_PREFERENCE_LOW,
                             SD_NDISC_PREFERENCE_MEDIUM,
                             SD_NDISC_PREFERENCE_HIGH), -EINVAL);

        ra->flags = (ra->flags & ~(0x3 << 3)) | (preference << 3);

        return r;
}

_public_ int sd_radv_add_prefix(sd_radv *ra, sd_radv_prefix *p, int dynamic) {
        sd_radv_prefix *cur;
        int r;
        _cleanup_free_ char *addr_p = NULL;
        char time_string_preferred[FORMAT_TIMESPAN_MAX];
        char time_string_valid[FORMAT_TIMESPAN_MAX];
        usec_t time_now, valid, preferred, valid_until, preferred_until;

        assert_return(ra, -EINVAL);

        if (!p)
                return -EINVAL;

        /* Refuse prefixes that don't have a prefix set */
        if (IN6_IS_ADDR_UNSPECIFIED(&p->opt.in6_addr))
                return -ENOEXEC;

        LIST_FOREACH(prefix, cur, ra->prefixes) {

                r = in_addr_prefix_intersect(AF_INET6,
                                             (union in_addr_union*) &cur->opt.in6_addr,
                                             cur->opt.prefixlen,
                                             (union in_addr_union*) &p->opt.in6_addr,
                                             p->opt.prefixlen);
                if (r > 0) {
                        _cleanup_free_ char *addr_cur = NULL;

                        (void) in_addr_to_string(AF_INET6,
                                                 (union in_addr_union*) &p->opt.in6_addr,
                                                 &addr_p);

                        if (dynamic && cur->opt.prefixlen == p->opt.prefixlen)
                                goto update;

                        (void) in_addr_to_string(AF_INET6,
                                                 (union in_addr_union*) &cur->opt.in6_addr,
                                                 &addr_cur);
                        log_radv("IPv6 prefix %s/%u already configured, ignoring %s/%u",
                                 addr_cur, cur->opt.prefixlen,
                                 addr_p, p->opt.prefixlen);

                        return -EEXIST;
                }
        }

        p = sd_radv_prefix_ref(p);

        LIST_APPEND(prefix, ra->prefixes, p);

        ra->n_prefixes++;

        (void) in_addr_to_string(AF_INET6, (union in_addr_union*) &p->opt.in6_addr, &addr_p);

        if (!dynamic) {
                log_radv("Added prefix %s/%d", addr_p, p->opt.prefixlen);
                return 0;
        }

        cur = p;

 update:
        r = sd_event_now(ra->event, clock_boottime_or_monotonic(), &time_now);
        if (r < 0)
                return r;

        valid = be32toh(p->opt.valid_lifetime) * USEC_PER_SEC;
        valid_until = usec_add(valid, time_now);
        if (valid_until == USEC_INFINITY)
                return -EOVERFLOW;

        preferred = be32toh(p->opt.preferred_lifetime) * USEC_PER_SEC;
        preferred_until = usec_add(preferred, time_now);
        if (preferred_until == USEC_INFINITY)
                return -EOVERFLOW;

        cur->valid_until = valid_until;
        cur->preferred_until = preferred_until;

        log_radv("%s prefix %s/%u preferred %s valid %s",
                 cur? "Updated": "Added",
                 addr_p, p->opt.prefixlen,
                 format_timespan(time_string_preferred, FORMAT_TIMESPAN_MAX,
                                 preferred, USEC_PER_SEC),
                 format_timespan(time_string_valid, FORMAT_TIMESPAN_MAX,
                                 valid, USEC_PER_SEC));

        return 0;
}

_public_ sd_radv_prefix *sd_radv_remove_prefix(sd_radv *ra,
                                               const struct in6_addr *prefix,
                                               unsigned char prefixlen) {
        sd_radv_prefix *cur, *next;

        assert_return(ra, NULL);
        assert_return(prefix, NULL);

        LIST_FOREACH_SAFE(prefix, cur, next, ra->prefixes) {
                if (prefixlen != cur->opt.prefixlen)
                        continue;

                if (!in_addr_equal(AF_INET6,
                                   (union in_addr_union *)prefix,
                                   (union in_addr_union *)&cur->opt.in6_addr))
                        continue;

                LIST_REMOVE(prefix, ra->prefixes, cur);
                ra->n_prefixes--;

                break;
        }

        return cur;
}

_public_ int sd_radv_set_rdnss(sd_radv *ra, uint32_t lifetime,
                               const struct in6_addr *dns, size_t n_dns) {
        _cleanup_free_ struct sd_radv_opt_dns *opt_rdnss = NULL;
        size_t len;

        assert_return(ra, -EINVAL);
        assert_return(n_dns < 128, -EINVAL);

        if (!dns || n_dns == 0) {
                ra->rdnss = mfree(ra->rdnss);
                ra->n_rdnss = 0;

                return 0;
        }

        len = sizeof(struct sd_radv_opt_dns) + sizeof(struct in6_addr) * n_dns;

        opt_rdnss = malloc0(len);
        if (!opt_rdnss)
                return -ENOMEM;

        opt_rdnss->type = SD_RADV_OPT_RDNSS;
        opt_rdnss->length = len / 8;
        opt_rdnss->lifetime = htobe32(lifetime);

        memcpy(opt_rdnss + 1, dns, n_dns * sizeof(struct in6_addr));

        free_and_replace(ra->rdnss, opt_rdnss);

        ra->n_rdnss = n_dns;

        return 0;
}

_public_ int sd_radv_set_dnssl(sd_radv *ra, uint32_t lifetime,
                               char **search_list) {
        _cleanup_free_ struct sd_radv_opt_dns *opt_dnssl = NULL;
        size_t len = 0;
        char **s;
        uint8_t *p;

        assert_return(ra, -EINVAL);

        if (strv_isempty(search_list)) {
                ra->dnssl = mfree(ra->dnssl);
                return 0;
        }

        STRV_FOREACH(s, search_list)
                len += strlen(*s) + 2;

        len = (sizeof(struct sd_radv_opt_dns) + len + 7) & ~0x7;

        opt_dnssl = malloc0(len);
        if (!opt_dnssl)
                return -ENOMEM;

        opt_dnssl->type = SD_RADV_OPT_DNSSL;
        opt_dnssl->length = len / 8;
        opt_dnssl->lifetime = htobe32(lifetime);

        p = (uint8_t *)(opt_dnssl + 1);
        len -= sizeof(struct sd_radv_opt_dns);

        STRV_FOREACH(s, search_list) {
                int r;

                r = dns_name_to_wire_format(*s, p, len, false);
                if (r < 0)
                        return r;

                if (len < (size_t)r)
                        return -ENOBUFS;

                p += r;
                len -= r;
        }

        free_and_replace(ra->dnssl, opt_dnssl);

        return 0;
}

_public_ int sd_radv_prefix_new(sd_radv_prefix **ret) {
        sd_radv_prefix *p;

        assert_return(ret, -EINVAL);

        p = new(sd_radv_prefix, 1);
        if (!p)
                return -ENOMEM;

        *p = (sd_radv_prefix) {
                .n_ref = 1,

                .opt.type = ND_OPT_PREFIX_INFORMATION,
                .opt.length = (sizeof(p->opt) - 1)/8 + 1,
                .opt.prefixlen = 64,

                /* RFC 4861, Section 6.2.1 */
                .opt.flags = ND_OPT_PI_FLAG_ONLINK|ND_OPT_PI_FLAG_AUTO,

                .opt.preferred_lifetime = htobe32(604800),
                .opt.valid_lifetime = htobe32(2592000),
        };

        *ret = p;
        return 0;
}

DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_prefix, sd_radv_prefix, mfree);

_public_ int sd_radv_prefix_set_prefix(sd_radv_prefix *p, const struct in6_addr *in6_addr,
                                       unsigned char prefixlen) {
        assert_return(p, -EINVAL);
        assert_return(in6_addr, -EINVAL);

        if (prefixlen < 3 || prefixlen > 128)
                return -EINVAL;

        if (prefixlen > 64)
                /* unusual but allowed, log it */
                log_radv("Unusual prefix length %d greater than 64", prefixlen);

        p->opt.in6_addr = *in6_addr;
        p->opt.prefixlen = prefixlen;

        return 0;
}

_public_ int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
        assert_return(p, -EINVAL);

        SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_ONLINK, onlink);

        return 0;
}

_public_ int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p,
                                                          int address_autoconfiguration) {
        assert_return(p, -EINVAL);

        SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_AUTO, address_autoconfiguration);

        return 0;
}

_public_ int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p,
                                               uint32_t valid_lifetime) {
        assert_return(p, -EINVAL);

        p->opt.valid_lifetime = htobe32(valid_lifetime);

        return 0;
}

_public_ int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p,
                                                   uint32_t preferred_lifetime) {
        assert_return(p, -EINVAL);

        p->opt.preferred_lifetime = htobe32(preferred_lifetime);

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
04473969	2	/***
810adae9	3	Copyright © 2017 Intel Corporation. All rights reserved.
04473969 PF	4	***/
	5
	6	#include <netinet/icmp6.h>
	7	#include <netinet/in.h>
204f99d2	8	#include <arpa/inet.h>
04473969 PF	9
	10	#include "sd-radv.h"
	11
	12	#include "alloc-util.h"
e965d6ab	13	#include "dns-domain.h"
ae25915d	14	#include "ether-addr-util.h"
807a8ede	15	#include "event-util.h"
04473969 PF	16	#include "fd-util.h"
	17	#include "icmp6-util.h"
	18	#include "in-addr-util.h"
5cfa2c3d LP	19	#include "io-util.h"
5cfa2c3d LP	20	#include "macro.h"
0a970718	21	#include "memory-util.h"
04473969	22	#include "radv-internal.h"
5cfa2c3d	23	#include "random-util.h"
04473969 PF	24	#include "socket-util.h"
04473969 PF	25	#include "string-util.h"
e965d6ab	26	#include "strv.h"
04473969	27
204f99d2 PF	28	_public_ int sd_radv_new(sd_radv **ret) {
	29	_cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
	30
	31	assert_return(ret, -EINVAL);
	32
78f9d24f	33	ra = new(sd_radv, 1);
204f99d2 PF	34	if (!ra)
	35	return -ENOMEM;
	36
78f9d24f YW	37	*ra = (sd_radv) {
	38	.n_ref = 1,
	39	.fd = -1,
	40	};
204f99d2	41
1cc6c93a	42	*ret = TAKE_PTR(ra);
204f99d2 PF	43
	44	return 0;
	45	}
	46
	47	_public_ int sd_radv_attach_event(sd_radv ra, sd_event event, int64_t priority) {
	48	int r;
	49
	50	assert_return(ra, -EINVAL);
	51	assert_return(!ra->event, -EBUSY);
	52
	53	if (event)
	54	ra->event = sd_event_ref(event);
	55	else {
	56	r = sd_event_default(&ra->event);
	57	if (r < 0)
	58	return 0;
	59	}
	60
	61	ra->event_priority = priority;
	62
	63	return 0;
	64	}
	65
	66	_public_ int sd_radv_detach_event(sd_radv *ra) {
	67
	68	assert_return(ra, -EINVAL);
	69
	70	ra->event = sd_event_unref(ra->event);
	71	return 0;
	72	}
	73
	74	_public_ sd_event sd_radv_get_event(sd_radv ra) {
	75	assert_return(ra, NULL);
	76
	77	return ra->event;
	78	}
	79
204fb681	80	static void radv_reset(sd_radv *ra) {
c4b6dda0	81	assert(ra);
204fb681	82
807a8ede	83	(void) event_source_disable(ra->timeout_event_source);
204fb681	84
88d5a3db PF	85	ra->recv_event_source =
	86	sd_event_source_unref(ra->recv_event_source);
	87
204fb681 PF	88	ra->ra_sent = 0;
	89	}
	90
8301aa0b	91	static sd_radv radv_free(sd_radv ra) {
e866e17b LP	92	if (!ra)
e866e17b LP	93	return NULL;
204f99d2 PF	94
	95	while (ra->prefixes) {
	96	sd_radv_prefix *p = ra->prefixes;
	97
	98	LIST_REMOVE(prefix, ra->prefixes, p);
	99	sd_radv_prefix_unref(p);
	100	}
	101
e9c6da38	102	free(ra->rdnss);
f9aa5417	103	free(ra->dnssl);
e9c6da38	104
807a8ede YW	105	ra->timeout_event_source = sd_event_source_unref(ra->timeout_event_source);
807a8ede YW	106
204fb681 PF	107	radv_reset(ra);
204fb681 PF	108
204f99d2	109	sd_radv_detach_event(ra);
c4b6dda0 LP	110
	111	ra->fd = safe_close(ra->fd);
	112
204f99d2 PF	113	return mfree(ra);
	114	}
	115
8301aa0b YW	116	DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv, sd_radv, radv_free);
8301aa0b YW	117
83ef9d14	118	static int radv_send(sd_radv ra, const struct in6_addr dst, uint32_t router_lifetime) {
77baf5ae PF	119	sd_radv_prefix *p;
	120	struct sockaddr_in6 dst_addr = {
	121	.sin6_family = AF_INET6,
	122	.sin6_addr = IN6ADDR_ALL_NODES_MULTICAST_INIT,
	123	};
	124	struct nd_router_advert adv = {};
	125	struct {
	126	struct nd_opt_hdr opthdr;
	127	struct ether_addr slladdr;
	128	} _packed_ opt_mac = {
	129	.opthdr = {
	130	.nd_opt_type = ND_OPT_SOURCE_LINKADDR,
	131	.nd_opt_len = (sizeof(struct nd_opt_hdr) +
	132	sizeof(struct ether_addr) - 1) /8 + 1,
	133	},
	134	};
	135	struct nd_opt_mtu opt_mtu = {
	136	.nd_opt_mtu_type = ND_OPT_MTU,
	137	.nd_opt_mtu_len = 1,
	138	};
6852c0f6 PF	139	/* Reserve iov space for RA header, linkaddr, MTU, N prefixes, RDNSS
	140	and DNSSL */
	141	struct iovec iov[5 + ra->n_prefixes];
77baf5ae PF	142	struct msghdr msg = {
	143	.msg_name = &dst_addr,
	144	.msg_namelen = sizeof(dst_addr),
	145	.msg_iov = iov,
	146	};
d601b566 PF	147	usec_t time_now;
	148	int r;
	149
dc0ec5e2 LP	150	assert(ra);
dc0ec5e2 LP	151
d601b566 PF	152	r = sd_event_now(ra->event, clock_boottime_or_monotonic(), &time_now);
	153	if (r < 0)
	154	return r;
77baf5ae	155
dc0ec5e2	156	if (dst && !IN6_IS_ADDR_UNSPECIFIED(dst))
77baf5ae	157	dst_addr.sin6_addr = *dst;
88d5a3db	158
77baf5ae PF	159	adv.nd_ra_type = ND_ROUTER_ADVERT;
	160	adv.nd_ra_curhoplimit = ra->hop_limit;
	161	adv.nd_ra_flags_reserved = ra->flags;
	162	adv.nd_ra_router_lifetime = htobe16(router_lifetime);
5cfa2c3d	163	iov[msg.msg_iovlen++] = IOVEC_MAKE(&adv, sizeof(adv));
77baf5ae PF	164
	165	/* MAC address is optional, either because the link does not use L2
	166	addresses or load sharing is desired. See RFC 4861, Section 4.2 */
ae25915d	167	if (!ether_addr_is_null(&ra->mac_addr)) {
77baf5ae	168	opt_mac.slladdr = ra->mac_addr;
5cfa2c3d	169	iov[msg.msg_iovlen++] = IOVEC_MAKE(&opt_mac, sizeof(opt_mac));
77baf5ae PF	170	}
	171
	172	if (ra->mtu) {
	173	opt_mtu.nd_opt_mtu_mtu = htobe32(ra->mtu);
5cfa2c3d	174	iov[msg.msg_iovlen++] = IOVEC_MAKE(&opt_mtu, sizeof(opt_mtu));
77baf5ae PF	175	}
	176
	177	LIST_FOREACH(prefix, p, ra->prefixes) {
d601b566 PF	178	if (p->valid_until) {
	179
	180	if (time_now > p->valid_until)
	181	p->opt.valid_lifetime = 0;
	182	else
	183	p->opt.valid_lifetime = htobe32((p->valid_until - time_now) / USEC_PER_SEC);
	184
	185	if (time_now > p->preferred_until)
	186	p->opt.preferred_lifetime = 0;
	187	else
	188	p->opt.preferred_lifetime = htobe32((p->preferred_until - time_now) / USEC_PER_SEC);
	189	}
5cfa2c3d	190	iov[msg.msg_iovlen++] = IOVEC_MAKE(&p->opt, sizeof(p->opt));
77baf5ae PF	191	}
77baf5ae PF	192
5cfa2c3d LP	193	if (ra->rdnss)
5cfa2c3d LP	194	iov[msg.msg_iovlen++] = IOVEC_MAKE(ra->rdnss, ra->rdnss->length * 8);
e9c6da38	195
5cfa2c3d LP	196	if (ra->dnssl)
5cfa2c3d LP	197	iov[msg.msg_iovlen++] = IOVEC_MAKE(ra->dnssl, ra->dnssl->length * 8);
e965d6ab	198
77baf5ae PF	199	if (sendmsg(ra->fd, &msg, 0) < 0)
77baf5ae PF	200	return -errno;
204fb681	201
77baf5ae	202	return 0;
204fb681 PF	203	}
204fb681 PF	204
88d5a3db PF	205	static int radv_recv(sd_event_source s, int fd, uint32_t revents, void userdata) {
	206	sd_radv *ra = userdata;
	207	_cleanup_free_ char *addr = NULL;
	208	struct in6_addr src;
	209	triple_timestamp timestamp;
	210	int r;
	211	ssize_t buflen;
	212	_cleanup_free_ char *buf = NULL;
	213
	214	assert(s);
	215	assert(ra);
	216	assert(ra->event);
	217
	218	buflen = next_datagram_size_fd(fd);
cfffddea LP	219	if (buflen < 0)
cfffddea LP	220	return (int) buflen;
88d5a3db PF	221
	222	buf = new0(char, buflen);
	223	if (!buf)
e55a6eae	224	return -ENOMEM;
88d5a3db PF	225
	226	r = icmp6_receive(fd, buf, buflen, &src, &timestamp);
	227	if (r < 0) {
	228	switch (r) {
	229	case -EADDRNOTAVAIL:
	230	(void) in_addr_to_string(AF_INET6, (union in_addr_union*) &src, &addr);
	231	log_radv("Received RS from non-link-local address %s. Ignoring", addr);
	232	break;
	233
	234	case -EMULTIHOP:
	235	log_radv("Received RS with invalid hop limit. Ignoring.");
	236	break;
	237
	238	case -EPFNOSUPPORT:
	239	log_radv("Received invalid source address from ICMPv6 socket. Ignoring.");
	240	break;
	241
8eb41f4c LP	242	case -EAGAIN: /* ignore spurious wakeups */
	243	break;
	244
88d5a3db	245	default:
8eb41f4c	246	log_radv_errno(r, "Unexpected error receiving from ICMPv6 socket: %m");
88d5a3db PF	247	break;
	248	}
	249
	250	return 0;
	251	}
	252
cfffddea LP	253	if ((size_t) buflen < sizeof(struct nd_router_solicit)) {
	254	log_radv("Too short packet received");
	255	return 0;
	256	}
	257
88d5a3db PF	258	(void) in_addr_to_string(AF_INET6, (union in_addr_union*) &src, &addr);
	259
	260	r = radv_send(ra, &src, ra->lifetime);
	261	if (r < 0)
5a9fca25	262	log_radv_errno(r, "Unable to send solicited Router Advertisement to %s: %m", strnull(addr));
88d5a3db	263	else
5a9fca25	264	log_radv("Sent solicited Router Advertisement to %s", strnull(addr));
88d5a3db PF	265
	266	return 0;
	267	}
	268
204fb681 PF	269	static usec_t radv_compute_timeout(usec_t min, usec_t max) {
	270	assert_return(min <= max, SD_RADV_DEFAULT_MIN_TIMEOUT_USEC);
	271
	272	return min + (random_u32() % (max - min));
	273	}
	274
	275	static int radv_timeout(sd_event_source s, uint64_t usec, void userdata) {
	276	int r;
	277	sd_radv *ra = userdata;
	278	usec_t min_timeout = SD_RADV_DEFAULT_MIN_TIMEOUT_USEC;
	279	usec_t max_timeout = SD_RADV_DEFAULT_MAX_TIMEOUT_USEC;
	280	usec_t time_now, timeout;
	281	char time_string[FORMAT_TIMESPAN_MAX];
	282
	283	assert(s);
	284	assert(ra);
	285	assert(ra->event);
	286
204fb681 PF	287	r = sd_event_now(ra->event, clock_boottime_or_monotonic(), &time_now);
	288	if (r < 0)
	289	goto fail;
	290
	291	r = radv_send(ra, NULL, ra->lifetime);
	292	if (r < 0)
fdc2afc1	293	log_radv_errno(r, "Unable to send Router Advertisement: %m");
204fb681 PF	294
	295	/* RFC 4861, Section 6.2.4, sending initial Router Advertisements */
	296	if (ra->ra_sent < SD_RADV_MAX_INITIAL_RTR_ADVERTISEMENTS) {
	297	max_timeout = SD_RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC;
	298	min_timeout = SD_RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC / 3;
	299	}
	300
	301	timeout = radv_compute_timeout(min_timeout, max_timeout);
	302
	303	log_radv("Next Router Advertisement in %s",
	304	format_timespan(time_string, FORMAT_TIMESPAN_MAX,
	305	timeout, USEC_PER_SEC));
	306
807a8ede YW	307	r = event_reset_time(ra->event, &ra->timeout_event_source,
	308	clock_boottime_or_monotonic(),
	309	time_now + timeout, MSEC_PER_SEC,
	310	radv_timeout, ra,
	311	ra->event_priority, "radv-timeout", true);
204fb681 PF	312	if (r < 0)
	313	goto fail;
	314
	315	ra->ra_sent++;
	316
807a8ede YW	317	return 0;
807a8ede YW	318
204fb681	319	fail:
807a8ede	320	sd_radv_stop(ra);
204fb681 PF	321
	322	return 0;
	323	}
	324
204f99d2	325	_public_ int sd_radv_stop(sd_radv *ra) {
204fb681 PF	326	int r;
204fb681 PF	327
204f99d2 PF	328	assert_return(ra, -EINVAL);
204f99d2 PF	329
6f8a8b84 SS	330	if (ra->state == SD_RADV_STATE_IDLE)
	331	return 0;
	332
204f99d2 PF	333	log_radv("Stopping IPv6 Router Advertisement daemon");
204f99d2 PF	334
204fb681 PF	335	/* RFC 4861, Section 6.2.5, send at least one Router Advertisement
	336	with zero lifetime */
	337	r = radv_send(ra, NULL, 0);
	338	if (r < 0)
fdc2afc1	339	log_radv_errno(r, "Unable to send last Router Advertisement with router lifetime set to zero: %m");
204fb681 PF	340
204fb681 PF	341	radv_reset(ra);
77baf5ae	342	ra->fd = safe_close(ra->fd);
204f99d2 PF	343	ra->state = SD_RADV_STATE_IDLE;
	344
	345	return 0;
	346	}
	347
	348	_public_ int sd_radv_start(sd_radv *ra) {
f474884c	349	int r;
204fb681	350
204f99d2 PF	351	assert_return(ra, -EINVAL);
	352	assert_return(ra->event, -EINVAL);
	353	assert_return(ra->ifindex > 0, -EINVAL);
	354
	355	if (ra->state != SD_RADV_STATE_IDLE)
	356	return 0;
	357
807a8ede YW	358	r = event_reset_time(ra->event, &ra->timeout_event_source,
	359	clock_boottime_or_monotonic(),
	360	0, 0,
	361	radv_timeout, ra,
	362	ra->event_priority, "radv-timeout", true);
204fb681 PF	363	if (r < 0)
	364	goto fail;
	365
77baf5ae PF	366	r = icmp6_bind_router_advertisement(ra->ifindex);
	367	if (r < 0)
	368	goto fail;
	369
	370	ra->fd = r;
88d5a3db PF	371
	372	r = sd_event_add_io(ra->event, &ra->recv_event_source, ra->fd, EPOLLIN, radv_recv, ra);
	373	if (r < 0)
	374	goto fail;
	375
	376	r = sd_event_source_set_priority(ra->recv_event_source, ra->event_priority);
	377	if (r < 0)
	378	goto fail;
	379
	380	(void) sd_event_source_set_description(ra->recv_event_source, "radv-receive-message");
77baf5ae	381
204f99d2 PF	382	ra->state = SD_RADV_STATE_ADVERTISING;
	383
	384	log_radv("Started IPv6 Router Advertisement daemon");
	385
	386	return 0;
204fb681 PF	387
	388	fail:
	389	radv_reset(ra);
	390
	391	return r;
204f99d2 PF	392	}
	393
	394	_public_ int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
	395	assert_return(ra, -EINVAL);
	396	assert_return(ifindex >= -1, -EINVAL);
	397
	398	if (ra->state != SD_RADV_STATE_IDLE)
	399	return -EBUSY;
	400
	401	ra->ifindex = ifindex;
	402
	403	return 0;
	404	}
	405
	406	_public_ int sd_radv_set_mac(sd_radv ra, const struct ether_addr mac_addr) {
	407	assert_return(ra, -EINVAL);
	408
	409	if (ra->state != SD_RADV_STATE_IDLE)
	410	return -EBUSY;
	411
	412	if (mac_addr)
	413	ra->mac_addr = *mac_addr;
	414	else
	415	zero(ra->mac_addr);
	416
	417	return 0;
	418	}
	419
	420	_public_ int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
	421	assert_return(ra, -EINVAL);
	422	assert_return(mtu >= 1280, -EINVAL);
	423
204f99d2 PF	424	ra->mtu = mtu;
	425
	426	return 0;
	427	}
	428
	429	_public_ int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
	430	assert_return(ra, -EINVAL);
	431
	432	if (ra->state != SD_RADV_STATE_IDLE)
	433	return -EBUSY;
	434
	435	ra->hop_limit = hop_limit;
	436
	437	return 0;
	438	}
	439
	440	_public_ int sd_radv_set_router_lifetime(sd_radv *ra, uint32_t router_lifetime) {
	441	assert_return(ra, -EINVAL);
	442
	443	if (ra->state != SD_RADV_STATE_IDLE)
	444	return -EBUSY;
	445
	446	/* RFC 4191, Section 2.2, "...If the Router Lifetime is zero, the
	447	preference value MUST be set to (00) by the sender..." */
	448	if (router_lifetime == 0 &&
	449	(ra->flags & (0x3 << 3)) != (SD_NDISC_PREFERENCE_MEDIUM << 3))
	450	return -ETIME;
	451
	452	ra->lifetime = router_lifetime;
	453
	454	return 0;
	455	}
	456
	457	_public_ int sd_radv_set_managed_information(sd_radv *ra, int managed) {
	458	assert_return(ra, -EINVAL);
	459
	460	if (ra->state != SD_RADV_STATE_IDLE)
	461	return -EBUSY;
	462
	463	SET_FLAG(ra->flags, ND_RA_FLAG_MANAGED, managed);
	464
	465	return 0;
	466	}
	467
	468	_public_ int sd_radv_set_other_information(sd_radv *ra, int other) {
	469	assert_return(ra, -EINVAL);
	470
	471	if (ra->state != SD_RADV_STATE_IDLE)
	472	return -EBUSY;
	473
	474	SET_FLAG(ra->flags, ND_RA_FLAG_OTHER, other);
	475
	476	return 0;
	477	}
	478
	479	_public_ int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
	480	int r = 0;
	481
	482	assert_return(ra, -EINVAL);
	483	assert_return(IN_SET(preference,
	484	SD_NDISC_PREFERENCE_LOW,
	485	SD_NDISC_PREFERENCE_MEDIUM,
	486	SD_NDISC_PREFERENCE_HIGH), -EINVAL);
	487
488	ra->flags = (ra->flags & ~(0x3 << 3)) \| (preference << 3);
489
490	return r;
491	}
492
a3a98776	493	_public_ int sd_radv_add_prefix(sd_radv ra, sd_radv_prefix p, int dynamic) {
204f99d2	494	sd_radv_prefix *cur;
d601b566	495	int r;
204f99d2	496	_cleanup_free_ char *addr_p = NULL;
d601b566 PF	497	char time_string_preferred[FORMAT_TIMESPAN_MAX];
	498	char time_string_valid[FORMAT_TIMESPAN_MAX];
	499	usec_t time_now, valid, preferred, valid_until, preferred_until;
204f99d2 PF	500
	501	assert_return(ra, -EINVAL);
	502
	503	if (!p)
	504	return -EINVAL;
	505
59ea6e57 LP	506	/* Refuse prefixes that don't have a prefix set */
	507	if (IN6_IS_ADDR_UNSPECIFIED(&p->opt.in6_addr))
	508	return -ENOEXEC;
	509
204f99d2	510	LIST_FOREACH(prefix, cur, ra->prefixes) {
204f99d2 PF	511
	512	r = in_addr_prefix_intersect(AF_INET6,
	513	(union in_addr_union*) &cur->opt.in6_addr,
	514	cur->opt.prefixlen,
	515	(union in_addr_union*) &p->opt.in6_addr,
	516	p->opt.prefixlen);
	517	if (r > 0) {
	518	_cleanup_free_ char *addr_cur = NULL;
	519
204f99d2 PF	520	(void) in_addr_to_string(AF_INET6,
	521	(union in_addr_union*) &p->opt.in6_addr,
	522	&addr_p);
	523
d601b566 PF	524	if (dynamic && cur->opt.prefixlen == p->opt.prefixlen)
	525	goto update;
	526
	527	(void) in_addr_to_string(AF_INET6,
	528	(union in_addr_union*) &cur->opt.in6_addr,
	529	&addr_cur);
204f99d2 PF	530	log_radv("IPv6 prefix %s/%u already configured, ignoring %s/%u",
	531	addr_cur, cur->opt.prefixlen,
	532	addr_p, p->opt.prefixlen);
	533
	534	return -EEXIST;
	535	}
	536	}
	537
	538	p = sd_radv_prefix_ref(p);
	539
	540	LIST_APPEND(prefix, ra->prefixes, p);
	541
	542	ra->n_prefixes++;
	543
	544	(void) in_addr_to_string(AF_INET6, (union in_addr_union*) &p->opt.in6_addr, &addr_p);
d601b566 PF	545
	546	if (!dynamic) {
	547	log_radv("Added prefix %s/%d", addr_p, p->opt.prefixlen);
	548	return 0;
	549	}
	550
	551	cur = p;
	552
	553	update:
	554	r = sd_event_now(ra->event, clock_boottime_or_monotonic(), &time_now);
	555	if (r < 0)
	556	return r;
	557
	558	valid = be32toh(p->opt.valid_lifetime) * USEC_PER_SEC;
	559	valid_until = usec_add(valid, time_now);
	560	if (valid_until == USEC_INFINITY)
	561	return -EOVERFLOW;
	562
	563	preferred = be32toh(p->opt.preferred_lifetime) * USEC_PER_SEC;
	564	preferred_until = usec_add(preferred, time_now);
	565	if (preferred_until == USEC_INFINITY)
	566	return -EOVERFLOW;
	567
	568	cur->valid_until = valid_until;
	569	cur->preferred_until = preferred_until;
	570
	571	log_radv("%s prefix %s/%u preferred %s valid %s",
	572	cur? "Updated": "Added",
	573	addr_p, p->opt.prefixlen,
	574	format_timespan(time_string_preferred, FORMAT_TIMESPAN_MAX,
	575	preferred, USEC_PER_SEC),
	576	format_timespan(time_string_valid, FORMAT_TIMESPAN_MAX,
	577	valid, USEC_PER_SEC));
204f99d2 PF	578
	579	return 0;
	580	}
	581
34c169c4	582	_public_ sd_radv_prefix sd_radv_remove_prefix(sd_radv ra,
f5a5706a LP	583	const struct in6_addr *prefix,
f5a5706a LP	584	unsigned char prefixlen) {
34c169c4 PF	585	sd_radv_prefix cur, next;
	586
	587	assert_return(ra, NULL);
	588	assert_return(prefix, NULL);
	589
	590	LIST_FOREACH_SAFE(prefix, cur, next, ra->prefixes) {
	591	if (prefixlen != cur->opt.prefixlen)
	592	continue;
	593
	594	if (!in_addr_equal(AF_INET6,
	595	(union in_addr_union *)prefix,
	596	(union in_addr_union *)&cur->opt.in6_addr))
	597	continue;
	598
	599	LIST_REMOVE(prefix, ra->prefixes, cur);
	600	ra->n_prefixes--;
	601
	602	break;
	603	}
	604
	605	return cur;
	606	}
	607
e9c6da38 PF	608	_public_ int sd_radv_set_rdnss(sd_radv *ra, uint32_t lifetime,
	609	const struct in6_addr *dns, size_t n_dns) {
	610	_cleanup_free_ struct sd_radv_opt_dns *opt_rdnss = NULL;
	611	size_t len;
	612
	613	assert_return(ra, -EINVAL);
	614	assert_return(n_dns < 128, -EINVAL);
	615
	616	if (!dns \|\| n_dns == 0) {
	617	ra->rdnss = mfree(ra->rdnss);
	618	ra->n_rdnss = 0;
	619
	620	return 0;
	621	}
	622
	623	len = sizeof(struct sd_radv_opt_dns) + sizeof(struct in6_addr) * n_dns;
	624
	625	opt_rdnss = malloc0(len);
	626	if (!opt_rdnss)
	627	return -ENOMEM;
	628
	629	opt_rdnss->type = SD_RADV_OPT_RDNSS;
	630	opt_rdnss->length = len / 8;
	631	opt_rdnss->lifetime = htobe32(lifetime);
	632
	633	memcpy(opt_rdnss + 1, dns, n_dns * sizeof(struct in6_addr));
	634
1cc6c93a	635	free_and_replace(ra->rdnss, opt_rdnss);
e9c6da38 PF	636
	637	ra->n_rdnss = n_dns;
	638
	639	return 0;
	640	}
	641
e965d6ab PF	642	_public_ int sd_radv_set_dnssl(sd_radv *ra, uint32_t lifetime,
	643	char **search_list) {
	644	_cleanup_free_ struct sd_radv_opt_dns *opt_dnssl = NULL;
	645	size_t len = 0;
	646	char **s;
	647	uint8_t *p;
	648
	649	assert_return(ra, -EINVAL);
	650
97d7974b	651	if (strv_isempty(search_list)) {
e965d6ab	652	ra->dnssl = mfree(ra->dnssl);
e965d6ab PF	653	return 0;
	654	}
	655
	656	STRV_FOREACH(s, search_list)
	657	len += strlen(*s) + 2;
	658
	659	len = (sizeof(struct sd_radv_opt_dns) + len + 7) & ~0x7;
	660
	661	opt_dnssl = malloc0(len);
	662	if (!opt_dnssl)
	663	return -ENOMEM;
	664
	665	opt_dnssl->type = SD_RADV_OPT_DNSSL;
	666	opt_dnssl->length = len / 8;
	667	opt_dnssl->lifetime = htobe32(lifetime);
	668
	669	p = (uint8_t *)(opt_dnssl + 1);
	670	len -= sizeof(struct sd_radv_opt_dns);
	671
	672	STRV_FOREACH(s, search_list) {
	673	int r;
	674
	675	r = dns_name_to_wire_format(*s, p, len, false);
	676	if (r < 0)
	677	return r;
	678
	679	if (len < (size_t)r)
	680	return -ENOBUFS;
	681
	682	p += r;
	683	len -= r;
	684	}
	685
1cc6c93a	686	free_and_replace(ra->dnssl, opt_dnssl);
e965d6ab PF	687
	688	return 0;
	689	}
	690
04473969	691	_public_ int sd_radv_prefix_new(sd_radv_prefix **ret) {
d2c8eed2	692	sd_radv_prefix *p;
04473969 PF	693
	694	assert_return(ret, -EINVAL);
	695
d2c8eed2	696	p = new(sd_radv_prefix, 1);
04473969 PF	697	if (!p)
	698	return -ENOMEM;
	699
d2c8eed2 LP	700	*p = (sd_radv_prefix) {
d2c8eed2 LP	701	.n_ref = 1,
04473969	702
d2c8eed2 LP	703	.opt.type = ND_OPT_PREFIX_INFORMATION,
	704	.opt.length = (sizeof(p->opt) - 1)/8 + 1,
	705	.opt.prefixlen = 64,
04473969	706
d2c8eed2 LP	707	/* RFC 4861, Section 6.2.1 */
d2c8eed2 LP	708	.opt.flags = ND_OPT_PI_FLAG_ONLINK\|ND_OPT_PI_FLAG_AUTO,
204f99d2	709
d2c8eed2 LP	710	.opt.preferred_lifetime = htobe32(604800),
	711	.opt.valid_lifetime = htobe32(2592000),
	712	};
04473969	713
d2c8eed2	714	*ret = p;
04473969 PF	715	return 0;
	716	}
	717
8301aa0b	718	DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_prefix, sd_radv_prefix, mfree);
04473969	719
f5a5706a	720	_public_ int sd_radv_prefix_set_prefix(sd_radv_prefix p, const struct in6_addr in6_addr,
04473969 PF	721	unsigned char prefixlen) {
	722	assert_return(p, -EINVAL);
	723	assert_return(in6_addr, -EINVAL);
	724
	725	if (prefixlen < 3 \|\| prefixlen > 128)
	726	return -EINVAL;
	727
	728	if (prefixlen > 64)
	729	/* unusual but allowed, log it */
	730	log_radv("Unusual prefix length %d greater than 64", prefixlen);
	731
	732	p->opt.in6_addr = *in6_addr;
	733	p->opt.prefixlen = prefixlen;
	734
	735	return 0;
	736	}
	737
	738	_public_ int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
	739	assert_return(p, -EINVAL);
	740
	741	SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_ONLINK, onlink);
	742
	743	return 0;
	744	}
	745
	746	_public_ int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p,
	747	int address_autoconfiguration) {
	748	assert_return(p, -EINVAL);
	749
	750	SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_AUTO, address_autoconfiguration);
	751
	752	return 0;
	753	}
	754
	755	_public_ int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p,
	756	uint32_t valid_lifetime) {
	757	assert_return(p, -EINVAL);
	758
	759	p->opt.valid_lifetime = htobe32(valid_lifetime);
	760
	761	return 0;
	762	}
	763
	764	_public_ int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p,
	765	uint32_t preferred_lifetime) {
	766	assert_return(p, -EINVAL);
	767
	768	p->opt.preferred_lifetime = htobe32(preferred_lifetime);
	769
	770	return 0;
	771	}