]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/libsystemd-network/sd-radv.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sd-radv: reset timer on sending unsolicited RA
[thirdparty/systemd.git] / src / libsystemd-network / sd-radv.c
CommitLineData
db9ecf05 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
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"
bd1ae178 19#include "iovec-util.h"
5cfa2c3d 20#include "macro.h"
0a970718 21#include "memory-util.h"
cc2bcbf6 22#include "ndisc-router-solicit-internal.h"
61a9fa8f 23#include "network-common.h"
04473969 24#include "radv-internal.h"
5cfa2c3d 25#include "random-util.h"
04473969
PF		 26#include "socket-util.h"
27#include "string-util.h"
e965d6ab 28#include "strv.h"
1925f829 29#include "unaligned.h"
04473969 30
17347053 31int sd_radv_new(sd_radv **ret) {
204f99d2
PF		 32 _cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
33
34 assert_return(ret, -EINVAL);
35
78f9d24f 36 ra = new(sd_radv, 1);
204f99d2
PF		 37 if (!ra)
38 return -ENOMEM;
39
78f9d24f
YW		 40 *ra = (sd_radv) {
41 .n_ref = 1,
254d1313 42 .fd = -EBADF,
72db0a71 43 .lifetime_usec = RADV_DEFAULT_ROUTER_LIFETIME_USEC,
78f9d24f 44 };
204f99d2 45
1cc6c93a 46 *ret = TAKE_PTR(ra);
204f99d2
PF		 47
48 return 0;
49}
50
17347053 51int sd_radv_attach_event(sd_radv *ra, sd_event *event, int64_t priority) {
204f99d2
PF		 52 int r;
53
54 assert_return(ra, -EINVAL);
55 assert_return(!ra->event, -EBUSY);
56
57 if (event)
58 ra->event = sd_event_ref(event);
59 else {
60 r = sd_event_default(&ra->event);
61 if (r < 0)
62 return 0;
63 }
64
65 ra->event_priority = priority;
66
67 return 0;
68}
69
17347053 70int sd_radv_detach_event(sd_radv *ra) {
204f99d2
PF		 71
72 assert_return(ra, -EINVAL);
73
74 ra->event = sd_event_unref(ra->event);
75 return 0;
76}
77
17347053 78sd_event *sd_radv_get_event(sd_radv *ra) {
204f99d2
PF		 79 assert_return(ra, NULL);
80
81 return ra->event;
82}
83
17347053 84int sd_radv_is_running(sd_radv *ra) {
8e91738f
YW		 85 if (!ra)
86 return false;
96fe813c 87
d6fc0d67 88 return ra->state != RADV_STATE_IDLE;
96fe813c
YW		 89}
90
204fb681 91static void radv_reset(sd_radv *ra) {
c4b6dda0 92 assert(ra);
204fb681 93
807a8ede 94 (void) event_source_disable(ra->timeout_event_source);
204fb681 95
eb2f7502 96 ra->recv_event_source = sd_event_source_disable_unref(ra->recv_event_source);
88d5a3db 97
204fb681
PF		 98 ra->ra_sent = 0;
99}
100
8301aa0b 101static sd_radv *radv_free(sd_radv *ra) {
e866e17b
LP		 102 if (!ra)
103 return NULL;
204f99d2 104
9aad490e
DT		 105 LIST_CLEAR(prefix, ra->prefixes, sd_radv_prefix_unref);
106 LIST_CLEAR(prefix, ra->route_prefixes, sd_radv_route_prefix_unref);
1a6b1214 107 LIST_CLEAR(prefix, ra->pref64_prefixes, sd_radv_pref64_prefix_unref);
69d7eba1 108
e9c6da38 109 free(ra->rdnss);
f9aa5417 110 free(ra->dnssl);
e9c6da38 111
204fb681
PF		 112 radv_reset(ra);
113
eb2f7502 114 sd_event_source_unref(ra->timeout_event_source);
204f99d2 115 sd_radv_detach_event(ra);
c4b6dda0
LP		 116
117 ra->fd = safe_close(ra->fd);
61a9fa8f 118 free(ra->ifname);
c4b6dda0 119
204f99d2
PF		 120 return mfree(ra);
121}
122
8301aa0b
YW		 123DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv, sd_radv, radv_free);
124
09457670 125static bool router_lifetime_is_valid(usec_t lifetime_usec) {
36653443 126 assert_cc(RADV_MAX_ROUTER_LIFETIME_USEC <= UINT16_MAX * USEC_PER_SEC);
09457670
YW		 127 return lifetime_usec == 0 ||
128 (lifetime_usec >= RADV_MIN_ROUTER_LIFETIME_USEC &&
129 lifetime_usec <= RADV_MAX_ROUTER_LIFETIME_USEC);
130}
131
19f3cc86
YW		 132static int radv_send_router_on_stop(sd_radv *ra) {
133 static const struct nd_router_advert adv = {
134 .nd_ra_type = ND_ROUTER_ADVERT,
135 };
136
137 _cleanup_set_free_ Set *options = NULL;
138 usec_t time_now;
139 int r;
140
141 assert(ra);
142
143 r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
144 if (r < 0)
145 return r;
146
147 if (!ether_addr_is_null(&ra->mac_addr)) {
148 r = ndisc_option_set_link_layer_address(&options, SD_NDISC_OPTION_SOURCE_LL_ADDRESS, &ra->mac_addr);
149 if (r < 0)
150 return r;
151 }
152
153 return ndisc_send(ra->fd, &IN6_ADDR_ALL_NODES_MULTICAST, &adv.nd_ra_hdr, options, time_now);
154}
155
69628e3b 156static int radv_send_router(sd_radv *ra, const struct in6_addr *dst) {
36653443 157 assert(ra);
36653443 158
77baf5ae
PF		 159 struct sockaddr_in6 dst_addr = {
160 .sin6_family = AF_INET6,
2c28eb02 161 .sin6_addr = IN6_ADDR_ALL_NODES_MULTICAST,
77baf5ae 162 };
36653443
YW		 163 struct nd_router_advert adv = {
164 .nd_ra_type = ND_ROUTER_ADVERT,
69628e3b 165 .nd_ra_router_lifetime = usec_to_be16_sec(ra->lifetime_usec),
36653443
YW		 166 .nd_ra_retransmit = usec_to_be32_msec(ra->retransmit_usec),
167 };
77baf5ae
PF		 168 struct {
169 struct nd_opt_hdr opthdr;
170 struct ether_addr slladdr;
171 } _packed_ opt_mac = {
172 .opthdr = {
173 .nd_opt_type = ND_OPT_SOURCE_LINKADDR,
36653443 174 .nd_opt_len = DIV_ROUND_UP(sizeof(struct nd_opt_hdr) + sizeof(struct ether_addr), 8),
77baf5ae 175 },
36653443 176 .slladdr = ra->mac_addr,
77baf5ae
PF		 177 };
178 struct nd_opt_mtu opt_mtu = {
179 .nd_opt_mtu_type = ND_OPT_MTU,
180 .nd_opt_mtu_len = 1,
36653443 181 .nd_opt_mtu_mtu = htobe32(ra->mtu),
77baf5ae 182 };
ac63c8df
YW		 183 /* Reserve iov space for RA header, linkaddr, MTU, N prefixes, N routes, N pref64 prefixes, RDNSS,
184 * DNSSL, and home agent. */
185 struct iovec iov[6 + ra->n_prefixes + ra->n_route_prefixes + ra->n_pref64_prefixes];
77baf5ae
PF		 186 struct msghdr msg = {
187 .msg_name = &dst_addr,
188 .msg_namelen = sizeof(dst_addr),
189 .msg_iov = iov,
190 };
d601b566
PF		 191 usec_t time_now;
192 int r;
193
ba4e0427 194 r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
d601b566
PF		 195 if (r < 0)
196 return r;
77baf5ae 197
94876904 198 if (dst && in6_addr_is_set(dst))
77baf5ae 199 dst_addr.sin6_addr = *dst;
88d5a3db 200
36653443
YW		 201 /* The nd_ra_curhoplimit and nd_ra_flags_reserved fields cannot specified with nd_ra_router_lifetime
202 * simultaneously in the structured initializer in the above. */
77baf5ae
PF		 203 adv.nd_ra_curhoplimit = ra->hop_limit;
204 adv.nd_ra_flags_reserved = ra->flags;
5cfa2c3d 205 iov[msg.msg_iovlen++] = IOVEC_MAKE(&adv, sizeof(adv));
77baf5ae 206
36653443
YW		 207 /* MAC address is optional, either because the link does not use L2 addresses or load sharing is
208 * desired. See RFC 4861, Section 4.2. */
209 if (!ether_addr_is_null(&ra->mac_addr))
5cfa2c3d 210 iov[msg.msg_iovlen++] = IOVEC_MAKE(&opt_mac, sizeof(opt_mac));
77baf5ae 211
36653443 212 if (ra->mtu > 0)
5cfa2c3d 213 iov[msg.msg_iovlen++] = IOVEC_MAKE(&opt_mtu, sizeof(opt_mtu));
77baf5ae
PF		 214
215 LIST_FOREACH(prefix, p, ra->prefixes) {
95e104e0 216 usec_t lifetime_valid_usec, lifetime_preferred_usec;
d601b566 217
95e104e0
YW		 218 lifetime_valid_usec = MIN(usec_sub_unsigned(p->valid_until, time_now),
219 p->lifetime_valid_usec);
220
221 lifetime_preferred_usec = MIN3(usec_sub_unsigned(p->preferred_until, time_now),
222 p->lifetime_preferred_usec,
223 lifetime_valid_usec);
224
225 p->opt.lifetime_valid = usec_to_be32_sec(lifetime_valid_usec);
226 p->opt.lifetime_preferred = usec_to_be32_sec(lifetime_preferred_usec);
d601b566 227
5cfa2c3d 228 iov[msg.msg_iovlen++] = IOVEC_MAKE(&p->opt, sizeof(p->opt));
77baf5ae
PF		 229 }
230
95e104e0
YW		 231 LIST_FOREACH(prefix, rt, ra->route_prefixes) {
232 rt->opt.lifetime = usec_to_be32_sec(MIN(usec_sub_unsigned(rt->valid_until, time_now),
233 rt->lifetime_usec));
234
203d4df5 235 iov[msg.msg_iovlen++] = IOVEC_MAKE(&rt->opt, sizeof(rt->opt));
95e104e0 236 }
203d4df5 237
1925f829
SS		 238 LIST_FOREACH(prefix, p, ra->pref64_prefixes)
239 iov[msg.msg_iovlen++] = IOVEC_MAKE(&p->opt, sizeof(p->opt));
240
5cfa2c3d
LP		 241 if (ra->rdnss)
242 iov[msg.msg_iovlen++] = IOVEC_MAKE(ra->rdnss, ra->rdnss->length * 8);
e9c6da38 243
5cfa2c3d
LP		 244 if (ra->dnssl)
245 iov[msg.msg_iovlen++] = IOVEC_MAKE(ra->dnssl, ra->dnssl->length * 8);
e965d6ab 246
6a6d27bc
SS		 247 if (FLAGS_SET(ra->flags, ND_RA_FLAG_HOME_AGENT)) {
248 ra->home_agent.nd_opt_home_agent_info_type = ND_OPT_HOME_AGENT_INFO;
249 ra->home_agent.nd_opt_home_agent_info_len = 1;
250
251 /* 0 means to place the current Router Lifetime value */
252 if (ra->home_agent.nd_opt_home_agent_info_lifetime == 0)
253 ra->home_agent.nd_opt_home_agent_info_lifetime = adv.nd_ra_router_lifetime;
254
255 iov[msg.msg_iovlen++] = IOVEC_MAKE(&ra->home_agent, sizeof(ra->home_agent));
256 }
257
77baf5ae
PF		 258 if (sendmsg(ra->fd, &msg, 0) < 0)
259 return -errno;
204fb681 260
77baf5ae 261 return 0;
204fb681
PF		 262}
263
cc2bcbf6 264static int radv_process_packet(sd_radv *ra, ICMP6Packet *packet) {
88d5a3db 265 int r;
88d5a3db 266
cc2bcbf6
YW		 267 assert(ra);
268 assert(packet);
88d5a3db 269
cc2bcbf6
YW		 270 if (icmp6_packet_get_type(packet) != ND_ROUTER_SOLICIT)
271 return log_radv_errno(ra, SYNTHETIC_ERRNO(EBADMSG), "Received ICMP6 packet with unexpected type, ignoring.");
88d5a3db 272
cc2bcbf6
YW		 273 _cleanup_(sd_ndisc_router_solicit_unrefp) sd_ndisc_router_solicit *rs = NULL;
274 rs = ndisc_router_solicit_new(packet);
275 if (!rs)
276 return log_oom_debug();
88d5a3db 277
cc2bcbf6 278 r = ndisc_router_solicit_parse(ra, rs);
1f2db2e3 279 if (r < 0)
cc2bcbf6 280 return r;
88d5a3db 281
2a1e8909 282 struct in6_addr src;
cc2bcbf6 283 r = sd_ndisc_router_solicit_get_sender_address(rs, &src);
2a1e8909
YW		 284 if (r == -ENODATA) /* null address is allowed */
285 return sd_radv_send(ra); /* When an unsolicited RA, we need to also update timer. */
286 if (r < 0)
cc2bcbf6 287 return log_radv_errno(ra, r, "Failed to get sender address of RS, ignoring: %m");
2a1e8909 288 if (in6_addr_equal(&src, &ra->ipv6ll))
50ba4e40
YW		 289 /* This should be definitely caused by a misconfiguration. If we send RA to ourself, the
290 * kernel complains about that. Let's ignore the packet. */
291 return log_radv_errno(ra, SYNTHETIC_ERRNO(EADDRINUSE), "Received RS from the same interface, ignoring.");
88d5a3db 292
69628e3b 293 r = radv_send_router(ra, &src);
cc2bcbf6
YW		 294 if (r < 0)
295 return log_radv_errno(ra, r, "Unable to send solicited Router Advertisement to %s, ignoring: %m", IN6_ADDR_TO_STRING(&src));
88d5a3db 296
cc2bcbf6
YW		 297 log_radv(ra, "Sent solicited Router Advertisement to %s.", IN6_ADDR_TO_STRING(&src));
298 return 0;
299}
88d5a3db 300
cc2bcbf6
YW		 301static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
302 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
303 sd_radv *ra = ASSERT_PTR(userdata);
304 int r;
cfffddea 305
cc2bcbf6 306 assert(fd >= 0);
4961f566 307
cc2bcbf6
YW		 308 r = icmp6_packet_receive(fd, &packet);
309 if (r < 0) {
310 log_radv_errno(ra, r, "Failed to receive ICMPv6 packet, ignoring: %m");
311 return 0;
312 }
88d5a3db 313
cc2bcbf6 314 (void) radv_process_packet(ra, packet);
88d5a3db
PF		 315 return 0;
316}
317
204fb681 318static int radv_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
99534007 319 sd_radv *ra = ASSERT_PTR(userdata);
16e4dce6
YW		 320
321 if (sd_radv_send(ra) < 0)
322 (void) sd_radv_stop(ra);
323
324 return 0;
325}
326
327int sd_radv_send(sd_radv *ra) {
328 usec_t min_timeout, max_timeout, time_now, timeout;
7003b114 329 int r;
204fb681 330
16e4dce6
YW		 331 assert_return(ra, -EINVAL);
332 assert_return(ra->event, -EINVAL);
333 assert_return(sd_radv_is_running(ra), -EINVAL);
80477557 334 assert(router_lifetime_is_valid(ra->lifetime_usec));
204fb681 335
ba4e0427 336 r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
204fb681 337 if (r < 0)
16e4dce6 338 return r;
204fb681 339
69628e3b 340 r = radv_send_router(ra, NULL);
204fb681 341 if (r < 0)
16e4dce6
YW		 342 return log_radv_errno(ra, r, "Unable to send Router Advertisement: %m");
343
344 ra->ra_sent++;
204fb681
PF		 345
346 /* RFC 4861, Section 6.2.4, sending initial Router Advertisements */
16e4dce6 347 if (ra->ra_sent <= RADV_MAX_INITIAL_RTR_ADVERTISEMENTS)
d6fc0d67 348 max_timeout = RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC;
80477557 349 else
03ec10fd 350 max_timeout = RADV_DEFAULT_MAX_TIMEOUT_USEC;
204fb681 351
ef90b6a4 352 /* RFC 4861, Section 6.2.1, lifetime must be at least MaxRtrAdvInterval,
80477557
YW		 353 * so lower the interval here */
354 if (ra->lifetime_usec > 0)
355 max_timeout = MIN(max_timeout, ra->lifetime_usec);
356
357 if (max_timeout >= 9 * USEC_PER_SEC)
ef90b6a4 358 min_timeout = max_timeout / 3;
80477557
YW		 359 else
360 min_timeout = max_timeout * 3 / 4;
ef90b6a4 361
80477557
YW		 362 /* RFC 4861, Section 6.2.1.
363 * MaxRtrAdvInterval MUST be no less than 4 seconds and no greater than 1800 seconds.
364 * MinRtrAdvInterval MUST be no less than 3 seconds and no greater than .75 * MaxRtrAdvInterval. */
365 assert(max_timeout >= RADV_MIN_MAX_TIMEOUT_USEC);
366 assert(max_timeout <= RADV_MAX_MAX_TIMEOUT_USEC);
367 assert(min_timeout >= RADV_MIN_MIN_TIMEOUT_USEC);
368 assert(min_timeout <= max_timeout * 3 / 4);
ef90b6a4 369
80477557 370 timeout = min_timeout + random_u64_range(max_timeout - min_timeout);
16e4dce6
YW		 371 log_radv(ra, "Sent unsolicited Router Advertisement. Next advertisement will be in %s.",
372 FORMAT_TIMESPAN(timeout, USEC_PER_SEC));
373
374 return event_reset_time(
375 ra->event, &ra->timeout_event_source,
376 CLOCK_BOOTTIME,
377 usec_add(time_now, timeout), MSEC_PER_SEC,
378 radv_timeout, ra,
379 ra->event_priority, "radv-timeout", true);
204fb681
PF		 380}
381
17347053 382int sd_radv_stop(sd_radv *ra) {
204fb681
PF		 383 int r;
384
c8bae363
YW		 385 if (!ra)
386 return 0;
204f99d2 387
d6fc0d67 388 if (ra->state == RADV_STATE_IDLE)
6f8a8b84
SS		 389 return 0;
390
35388783 391 log_radv(ra, "Stopping IPv6 Router Advertisement daemon");
204f99d2 392
36653443
YW		 393 /* RFC 4861, Section 6.2.5:
394 * the router SHOULD transmit one or more (but not more than MAX_FINAL_RTR_ADVERTISEMENTS) final
395 * multicast Router Advertisements on the interface with a Router Lifetime field of zero. */
19f3cc86 396 r = radv_send_router_on_stop(ra);
290696e5 397 if (r < 0)
abb977a6 398 log_radv_errno(ra, r, "Unable to send last Router Advertisement with router lifetime set to zero, ignoring: %m");
204fb681
PF		 399
400 radv_reset(ra);
77baf5ae 401 ra->fd = safe_close(ra->fd);
d6fc0d67 402 ra->state = RADV_STATE_IDLE;
204f99d2
PF		 403
404 return 0;
405}
406
36653443
YW		 407static int radv_setup_recv_event(sd_radv *ra) {
408 int r;
409
410 assert(ra);
411 assert(ra->event);
412 assert(ra->ifindex > 0);
413
414 _cleanup_close_ int fd = -EBADF;
415 fd = icmp6_bind(ra->ifindex, /* is_router = */ true);
416 if (fd < 0)
417 return fd;
418
419 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
420 r = sd_event_add_io(ra->event, &s, fd, EPOLLIN, radv_recv, ra);
421 if (r < 0)
422 return r;
423
424 r = sd_event_source_set_priority(s, ra->event_priority);
425 if (r < 0)
426 return r;
427
428 (void) sd_event_source_set_description(s, "radv-receive-message");
429
430 ra->fd = TAKE_FD(fd);
431 ra->recv_event_source = TAKE_PTR(s);
432 return 0;
433}
434
17347053 435int sd_radv_start(sd_radv *ra) {
f474884c 436 int r;
204fb681 437
204f99d2
PF		 438 assert_return(ra, -EINVAL);
439 assert_return(ra->event, -EINVAL);
440 assert_return(ra->ifindex > 0, -EINVAL);
441
d6fc0d67 442 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 443 return 0;
444
36653443
YW		 445 r = radv_setup_recv_event(ra);
446 if (r < 0)
447 goto fail;
448
807a8ede 449 r = event_reset_time(ra->event, &ra->timeout_event_source,
ba4e0427 450 CLOCK_BOOTTIME,
807a8ede
YW		 451 0, 0,
452 radv_timeout, ra,
453 ra->event_priority, "radv-timeout", true);
204fb681
PF		 454 if (r < 0)
455 goto fail;
456
d6fc0d67 457 ra->state = RADV_STATE_ADVERTISING;
204f99d2 458
35388783 459 log_radv(ra, "Started IPv6 Router Advertisement daemon");
204f99d2
PF		 460
461 return 0;
204fb681
PF		 462
463 fail:
464 radv_reset(ra);
465
466 return r;
204f99d2
PF		 467}
468
17347053 469int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
204f99d2 470 assert_return(ra, -EINVAL);
7fa69c0a 471 assert_return(ifindex > 0, -EINVAL);
204f99d2 472
d6fc0d67 473 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 474 return -EBUSY;
475
476 ra->ifindex = ifindex;
477
478 return 0;
479}
480
61a9fa8f
YW		 481int sd_radv_set_ifname(sd_radv *ra, const char *ifname) {
482 assert_return(ra, -EINVAL);
483 assert_return(ifname, -EINVAL);
484
485 if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
486 return -EINVAL;
487
488 return free_and_strdup(&ra->ifname, ifname);
489}
490
5977b71f
YW		 491int sd_radv_get_ifname(sd_radv *ra, const char **ret) {
492 int r;
493
494 assert_return(ra, -EINVAL);
61a9fa8f 495
5977b71f
YW		 496 r = get_ifname(ra->ifindex, &ra->ifname);
497 if (r < 0)
498 return r;
499
500 if (ret)
501 *ret = ra->ifname;
502
503 return 0;
61a9fa8f
YW		 504}
505
50ba4e40
YW		 506int sd_radv_set_link_local_address(sd_radv *ra, const struct in6_addr *addr) {
507 assert_return(ra, -EINVAL);
508 assert_return(!addr || in6_addr_is_link_local(addr), -EINVAL);
509
510 if (addr)
511 ra->ipv6ll = *addr;
512 else
513 zero(ra->ipv6ll);
514
515 return 0;
516}
517
17347053 518int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
204f99d2
PF		 519 assert_return(ra, -EINVAL);
520
d6fc0d67 521 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 522 return -EBUSY;
523
524 if (mac_addr)
525 ra->mac_addr = *mac_addr;
526 else
527 zero(ra->mac_addr);
528
529 return 0;
530}
531
17347053 532int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
204f99d2
PF		 533 assert_return(ra, -EINVAL);
534 assert_return(mtu >= 1280, -EINVAL);
535
204f99d2
PF		 536 ra->mtu = mtu;
537
538 return 0;
539}
540
17347053 541int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
204f99d2
PF		 542 assert_return(ra, -EINVAL);
543
d6fc0d67 544 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 545 return -EBUSY;
546
547 ra->hop_limit = hop_limit;
548
549 return 0;
550}
551
eca280c8 552int sd_radv_set_retransmit(sd_radv *ra, uint64_t usec) {
fdc4c67c
SS		 553 assert_return(ra, -EINVAL);
554
555 if (ra->state != RADV_STATE_IDLE)
556 return -EBUSY;
557
eca280c8
YW		 558 if (usec > RADV_MAX_RETRANSMIT_USEC)
559 return -EINVAL;
fdc4c67c 560
eca280c8 561 ra->retransmit_usec = usec;
fdc4c67c
SS		 562 return 0;
563}
564
eca280c8 565int sd_radv_set_router_lifetime(sd_radv *ra, uint64_t usec) {
204f99d2
PF		 566 assert_return(ra, -EINVAL);
567
d6fc0d67 568 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 569 return -EBUSY;
570
eca280c8 571 if (!router_lifetime_is_valid(usec))
09457670
YW		 572 return -EINVAL;
573
ac138551
YW		 574 /* RFC 4191, Section 2.2, "...If the Router Lifetime is zero, the preference value MUST be set
575 * to (00) by the sender..." */
eca280c8 576 if (usec == 0 &&
204f99d2 577 (ra->flags & (0x3 << 3)) != (SD_NDISC_PREFERENCE_MEDIUM << 3))
09457670 578 return -EINVAL;
204f99d2 579
eca280c8 580 ra->lifetime_usec = usec;
204f99d2
PF		 581 return 0;
582}
583
17347053 584int sd_radv_set_managed_information(sd_radv *ra, int managed) {
204f99d2
PF		 585 assert_return(ra, -EINVAL);
586
d6fc0d67 587 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 588 return -EBUSY;
589
590 SET_FLAG(ra->flags, ND_RA_FLAG_MANAGED, managed);
591
592 return 0;
593}
594
17347053 595int sd_radv_set_other_information(sd_radv *ra, int other) {
204f99d2
PF		 596 assert_return(ra, -EINVAL);
597
d6fc0d67 598 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 599 return -EBUSY;
600
601 SET_FLAG(ra->flags, ND_RA_FLAG_OTHER, other);
602
603 return 0;
604}
605
17347053 606int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
204f99d2
PF		 607 assert_return(ra, -EINVAL);
608 assert_return(IN_SET(preference,
609 SD_NDISC_PREFERENCE_LOW,
610 SD_NDISC_PREFERENCE_MEDIUM,
611 SD_NDISC_PREFERENCE_HIGH), -EINVAL);
612
dd1b1870
YW		 613 /* RFC 4191, Section 2.2, "...If the Router Lifetime is zero, the preference value MUST be set
614 * to (00) by the sender..." */
7003b114 615 if (ra->lifetime_usec == 0 && preference != SD_NDISC_PREFERENCE_MEDIUM)
dd1b1870
YW		 616 return -EINVAL;
617
204f99d2
PF		 618 ra->flags = (ra->flags & ~(0x3 << 3)) | (preference << 3);
619
dd1b1870 620 return 0;
204f99d2
PF		 621}
622
6a6d27bc
SS		 623int sd_radv_set_home_agent_information(sd_radv *ra, int home_agent) {
624 assert_return(ra, -EINVAL);
625
626 if (ra->state != RADV_STATE_IDLE)
627 return -EBUSY;
628
629 SET_FLAG(ra->flags, ND_RA_FLAG_HOME_AGENT, home_agent);
630
631 return 0;
632}
633
634int sd_radv_set_home_agent_preference(sd_radv *ra, uint16_t preference) {
635 assert_return(ra, -EINVAL);
636
637 if (ra->state != RADV_STATE_IDLE)
638 return -EBUSY;
639
640 ra->home_agent.nd_opt_home_agent_info_preference = htobe16(preference);
641
642 return 0;
643}
644
eca280c8 645int sd_radv_set_home_agent_lifetime(sd_radv *ra, uint64_t lifetime_usec) {
6a6d27bc
SS		 646 assert_return(ra, -EINVAL);
647
648 if (ra->state != RADV_STATE_IDLE)
649 return -EBUSY;
650
eca280c8
YW		 651 if (lifetime_usec > RADV_HOME_AGENT_MAX_LIFETIME_USEC)
652 return -EINVAL;
6a6d27bc 653
eca280c8 654 ra->home_agent.nd_opt_home_agent_info_lifetime = usec_to_be16_sec(lifetime_usec);
6a6d27bc
SS		 655 return 0;
656}
657
17347053 658int sd_radv_add_prefix(sd_radv *ra, sd_radv_prefix *p) {
03677889 659 sd_radv_prefix *found = NULL;
d601b566 660 int r;
204f99d2
PF		 661
662 assert_return(ra, -EINVAL);
acbb5500 663 assert_return(p, -EINVAL);
204f99d2 664
59ea6e57 665 /* Refuse prefixes that don't have a prefix set */
94876904 666 if (in6_addr_is_null(&p->opt.in6_addr))
59ea6e57
LP		 667 return -ENOEXEC;
668
c71384a9 669 const char *addr_p = IN6_ADDR_PREFIX_TO_STRING(&p->opt.in6_addr, p->opt.prefixlen);
5380707a 670
204f99d2 671 LIST_FOREACH(prefix, cur, ra->prefixes) {
204f99d2 672 r = in_addr_prefix_intersect(AF_INET6,
c633628d 673 (const union in_addr_union*) &cur->opt.in6_addr,
204f99d2 674 cur->opt.prefixlen,
c633628d 675 (const union in_addr_union*) &p->opt.in6_addr,
204f99d2 676 p->opt.prefixlen);
5380707a
YW		 677 if (r < 0)
678 return r;
679 if (r == 0)
680 continue;
204f99d2 681
95e104e0 682 if (cur->opt.prefixlen == p->opt.prefixlen) {
56aa5143 683 found = cur;
b9f27a05 684 break;
95e104e0 685 }
d601b566 686
35388783 687 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
95e104e0 688 "IPv6 prefix %s conflicts with %s, ignoring.",
c71384a9
ZJS		 689 addr_p,
690 IN6_ADDR_PREFIX_TO_STRING(&cur->opt.in6_addr, cur->opt.prefixlen));
204f99d2
PF		 691 }
692
56aa5143 693 if (found) {
b9f27a05
YW		 694 /* p and cur may be equivalent. First increment the reference counter. */
695 sd_radv_prefix_ref(p);
696
697 /* Then, remove the old entry. */
56aa5143
YW		 698 LIST_REMOVE(prefix, ra->prefixes, found);
699 sd_radv_prefix_unref(found);
b9f27a05
YW		 700
701 /* Finally, add the new entry. */
702 LIST_APPEND(prefix, ra->prefixes, p);
703
704 log_radv(ra, "Updated/replaced IPv6 prefix %s (preferred: %s, valid: %s)",
c71384a9 705 addr_p,
b9f27a05
YW		 706 FORMAT_TIMESPAN(p->lifetime_preferred_usec, USEC_PER_SEC),
707 FORMAT_TIMESPAN(p->lifetime_valid_usec, USEC_PER_SEC));
708 } else {
709 /* The prefix is new. Let's simply add it. */
710
711 sd_radv_prefix_ref(p);
712 LIST_APPEND(prefix, ra->prefixes, p);
713 ra->n_prefixes++;
204f99d2 714
c71384a9 715 log_radv(ra, "Added prefix %s", addr_p);
b9f27a05 716 }
059d7b6e
YW		 717
718 if (ra->state == RADV_STATE_IDLE)
719 return 0;
720
059d7b6e 721 if (ra->ra_sent == 0)
d601b566 722 return 0;
d601b566 723
97efde65 724 /* If RAs have already been sent, send an RA immediately to announce the newly-added prefix */
69628e3b 725 r = radv_send_router(ra, NULL);
059d7b6e 726 if (r < 0)
abb977a6 727 log_radv_errno(ra, r, "Unable to send Router Advertisement for added prefix %s, ignoring: %m", addr_p);
059d7b6e 728 else
c71384a9 729 log_radv(ra, "Sent Router Advertisement for added/updated prefix %s.", addr_p);
97efde65 730
204f99d2
PF		 731 return 0;
732}
733
95931532
YW		 734void sd_radv_remove_prefix(
735 sd_radv *ra,
736 const struct in6_addr *prefix,
737 unsigned char prefixlen) {
34c169c4 738
95931532
YW		 739 if (!ra)
740 return;
34c169c4 741
95931532
YW		 742 if (!prefix)
743 return;
744
745 LIST_FOREACH(prefix, cur, ra->prefixes) {
34c169c4
PF		 746 if (prefixlen != cur->opt.prefixlen)
747 continue;
748
94876904 749 if (!in6_addr_equal(prefix, &cur->opt.in6_addr))
34c169c4
PF		 750 continue;
751
752 LIST_REMOVE(prefix, ra->prefixes, cur);
753 ra->n_prefixes--;
62bbbedf 754 sd_radv_prefix_unref(cur);
95931532 755 return;
34c169c4 756 }
34c169c4
PF		 757}
758
17347053 759int sd_radv_add_route_prefix(sd_radv *ra, sd_radv_route_prefix *p) {
03677889 760 sd_radv_route_prefix *found = NULL;
203d4df5
SS		 761 int r;
762
763 assert_return(ra, -EINVAL);
acbb5500 764 assert_return(p, -EINVAL);
203d4df5 765
c71384a9 766 const char *addr_p = IN6_ADDR_PREFIX_TO_STRING(&p->opt.in6_addr, p->opt.prefixlen);
203d4df5
SS		 767
768 LIST_FOREACH(prefix, cur, ra->route_prefixes) {
203d4df5 769 r = in_addr_prefix_intersect(AF_INET6,
c633628d 770 (const union in_addr_union*) &cur->opt.in6_addr,
203d4df5 771 cur->opt.prefixlen,
c633628d 772 (const union in_addr_union*) &p->opt.in6_addr,
203d4df5
SS		 773 p->opt.prefixlen);
774 if (r < 0)
775 return r;
776 if (r == 0)
777 continue;
778
95e104e0 779 if (cur->opt.prefixlen == p->opt.prefixlen) {
56aa5143 780 found = cur;
b9f27a05 781 break;
95e104e0 782 }
203d4df5 783
35388783 784 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
95e104e0 785 "IPv6 route prefix %s conflicts with %s, ignoring.",
c71384a9
ZJS		 786 addr_p,
787 IN6_ADDR_PREFIX_TO_STRING(&cur->opt.in6_addr, cur->opt.prefixlen));
203d4df5
SS		 788 }
789
56aa5143 790 if (found) {
b9f27a05
YW		 791 /* p and cur may be equivalent. First increment the reference counter. */
792 sd_radv_route_prefix_ref(p);
793
794 /* Then, remove the old entry. */
56aa5143
YW		 795 LIST_REMOVE(prefix, ra->route_prefixes, found);
796 sd_radv_route_prefix_unref(found);
b9f27a05
YW		 797
798 /* Finally, add the new entry. */
799 LIST_APPEND(prefix, ra->route_prefixes, p);
800
801 log_radv(ra, "Updated/replaced IPv6 route prefix %s (lifetime: %s)",
802 strna(addr_p),
803 FORMAT_TIMESPAN(p->lifetime_usec, USEC_PER_SEC));
804 } else {
805 /* The route prefix is new. Let's simply add it. */
806
807 sd_radv_route_prefix_ref(p);
808 LIST_APPEND(prefix, ra->route_prefixes, p);
809 ra->n_route_prefixes++;
810
811 log_radv(ra, "Added route prefix %s", strna(addr_p));
812 }
059d7b6e
YW		 813
814 if (ra->state == RADV_STATE_IDLE)
815 return 0;
816
059d7b6e 817 if (ra->ra_sent == 0)
203d4df5 818 return 0;
203d4df5 819
97efde65 820 /* If RAs have already been sent, send an RA immediately to announce the newly-added route prefix */
69628e3b 821 r = radv_send_router(ra, NULL);
059d7b6e 822 if (r < 0)
abb977a6 823 log_radv_errno(ra, r, "Unable to send Router Advertisement for added route prefix %s, ignoring: %m",
b9f27a05 824 strna(addr_p));
059d7b6e 825 else
b9f27a05 826 log_radv(ra, "Sent Router Advertisement for added route prefix %s.", strna(addr_p));
97efde65 827
203d4df5
SS		 828 return 0;
829}
830
1925f829
SS		 831int sd_radv_add_pref64_prefix(sd_radv *ra, sd_radv_pref64_prefix *p) {
832 sd_radv_pref64_prefix *found = NULL;
833 int r;
834
835 assert_return(ra, -EINVAL);
836 assert_return(p, -EINVAL);
837
838 const char *addr_p = IN6_ADDR_PREFIX_TO_STRING(&p->in6_addr, p->prefixlen);
839
840 LIST_FOREACH(prefix, cur, ra->pref64_prefixes) {
841 r = in_addr_prefix_intersect(AF_INET6,
842 (const union in_addr_union*) &cur->in6_addr,
843 cur->prefixlen,
844 (const union in_addr_union*) &p->in6_addr,
845 p->prefixlen);
846 if (r < 0)
847 return r;
848 if (r == 0)
849 continue;
850
851 if (cur->prefixlen == p->prefixlen) {
852 found = cur;
853 break;
854 }
855
856 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
857 "IPv6 PREF64 prefix %s conflicts with %s, ignoring.",
858 addr_p,
859 IN6_ADDR_PREFIX_TO_STRING(&cur->in6_addr, cur->prefixlen));
860 }
861
862 if (found) {
863 /* p and cur may be equivalent. First increment the reference counter. */
864 sd_radv_pref64_prefix_ref(p);
865
866 /* Then, remove the old entry. */
867 LIST_REMOVE(prefix, ra->pref64_prefixes, found);
868 sd_radv_pref64_prefix_unref(found);
869
870 /* Finally, add the new entry. */
871 LIST_APPEND(prefix, ra->pref64_prefixes, p);
872
873 log_radv(ra, "Updated/replaced IPv6 PREF64 prefix %s (lifetime: %s)",
874 strna(addr_p),
875 FORMAT_TIMESPAN(p->lifetime_usec, USEC_PER_SEC));
876 } else {
877 /* The route prefix is new. Let's simply add it. */
878
879 sd_radv_pref64_prefix_ref(p);
880 LIST_APPEND(prefix, ra->pref64_prefixes, p);
881 ra->n_pref64_prefixes++;
882
883 log_radv(ra, "Added PREF64 prefix %s", strna(addr_p));
884 }
885
886 if (ra->state == RADV_STATE_IDLE)
887 return 0;
888
889 if (ra->ra_sent == 0)
890 return 0;
891
892 /* If RAs have already been sent, send an RA immediately to announce the newly-added route prefix */
69628e3b 893 r = radv_send_router(ra, NULL);
1925f829
SS		 894 if (r < 0)
895 log_radv_errno(ra, r, "Unable to send Router Advertisement for added PREF64 prefix %s, ignoring: %m",
896 strna(addr_p));
897 else
898 log_radv(ra, "Sent Router Advertisement for added PREF64 prefix %s.", strna(addr_p));
899
900 return 0;
901}
902
faaf3d66
YW		 903int sd_radv_set_rdnss(
904 sd_radv *ra,
eca280c8 905 uint64_t lifetime_usec,
faaf3d66
YW		 906 const struct in6_addr *dns,
907 size_t n_dns) {
908
e9c6da38
PF		 909 _cleanup_free_ struct sd_radv_opt_dns *opt_rdnss = NULL;
910 size_t len;
911
912 assert_return(ra, -EINVAL);
913 assert_return(n_dns < 128, -EINVAL);
914
eca280c8
YW		 915 if (lifetime_usec > RADV_RDNSS_MAX_LIFETIME_USEC)
916 return -EINVAL;
917
e9c6da38
PF		 918 if (!dns || n_dns == 0) {
919 ra->rdnss = mfree(ra->rdnss);
920 ra->n_rdnss = 0;
921
922 return 0;
923 }
924
925 len = sizeof(struct sd_radv_opt_dns) + sizeof(struct in6_addr) * n_dns;
926
927 opt_rdnss = malloc0(len);
928 if (!opt_rdnss)
929 return -ENOMEM;
930
d6fc0d67 931 opt_rdnss->type = RADV_OPT_RDNSS;
e9c6da38 932 opt_rdnss->length = len / 8;
eca280c8 933 opt_rdnss->lifetime = usec_to_be32_sec(lifetime_usec);
e9c6da38
PF		 934
935 memcpy(opt_rdnss + 1, dns, n_dns * sizeof(struct in6_addr));
936
1cc6c93a 937 free_and_replace(ra->rdnss, opt_rdnss);
e9c6da38
PF		 938
939 ra->n_rdnss = n_dns;
940
941 return 0;
942}
943
faaf3d66
YW		 944int sd_radv_set_dnssl(
945 sd_radv *ra,
eca280c8 946 uint64_t lifetime_usec,
faaf3d66
YW		 947 char **search_list) {
948
e965d6ab
PF		 949 _cleanup_free_ struct sd_radv_opt_dns *opt_dnssl = NULL;
950 size_t len = 0;
e965d6ab
PF		 951 uint8_t *p;
952
953 assert_return(ra, -EINVAL);
954
eca280c8
YW		 955 if (lifetime_usec > RADV_DNSSL_MAX_LIFETIME_USEC)
956 return -EINVAL;
957
97d7974b 958 if (strv_isempty(search_list)) {
e965d6ab 959 ra->dnssl = mfree(ra->dnssl);
e965d6ab
PF		 960 return 0;
961 }
962
963 STRV_FOREACH(s, search_list)
964 len += strlen(*s) + 2;
965
966 len = (sizeof(struct sd_radv_opt_dns) + len + 7) & ~0x7;
967
968 opt_dnssl = malloc0(len);
969 if (!opt_dnssl)
970 return -ENOMEM;
971
d6fc0d67 972 opt_dnssl->type = RADV_OPT_DNSSL;
e965d6ab 973 opt_dnssl->length = len / 8;
eca280c8 974 opt_dnssl->lifetime = usec_to_be32_sec(lifetime_usec);
e965d6ab
PF		 975
976 p = (uint8_t *)(opt_dnssl + 1);
977 len -= sizeof(struct sd_radv_opt_dns);
978
979 STRV_FOREACH(s, search_list) {
980 int r;
981
982 r = dns_name_to_wire_format(*s, p, len, false);
983 if (r < 0)
984 return r;
985
986 if (len < (size_t)r)
987 return -ENOBUFS;
988
989 p += r;
990 len -= r;
991 }
992
1cc6c93a 993 free_and_replace(ra->dnssl, opt_dnssl);
e965d6ab
PF		 994
995 return 0;
996}
997
17347053 998int sd_radv_prefix_new(sd_radv_prefix **ret) {
d2c8eed2 999 sd_radv_prefix *p;
04473969
PF		 1000
1001 assert_return(ret, -EINVAL);
1002
d2c8eed2 1003 p = new(sd_radv_prefix, 1);
04473969
PF		 1004 if (!p)
1005 return -ENOMEM;
1006
d2c8eed2
LP		 1007 *p = (sd_radv_prefix) {
1008 .n_ref = 1,
04473969 1009
d2c8eed2
LP		 1010 .opt.type = ND_OPT_PREFIX_INFORMATION,
1011 .opt.length = (sizeof(p->opt) - 1)/8 + 1,
1012 .opt.prefixlen = 64,
04473969 1013
d2c8eed2
LP		 1014 /* RFC 4861, Section 6.2.1 */
1015 .opt.flags = ND_OPT_PI_FLAG_ONLINK|ND_OPT_PI_FLAG_AUTO,
204f99d2 1016
d951507d
YW		 1017 .lifetime_valid_usec = RADV_DEFAULT_VALID_LIFETIME_USEC,
1018 .lifetime_preferred_usec = RADV_DEFAULT_PREFERRED_LIFETIME_USEC,
95e104e0
YW		 1019 .valid_until = USEC_INFINITY,
1020 .preferred_until = USEC_INFINITY,
d2c8eed2 1021 };
04473969 1022
d2c8eed2 1023 *ret = p;
04473969
PF		 1024 return 0;
1025}
1026
8301aa0b 1027DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_prefix, sd_radv_prefix, mfree);
04473969 1028
faaf3d66
YW		 1029int sd_radv_prefix_set_prefix(
1030 sd_radv_prefix *p,
1031 const struct in6_addr *in6_addr,
1032 unsigned char prefixlen) {
1033
04473969
PF		 1034 assert_return(p, -EINVAL);
1035 assert_return(in6_addr, -EINVAL);
1036
1037 if (prefixlen < 3 || prefixlen > 128)
1038 return -EINVAL;
1039
1040 if (prefixlen > 64)
1041 /* unusual but allowed, log it */
35388783 1042 log_radv(NULL, "Unusual prefix length %d greater than 64", prefixlen);
04473969
PF		 1043
1044 p->opt.in6_addr = *in6_addr;
1045 p->opt.prefixlen = prefixlen;
1046
1047 return 0;
1048}
1049
faaf3d66
YW		 1050int sd_radv_prefix_get_prefix(
1051 sd_radv_prefix *p,
1052 struct in6_addr *ret_in6_addr,
1053 unsigned char *ret_prefixlen) {
1054
34332af2
SS		 1055 assert_return(p, -EINVAL);
1056 assert_return(ret_in6_addr, -EINVAL);
1057 assert_return(ret_prefixlen, -EINVAL);
1058
1059 *ret_in6_addr = p->opt.in6_addr;
1060 *ret_prefixlen = p->opt.prefixlen;
1061
1062 return 0;
1063}
1064
17347053 1065int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
04473969
PF		 1066 assert_return(p, -EINVAL);
1067
1068 SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_ONLINK, onlink);
1069
1070 return 0;
1071}
1072
faaf3d66 1073int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p, int address_autoconfiguration) {
04473969
PF		 1074 assert_return(p, -EINVAL);
1075
1076 SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_AUTO, address_autoconfiguration);
1077
1078 return 0;
1079}
1080
17347053 1081int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
04473969
PF		 1082 assert_return(p, -EINVAL);
1083
95e104e0
YW		 1084 p->lifetime_valid_usec = lifetime_usec;
1085 p->valid_until = valid_until;
04473969
PF		 1086
1087 return 0;
1088}
1089
17347053 1090int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
04473969
PF		 1091 assert_return(p, -EINVAL);
1092
95e104e0
YW		 1093 p->lifetime_preferred_usec = lifetime_usec;
1094 p->preferred_until = valid_until;
04473969
PF		 1095
1096 return 0;
1097}
203d4df5 1098
17347053 1099int sd_radv_route_prefix_new(sd_radv_route_prefix **ret) {
203d4df5
SS		 1100 sd_radv_route_prefix *p;
1101
1102 assert_return(ret, -EINVAL);
1103
1104 p = new(sd_radv_route_prefix, 1);
1105 if (!p)
1106 return -ENOMEM;
1107
1108 *p = (sd_radv_route_prefix) {
1109 .n_ref = 1,
1110
d6fc0d67 1111 .opt.type = RADV_OPT_ROUTE_INFORMATION,
203d4df5
SS		 1112 .opt.length = DIV_ROUND_UP(sizeof(p->opt), 8),
1113 .opt.prefixlen = 64,
1114
d951507d 1115 .lifetime_usec = RADV_DEFAULT_VALID_LIFETIME_USEC,
95e104e0 1116 .valid_until = USEC_INFINITY,
203d4df5
SS		 1117 };
1118
1119 *ret = p;
1120 return 0;
1121}
1122
1123DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_route_prefix, sd_radv_route_prefix, mfree);
1124
faaf3d66
YW		 1125int sd_radv_route_prefix_set_prefix(
1126 sd_radv_route_prefix *p,
1127 const struct in6_addr *in6_addr,
1128 unsigned char prefixlen) {
1129
203d4df5
SS		 1130 assert_return(p, -EINVAL);
1131 assert_return(in6_addr, -EINVAL);
1132
1133 if (prefixlen > 128)
1134 return -EINVAL;
1135
1136 if (prefixlen > 64)
1137 /* unusual but allowed, log it */
35388783 1138 log_radv(NULL, "Unusual prefix length %u greater than 64", prefixlen);
203d4df5
SS		 1139
1140 p->opt.in6_addr = *in6_addr;
1141 p->opt.prefixlen = prefixlen;
1142
1143 return 0;
1144}
1145
17347053 1146int sd_radv_route_prefix_set_lifetime(sd_radv_route_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
203d4df5
SS		 1147 assert_return(p, -EINVAL);
1148
95e104e0
YW		 1149 p->lifetime_usec = lifetime_usec;
1150 p->valid_until = valid_until;
203d4df5
SS		 1151
1152 return 0;
1153}
1925f829
SS		 1154
1155int sd_radv_pref64_prefix_new(sd_radv_pref64_prefix **ret) {
1156 sd_radv_pref64_prefix *p;
1157
1158 assert_return(ret, -EINVAL);
1159
1160 p = new(sd_radv_pref64_prefix, 1);
1161 if (!p)
1162 return -ENOMEM;
1163
1164 *p = (sd_radv_pref64_prefix) {
1165 .n_ref = 1,
1166
1167 .opt.type = RADV_OPT_PREF64,
1168 .opt.length = 2,
1169 };
1170
1171 *ret = p;
1172 return 0;
1173}
1174
1175DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_pref64_prefix, sd_radv_pref64_prefix, mfree);
1176
1177int sd_radv_pref64_prefix_set_prefix(
1178 sd_radv_pref64_prefix *p,
1179 const struct in6_addr *prefix,
1180 uint8_t prefixlen,
1181 uint64_t lifetime_usec) {
1182
1183 uint16_t pref64_lifetime;
1184 uint8_t prefixlen_code;
6e8f5e4c 1185 int r;
1925f829
SS		 1186
1187 assert_return(p, -EINVAL);
1188 assert_return(prefix, -EINVAL);
1189
6e8f5e4c
SS		 1190 r = pref64_prefix_length_to_plc(prefixlen, &prefixlen_code);
1191 if (r < 0)
f31fa080
ZJS		 1192 return log_radv_errno(NULL, r,
1193 "Unsupported PREF64 prefix length %u. Valid lengths are 32, 40, 48, 56, 64 and 96", prefixlen);
1925f829 1194
eca280c8 1195 if (lifetime_usec > PREF64_MAX_LIFETIME_USEC)
1925f829
SS		 1196 return -EINVAL;
1197
1198 /* RFC 8781 - 4.1 rounding up lifetime to multiply of 8 */
1199 pref64_lifetime = DIV_ROUND_UP(lifetime_usec, 8 * USEC_PER_SEC) << 3;
1200 pref64_lifetime |= prefixlen_code;
1201
1202 unaligned_write_be16(&p->opt.lifetime_and_plc, pref64_lifetime);
1203 memcpy(&p->opt.prefix, prefix, sizeof(p->opt.prefix));
1204
1205 p->in6_addr = *prefix;
1206 p->prefixlen = prefixlen;
1207
1208 return 0;
1209}
Unnamed repository; edit this file 'description' to name the repository.