]> 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
test: initialize _cleanup_ variables
[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
cc2bcbf6
YW		 282 struct in6_addr src = {};
283 r = sd_ndisc_router_solicit_get_sender_address(rs, &src);
284 if (r < 0 && r != -ENODATA) /* null address is allowed */
285 return log_radv_errno(ra, r, "Failed to get sender address of RS, ignoring: %m");
50ba4e40
YW		 286 if (r >= 0 && in6_addr_equal(&src, &ra->ipv6ll))
287 /* This should be definitely caused by a misconfiguration. If we send RA to ourself, the
288 * kernel complains about that. Let's ignore the packet. */
289 return log_radv_errno(ra, SYNTHETIC_ERRNO(EADDRINUSE), "Received RS from the same interface, ignoring.");
88d5a3db 290
69628e3b 291 r = radv_send_router(ra, &src);
cc2bcbf6
YW		 292 if (r < 0)
293 return log_radv_errno(ra, r, "Unable to send solicited Router Advertisement to %s, ignoring: %m", IN6_ADDR_TO_STRING(&src));
88d5a3db 294
cc2bcbf6
YW		 295 log_radv(ra, "Sent solicited Router Advertisement to %s.", IN6_ADDR_TO_STRING(&src));
296 return 0;
297}
88d5a3db 298
cc2bcbf6
YW		 299static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
300 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
301 sd_radv *ra = ASSERT_PTR(userdata);
302 int r;
cfffddea 303
cc2bcbf6 304 assert(fd >= 0);
4961f566 305
cc2bcbf6
YW		 306 r = icmp6_packet_receive(fd, &packet);
307 if (r < 0) {
308 log_radv_errno(ra, r, "Failed to receive ICMPv6 packet, ignoring: %m");
309 return 0;
310 }
88d5a3db 311
cc2bcbf6 312 (void) radv_process_packet(ra, packet);
88d5a3db
PF		 313 return 0;
314}
315
204fb681 316static int radv_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
7003b114 317 usec_t min_timeout, max_timeout, time_now, timeout;
99534007 318 sd_radv *ra = ASSERT_PTR(userdata);
7003b114 319 int r;
204fb681
PF		 320
321 assert(s);
204fb681 322 assert(ra->event);
80477557 323 assert(router_lifetime_is_valid(ra->lifetime_usec));
204fb681 324
ba4e0427 325 r = sd_event_now(ra->event, CLOCK_BOOTTIME, &time_now);
204fb681
PF		 326 if (r < 0)
327 goto fail;
328
69628e3b 329 r = radv_send_router(ra, NULL);
204fb681 330 if (r < 0)
abb977a6 331 log_radv_errno(ra, r, "Unable to send Router Advertisement, ignoring: %m");
204fb681
PF		 332
333 /* RFC 4861, Section 6.2.4, sending initial Router Advertisements */
80477557 334 if (ra->ra_sent < RADV_MAX_INITIAL_RTR_ADVERTISEMENTS)
d6fc0d67 335 max_timeout = RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC;
80477557 336 else
03ec10fd 337 max_timeout = RADV_DEFAULT_MAX_TIMEOUT_USEC;
204fb681 338
ef90b6a4 339 /* RFC 4861, Section 6.2.1, lifetime must be at least MaxRtrAdvInterval,
80477557
YW		 340 * so lower the interval here */
341 if (ra->lifetime_usec > 0)
342 max_timeout = MIN(max_timeout, ra->lifetime_usec);
343
344 if (max_timeout >= 9 * USEC_PER_SEC)
ef90b6a4 345 min_timeout = max_timeout / 3;
80477557
YW		 346 else
347 min_timeout = max_timeout * 3 / 4;
ef90b6a4 348
80477557
YW		 349 /* RFC 4861, Section 6.2.1.
350 * MaxRtrAdvInterval MUST be no less than 4 seconds and no greater than 1800 seconds.
351 * MinRtrAdvInterval MUST be no less than 3 seconds and no greater than .75 * MaxRtrAdvInterval. */
352 assert(max_timeout >= RADV_MIN_MAX_TIMEOUT_USEC);
353 assert(max_timeout <= RADV_MAX_MAX_TIMEOUT_USEC);
354 assert(min_timeout >= RADV_MIN_MIN_TIMEOUT_USEC);
355 assert(min_timeout <= max_timeout * 3 / 4);
ef90b6a4 356
80477557 357 timeout = min_timeout + random_u64_range(max_timeout - min_timeout);
5291f26d 358 log_radv(ra, "Next Router Advertisement in %s", FORMAT_TIMESPAN(timeout, USEC_PER_SEC));
204fb681 359
807a8ede 360 r = event_reset_time(ra->event, &ra->timeout_event_source,
ba4e0427 361 CLOCK_BOOTTIME,
80477557 362 usec_add(time_now, timeout), MSEC_PER_SEC,
807a8ede
YW		 363 radv_timeout, ra,
364 ra->event_priority, "radv-timeout", true);
204fb681
PF		 365 if (r < 0)
366 goto fail;
367
368 ra->ra_sent++;
369
807a8ede
YW		 370 return 0;
371
204fb681 372fail:
290696e5 373 sd_radv_stop(ra);
204fb681
PF		 374
375 return 0;
376}
377
17347053 378int sd_radv_stop(sd_radv *ra) {
204fb681
PF		 379 int r;
380
c8bae363
YW		 381 if (!ra)
382 return 0;
204f99d2 383
d6fc0d67 384 if (ra->state == RADV_STATE_IDLE)
6f8a8b84
SS		 385 return 0;
386
35388783 387 log_radv(ra, "Stopping IPv6 Router Advertisement daemon");
204f99d2 388
36653443
YW		 389 /* RFC 4861, Section 6.2.5:
390 * the router SHOULD transmit one or more (but not more than MAX_FINAL_RTR_ADVERTISEMENTS) final
391 * multicast Router Advertisements on the interface with a Router Lifetime field of zero. */
19f3cc86 392 r = radv_send_router_on_stop(ra);
290696e5 393 if (r < 0)
abb977a6 394 log_radv_errno(ra, r, "Unable to send last Router Advertisement with router lifetime set to zero, ignoring: %m");
204fb681
PF		 395
396 radv_reset(ra);
77baf5ae 397 ra->fd = safe_close(ra->fd);
d6fc0d67 398 ra->state = RADV_STATE_IDLE;
204f99d2
PF		 399
400 return 0;
401}
402
36653443
YW		 403static int radv_setup_recv_event(sd_radv *ra) {
404 int r;
405
406 assert(ra);
407 assert(ra->event);
408 assert(ra->ifindex > 0);
409
410 _cleanup_close_ int fd = -EBADF;
411 fd = icmp6_bind(ra->ifindex, /* is_router = */ true);
412 if (fd < 0)
413 return fd;
414
415 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
416 r = sd_event_add_io(ra->event, &s, fd, EPOLLIN, radv_recv, ra);
417 if (r < 0)
418 return r;
419
420 r = sd_event_source_set_priority(s, ra->event_priority);
421 if (r < 0)
422 return r;
423
424 (void) sd_event_source_set_description(s, "radv-receive-message");
425
426 ra->fd = TAKE_FD(fd);
427 ra->recv_event_source = TAKE_PTR(s);
428 return 0;
429}
430
17347053 431int sd_radv_start(sd_radv *ra) {
f474884c 432 int r;
204fb681 433
204f99d2
PF		 434 assert_return(ra, -EINVAL);
435 assert_return(ra->event, -EINVAL);
436 assert_return(ra->ifindex > 0, -EINVAL);
437
d6fc0d67 438 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 439 return 0;
440
36653443
YW		 441 r = radv_setup_recv_event(ra);
442 if (r < 0)
443 goto fail;
444
807a8ede 445 r = event_reset_time(ra->event, &ra->timeout_event_source,
ba4e0427 446 CLOCK_BOOTTIME,
807a8ede
YW		 447 0, 0,
448 radv_timeout, ra,
449 ra->event_priority, "radv-timeout", true);
204fb681
PF		 450 if (r < 0)
451 goto fail;
452
d6fc0d67 453 ra->state = RADV_STATE_ADVERTISING;
204f99d2 454
35388783 455 log_radv(ra, "Started IPv6 Router Advertisement daemon");
204f99d2
PF		 456
457 return 0;
204fb681
PF		 458
459 fail:
460 radv_reset(ra);
461
462 return r;
204f99d2
PF		 463}
464
17347053 465int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
204f99d2 466 assert_return(ra, -EINVAL);
7fa69c0a 467 assert_return(ifindex > 0, -EINVAL);
204f99d2 468
d6fc0d67 469 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 470 return -EBUSY;
471
472 ra->ifindex = ifindex;
473
474 return 0;
475}
476
61a9fa8f
YW		 477int sd_radv_set_ifname(sd_radv *ra, const char *ifname) {
478 assert_return(ra, -EINVAL);
479 assert_return(ifname, -EINVAL);
480
481 if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
482 return -EINVAL;
483
484 return free_and_strdup(&ra->ifname, ifname);
485}
486
5977b71f
YW		 487int sd_radv_get_ifname(sd_radv *ra, const char **ret) {
488 int r;
489
490 assert_return(ra, -EINVAL);
61a9fa8f 491
5977b71f
YW		 492 r = get_ifname(ra->ifindex, &ra->ifname);
493 if (r < 0)
494 return r;
495
496 if (ret)
497 *ret = ra->ifname;
498
499 return 0;
61a9fa8f
YW		 500}
501
50ba4e40
YW		 502int sd_radv_set_link_local_address(sd_radv *ra, const struct in6_addr *addr) {
503 assert_return(ra, -EINVAL);
504 assert_return(!addr || in6_addr_is_link_local(addr), -EINVAL);
505
506 if (addr)
507 ra->ipv6ll = *addr;
508 else
509 zero(ra->ipv6ll);
510
511 return 0;
512}
513
17347053 514int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
204f99d2
PF		 515 assert_return(ra, -EINVAL);
516
d6fc0d67 517 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 518 return -EBUSY;
519
520 if (mac_addr)
521 ra->mac_addr = *mac_addr;
522 else
523 zero(ra->mac_addr);
524
525 return 0;
526}
527
17347053 528int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
204f99d2
PF		 529 assert_return(ra, -EINVAL);
530 assert_return(mtu >= 1280, -EINVAL);
531
204f99d2
PF		 532 ra->mtu = mtu;
533
534 return 0;
535}
536
17347053 537int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
204f99d2
PF		 538 assert_return(ra, -EINVAL);
539
d6fc0d67 540 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 541 return -EBUSY;
542
543 ra->hop_limit = hop_limit;
544
545 return 0;
546}
547
eca280c8 548int sd_radv_set_retransmit(sd_radv *ra, uint64_t usec) {
fdc4c67c
SS		 549 assert_return(ra, -EINVAL);
550
551 if (ra->state != RADV_STATE_IDLE)
552 return -EBUSY;
553
eca280c8
YW		 554 if (usec > RADV_MAX_RETRANSMIT_USEC)
555 return -EINVAL;
fdc4c67c 556
eca280c8 557 ra->retransmit_usec = usec;
fdc4c67c
SS		 558 return 0;
559}
560
eca280c8 561int sd_radv_set_router_lifetime(sd_radv *ra, uint64_t usec) {
204f99d2
PF		 562 assert_return(ra, -EINVAL);
563
d6fc0d67 564 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 565 return -EBUSY;
566
eca280c8 567 if (!router_lifetime_is_valid(usec))
09457670
YW		 568 return -EINVAL;
569
ac138551
YW		 570 /* RFC 4191, Section 2.2, "...If the Router Lifetime is zero, the preference value MUST be set
571 * to (00) by the sender..." */
eca280c8 572 if (usec == 0 &&
204f99d2 573 (ra->flags & (0x3 << 3)) != (SD_NDISC_PREFERENCE_MEDIUM << 3))
09457670 574 return -EINVAL;
204f99d2 575
eca280c8 576 ra->lifetime_usec = usec;
204f99d2
PF		 577 return 0;
578}
579
17347053 580int sd_radv_set_managed_information(sd_radv *ra, int managed) {
204f99d2
PF		 581 assert_return(ra, -EINVAL);
582
d6fc0d67 583 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 584 return -EBUSY;
585
586 SET_FLAG(ra->flags, ND_RA_FLAG_MANAGED, managed);
587
588 return 0;
589}
590
17347053 591int sd_radv_set_other_information(sd_radv *ra, int other) {
204f99d2
PF		 592 assert_return(ra, -EINVAL);
593
d6fc0d67 594 if (ra->state != RADV_STATE_IDLE)
204f99d2
PF		 595 return -EBUSY;
596
597 SET_FLAG(ra->flags, ND_RA_FLAG_OTHER, other);
598
599 return 0;
600}
601
17347053 602int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
204f99d2
PF		 603 assert_return(ra, -EINVAL);
604 assert_return(IN_SET(preference,
605 SD_NDISC_PREFERENCE_LOW,
606 SD_NDISC_PREFERENCE_MEDIUM,
607 SD_NDISC_PREFERENCE_HIGH), -EINVAL);
608
dd1b1870
YW		 609 /* RFC 4191, Section 2.2, "...If the Router Lifetime is zero, the preference value MUST be set
610 * to (00) by the sender..." */
7003b114 611 if (ra->lifetime_usec == 0 && preference != SD_NDISC_PREFERENCE_MEDIUM)
dd1b1870
YW		 612 return -EINVAL;
613
204f99d2
PF		 614 ra->flags = (ra->flags & ~(0x3 << 3)) | (preference << 3);
615
dd1b1870 616 return 0;
204f99d2
PF		 617}
618
6a6d27bc
SS		 619int sd_radv_set_home_agent_information(sd_radv *ra, int home_agent) {
620 assert_return(ra, -EINVAL);
621
622 if (ra->state != RADV_STATE_IDLE)
623 return -EBUSY;
624
625 SET_FLAG(ra->flags, ND_RA_FLAG_HOME_AGENT, home_agent);
626
627 return 0;
628}
629
630int sd_radv_set_home_agent_preference(sd_radv *ra, uint16_t preference) {
631 assert_return(ra, -EINVAL);
632
633 if (ra->state != RADV_STATE_IDLE)
634 return -EBUSY;
635
636 ra->home_agent.nd_opt_home_agent_info_preference = htobe16(preference);
637
638 return 0;
639}
640
eca280c8 641int sd_radv_set_home_agent_lifetime(sd_radv *ra, uint64_t lifetime_usec) {
6a6d27bc
SS		 642 assert_return(ra, -EINVAL);
643
644 if (ra->state != RADV_STATE_IDLE)
645 return -EBUSY;
646
eca280c8
YW		 647 if (lifetime_usec > RADV_HOME_AGENT_MAX_LIFETIME_USEC)
648 return -EINVAL;
6a6d27bc 649
eca280c8 650 ra->home_agent.nd_opt_home_agent_info_lifetime = usec_to_be16_sec(lifetime_usec);
6a6d27bc
SS		 651 return 0;
652}
653
17347053 654int sd_radv_add_prefix(sd_radv *ra, sd_radv_prefix *p) {
03677889 655 sd_radv_prefix *found = NULL;
d601b566 656 int r;
204f99d2
PF		 657
658 assert_return(ra, -EINVAL);
acbb5500 659 assert_return(p, -EINVAL);
204f99d2 660
59ea6e57 661 /* Refuse prefixes that don't have a prefix set */
94876904 662 if (in6_addr_is_null(&p->opt.in6_addr))
59ea6e57
LP		 663 return -ENOEXEC;
664
c71384a9 665 const char *addr_p = IN6_ADDR_PREFIX_TO_STRING(&p->opt.in6_addr, p->opt.prefixlen);
5380707a 666
204f99d2 667 LIST_FOREACH(prefix, cur, ra->prefixes) {
204f99d2 668 r = in_addr_prefix_intersect(AF_INET6,
c633628d 669 (const union in_addr_union*) &cur->opt.in6_addr,
204f99d2 670 cur->opt.prefixlen,
c633628d 671 (const union in_addr_union*) &p->opt.in6_addr,
204f99d2 672 p->opt.prefixlen);
5380707a
YW		 673 if (r < 0)
674 return r;
675 if (r == 0)
676 continue;
204f99d2 677
95e104e0 678 if (cur->opt.prefixlen == p->opt.prefixlen) {
56aa5143 679 found = cur;
b9f27a05 680 break;
95e104e0 681 }
d601b566 682
35388783 683 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
95e104e0 684 "IPv6 prefix %s conflicts with %s, ignoring.",
c71384a9
ZJS		 685 addr_p,
686 IN6_ADDR_PREFIX_TO_STRING(&cur->opt.in6_addr, cur->opt.prefixlen));
204f99d2
PF		 687 }
688
56aa5143 689 if (found) {
b9f27a05
YW		 690 /* p and cur may be equivalent. First increment the reference counter. */
691 sd_radv_prefix_ref(p);
692
693 /* Then, remove the old entry. */
56aa5143
YW		 694 LIST_REMOVE(prefix, ra->prefixes, found);
695 sd_radv_prefix_unref(found);
b9f27a05
YW		 696
697 /* Finally, add the new entry. */
698 LIST_APPEND(prefix, ra->prefixes, p);
699
700 log_radv(ra, "Updated/replaced IPv6 prefix %s (preferred: %s, valid: %s)",
c71384a9 701 addr_p,
b9f27a05
YW		 702 FORMAT_TIMESPAN(p->lifetime_preferred_usec, USEC_PER_SEC),
703 FORMAT_TIMESPAN(p->lifetime_valid_usec, USEC_PER_SEC));
704 } else {
705 /* The prefix is new. Let's simply add it. */
706
707 sd_radv_prefix_ref(p);
708 LIST_APPEND(prefix, ra->prefixes, p);
709 ra->n_prefixes++;
204f99d2 710
c71384a9 711 log_radv(ra, "Added prefix %s", addr_p);
b9f27a05 712 }
059d7b6e
YW		 713
714 if (ra->state == RADV_STATE_IDLE)
715 return 0;
716
059d7b6e 717 if (ra->ra_sent == 0)
d601b566 718 return 0;
d601b566 719
97efde65 720 /* If RAs have already been sent, send an RA immediately to announce the newly-added prefix */
69628e3b 721 r = radv_send_router(ra, NULL);
059d7b6e 722 if (r < 0)
abb977a6 723 log_radv_errno(ra, r, "Unable to send Router Advertisement for added prefix %s, ignoring: %m", addr_p);
059d7b6e 724 else
c71384a9 725 log_radv(ra, "Sent Router Advertisement for added/updated prefix %s.", addr_p);
97efde65 726
204f99d2
PF		 727 return 0;
728}
729
95931532
YW		 730void sd_radv_remove_prefix(
731 sd_radv *ra,
732 const struct in6_addr *prefix,
733 unsigned char prefixlen) {
34c169c4 734
95931532
YW		 735 if (!ra)
736 return;
34c169c4 737
95931532
YW		 738 if (!prefix)
739 return;
740
741 LIST_FOREACH(prefix, cur, ra->prefixes) {
34c169c4
PF		 742 if (prefixlen != cur->opt.prefixlen)
743 continue;
744
94876904 745 if (!in6_addr_equal(prefix, &cur->opt.in6_addr))
34c169c4
PF		 746 continue;
747
748 LIST_REMOVE(prefix, ra->prefixes, cur);
749 ra->n_prefixes--;
62bbbedf 750 sd_radv_prefix_unref(cur);
95931532 751 return;
34c169c4 752 }
34c169c4
PF		 753}
754
17347053 755int sd_radv_add_route_prefix(sd_radv *ra, sd_radv_route_prefix *p) {
03677889 756 sd_radv_route_prefix *found = NULL;
203d4df5
SS		 757 int r;
758
759 assert_return(ra, -EINVAL);
acbb5500 760 assert_return(p, -EINVAL);
203d4df5 761
c71384a9 762 const char *addr_p = IN6_ADDR_PREFIX_TO_STRING(&p->opt.in6_addr, p->opt.prefixlen);
203d4df5
SS		 763
764 LIST_FOREACH(prefix, cur, ra->route_prefixes) {
203d4df5 765 r = in_addr_prefix_intersect(AF_INET6,
c633628d 766 (const union in_addr_union*) &cur->opt.in6_addr,
203d4df5 767 cur->opt.prefixlen,
c633628d 768 (const union in_addr_union*) &p->opt.in6_addr,
203d4df5
SS		 769 p->opt.prefixlen);
770 if (r < 0)
771 return r;
772 if (r == 0)
773 continue;
774
95e104e0 775 if (cur->opt.prefixlen == p->opt.prefixlen) {
56aa5143 776 found = cur;
b9f27a05 777 break;
95e104e0 778 }
203d4df5 779
35388783 780 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
95e104e0 781 "IPv6 route prefix %s conflicts with %s, ignoring.",
c71384a9
ZJS		 782 addr_p,
783 IN6_ADDR_PREFIX_TO_STRING(&cur->opt.in6_addr, cur->opt.prefixlen));
203d4df5
SS		 784 }
785
56aa5143 786 if (found) {
b9f27a05
YW		 787 /* p and cur may be equivalent. First increment the reference counter. */
788 sd_radv_route_prefix_ref(p);
789
790 /* Then, remove the old entry. */
56aa5143
YW		 791 LIST_REMOVE(prefix, ra->route_prefixes, found);
792 sd_radv_route_prefix_unref(found);
b9f27a05
YW		 793
794 /* Finally, add the new entry. */
795 LIST_APPEND(prefix, ra->route_prefixes, p);
796
797 log_radv(ra, "Updated/replaced IPv6 route prefix %s (lifetime: %s)",
798 strna(addr_p),
799 FORMAT_TIMESPAN(p->lifetime_usec, USEC_PER_SEC));
800 } else {
801 /* The route prefix is new. Let's simply add it. */
802
803 sd_radv_route_prefix_ref(p);
804 LIST_APPEND(prefix, ra->route_prefixes, p);
805 ra->n_route_prefixes++;
806
807 log_radv(ra, "Added route prefix %s", strna(addr_p));
808 }
059d7b6e
YW		 809
810 if (ra->state == RADV_STATE_IDLE)
811 return 0;
812
059d7b6e 813 if (ra->ra_sent == 0)
203d4df5 814 return 0;
203d4df5 815
97efde65 816 /* If RAs have already been sent, send an RA immediately to announce the newly-added route prefix */
69628e3b 817 r = radv_send_router(ra, NULL);
059d7b6e 818 if (r < 0)
abb977a6 819 log_radv_errno(ra, r, "Unable to send Router Advertisement for added route prefix %s, ignoring: %m",
b9f27a05 820 strna(addr_p));
059d7b6e 821 else
b9f27a05 822 log_radv(ra, "Sent Router Advertisement for added route prefix %s.", strna(addr_p));
97efde65 823
203d4df5
SS		 824 return 0;
825}
826
1925f829
SS		 827int sd_radv_add_pref64_prefix(sd_radv *ra, sd_radv_pref64_prefix *p) {
828 sd_radv_pref64_prefix *found = NULL;
829 int r;
830
831 assert_return(ra, -EINVAL);
832 assert_return(p, -EINVAL);
833
834 const char *addr_p = IN6_ADDR_PREFIX_TO_STRING(&p->in6_addr, p->prefixlen);
835
836 LIST_FOREACH(prefix, cur, ra->pref64_prefixes) {
837 r = in_addr_prefix_intersect(AF_INET6,
838 (const union in_addr_union*) &cur->in6_addr,
839 cur->prefixlen,
840 (const union in_addr_union*) &p->in6_addr,
841 p->prefixlen);
842 if (r < 0)
843 return r;
844 if (r == 0)
845 continue;
846
847 if (cur->prefixlen == p->prefixlen) {
848 found = cur;
849 break;
850 }
851
852 return log_radv_errno(ra, SYNTHETIC_ERRNO(EEXIST),
853 "IPv6 PREF64 prefix %s conflicts with %s, ignoring.",
854 addr_p,
855 IN6_ADDR_PREFIX_TO_STRING(&cur->in6_addr, cur->prefixlen));
856 }
857
858 if (found) {
859 /* p and cur may be equivalent. First increment the reference counter. */
860 sd_radv_pref64_prefix_ref(p);
861
862 /* Then, remove the old entry. */
863 LIST_REMOVE(prefix, ra->pref64_prefixes, found);
864 sd_radv_pref64_prefix_unref(found);
865
866 /* Finally, add the new entry. */
867 LIST_APPEND(prefix, ra->pref64_prefixes, p);
868
869 log_radv(ra, "Updated/replaced IPv6 PREF64 prefix %s (lifetime: %s)",
870 strna(addr_p),
871 FORMAT_TIMESPAN(p->lifetime_usec, USEC_PER_SEC));
872 } else {
873 /* The route prefix is new. Let's simply add it. */
874
875 sd_radv_pref64_prefix_ref(p);
876 LIST_APPEND(prefix, ra->pref64_prefixes, p);
877 ra->n_pref64_prefixes++;
878
879 log_radv(ra, "Added PREF64 prefix %s", strna(addr_p));
880 }
881
882 if (ra->state == RADV_STATE_IDLE)
883 return 0;
884
885 if (ra->ra_sent == 0)
886 return 0;
887
888 /* If RAs have already been sent, send an RA immediately to announce the newly-added route prefix */
69628e3b 889 r = radv_send_router(ra, NULL);
1925f829
SS		 890 if (r < 0)
891 log_radv_errno(ra, r, "Unable to send Router Advertisement for added PREF64 prefix %s, ignoring: %m",
892 strna(addr_p));
893 else
894 log_radv(ra, "Sent Router Advertisement for added PREF64 prefix %s.", strna(addr_p));
895
896 return 0;
897}
898
faaf3d66
YW		 899int sd_radv_set_rdnss(
900 sd_radv *ra,
eca280c8 901 uint64_t lifetime_usec,
faaf3d66
YW		 902 const struct in6_addr *dns,
903 size_t n_dns) {
904
e9c6da38
PF		 905 _cleanup_free_ struct sd_radv_opt_dns *opt_rdnss = NULL;
906 size_t len;
907
908 assert_return(ra, -EINVAL);
909 assert_return(n_dns < 128, -EINVAL);
910
eca280c8
YW		 911 if (lifetime_usec > RADV_RDNSS_MAX_LIFETIME_USEC)
912 return -EINVAL;
913
e9c6da38
PF		 914 if (!dns || n_dns == 0) {
915 ra->rdnss = mfree(ra->rdnss);
916 ra->n_rdnss = 0;
917
918 return 0;
919 }
920
921 len = sizeof(struct sd_radv_opt_dns) + sizeof(struct in6_addr) * n_dns;
922
923 opt_rdnss = malloc0(len);
924 if (!opt_rdnss)
925 return -ENOMEM;
926
d6fc0d67 927 opt_rdnss->type = RADV_OPT_RDNSS;
e9c6da38 928 opt_rdnss->length = len / 8;
eca280c8 929 opt_rdnss->lifetime = usec_to_be32_sec(lifetime_usec);
e9c6da38
PF		 930
931 memcpy(opt_rdnss + 1, dns, n_dns * sizeof(struct in6_addr));
932
1cc6c93a 933 free_and_replace(ra->rdnss, opt_rdnss);
e9c6da38
PF		 934
935 ra->n_rdnss = n_dns;
936
937 return 0;
938}
939
faaf3d66
YW		 940int sd_radv_set_dnssl(
941 sd_radv *ra,
eca280c8 942 uint64_t lifetime_usec,
faaf3d66
YW		 943 char **search_list) {
944
e965d6ab
PF		 945 _cleanup_free_ struct sd_radv_opt_dns *opt_dnssl = NULL;
946 size_t len = 0;
e965d6ab
PF		 947 uint8_t *p;
948
949 assert_return(ra, -EINVAL);
950
eca280c8
YW		 951 if (lifetime_usec > RADV_DNSSL_MAX_LIFETIME_USEC)
952 return -EINVAL;
953
97d7974b 954 if (strv_isempty(search_list)) {
e965d6ab 955 ra->dnssl = mfree(ra->dnssl);
e965d6ab
PF		 956 return 0;
957 }
958
959 STRV_FOREACH(s, search_list)
960 len += strlen(*s) + 2;
961
962 len = (sizeof(struct sd_radv_opt_dns) + len + 7) & ~0x7;
963
964 opt_dnssl = malloc0(len);
965 if (!opt_dnssl)
966 return -ENOMEM;
967
d6fc0d67 968 opt_dnssl->type = RADV_OPT_DNSSL;
e965d6ab 969 opt_dnssl->length = len / 8;
eca280c8 970 opt_dnssl->lifetime = usec_to_be32_sec(lifetime_usec);
e965d6ab
PF		 971
972 p = (uint8_t *)(opt_dnssl + 1);
973 len -= sizeof(struct sd_radv_opt_dns);
974
975 STRV_FOREACH(s, search_list) {
976 int r;
977
978 r = dns_name_to_wire_format(*s, p, len, false);
979 if (r < 0)
980 return r;
981
982 if (len < (size_t)r)
983 return -ENOBUFS;
984
985 p += r;
986 len -= r;
987 }
988
1cc6c93a 989 free_and_replace(ra->dnssl, opt_dnssl);
e965d6ab
PF		 990
991 return 0;
992}
993
17347053 994int sd_radv_prefix_new(sd_radv_prefix **ret) {
d2c8eed2 995 sd_radv_prefix *p;
04473969
PF		 996
997 assert_return(ret, -EINVAL);
998
d2c8eed2 999 p = new(sd_radv_prefix, 1);
04473969
PF		 1000 if (!p)
1001 return -ENOMEM;
1002
d2c8eed2
LP		 1003 *p = (sd_radv_prefix) {
1004 .n_ref = 1,
04473969 1005
d2c8eed2
LP		 1006 .opt.type = ND_OPT_PREFIX_INFORMATION,
1007 .opt.length = (sizeof(p->opt) - 1)/8 + 1,
1008 .opt.prefixlen = 64,
04473969 1009
d2c8eed2
LP		 1010 /* RFC 4861, Section 6.2.1 */
1011 .opt.flags = ND_OPT_PI_FLAG_ONLINK|ND_OPT_PI_FLAG_AUTO,
204f99d2 1012
d951507d
YW		 1013 .lifetime_valid_usec = RADV_DEFAULT_VALID_LIFETIME_USEC,
1014 .lifetime_preferred_usec = RADV_DEFAULT_PREFERRED_LIFETIME_USEC,
95e104e0
YW		 1015 .valid_until = USEC_INFINITY,
1016 .preferred_until = USEC_INFINITY,
d2c8eed2 1017 };
04473969 1018
d2c8eed2 1019 *ret = p;
04473969
PF		 1020 return 0;
1021}
1022
8301aa0b 1023DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_prefix, sd_radv_prefix, mfree);
04473969 1024
faaf3d66
YW		 1025int sd_radv_prefix_set_prefix(
1026 sd_radv_prefix *p,
1027 const struct in6_addr *in6_addr,
1028 unsigned char prefixlen) {
1029
04473969
PF		 1030 assert_return(p, -EINVAL);
1031 assert_return(in6_addr, -EINVAL);
1032
1033 if (prefixlen < 3 || prefixlen > 128)
1034 return -EINVAL;
1035
1036 if (prefixlen > 64)
1037 /* unusual but allowed, log it */
35388783 1038 log_radv(NULL, "Unusual prefix length %d greater than 64", prefixlen);
04473969
PF		 1039
1040 p->opt.in6_addr = *in6_addr;
1041 p->opt.prefixlen = prefixlen;
1042
1043 return 0;
1044}
1045
faaf3d66
YW		 1046int sd_radv_prefix_get_prefix(
1047 sd_radv_prefix *p,
1048 struct in6_addr *ret_in6_addr,
1049 unsigned char *ret_prefixlen) {
1050
34332af2
SS		 1051 assert_return(p, -EINVAL);
1052 assert_return(ret_in6_addr, -EINVAL);
1053 assert_return(ret_prefixlen, -EINVAL);
1054
1055 *ret_in6_addr = p->opt.in6_addr;
1056 *ret_prefixlen = p->opt.prefixlen;
1057
1058 return 0;
1059}
1060
17347053 1061int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
04473969
PF		 1062 assert_return(p, -EINVAL);
1063
1064 SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_ONLINK, onlink);
1065
1066 return 0;
1067}
1068
faaf3d66 1069int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p, int address_autoconfiguration) {
04473969
PF		 1070 assert_return(p, -EINVAL);
1071
1072 SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_AUTO, address_autoconfiguration);
1073
1074 return 0;
1075}
1076
17347053 1077int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
04473969
PF		 1078 assert_return(p, -EINVAL);
1079
95e104e0
YW		 1080 p->lifetime_valid_usec = lifetime_usec;
1081 p->valid_until = valid_until;
04473969
PF		 1082
1083 return 0;
1084}
1085
17347053 1086int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
04473969
PF		 1087 assert_return(p, -EINVAL);
1088
95e104e0
YW		 1089 p->lifetime_preferred_usec = lifetime_usec;
1090 p->preferred_until = valid_until;
04473969
PF		 1091
1092 return 0;
1093}
203d4df5 1094
17347053 1095int sd_radv_route_prefix_new(sd_radv_route_prefix **ret) {
203d4df5
SS		 1096 sd_radv_route_prefix *p;
1097
1098 assert_return(ret, -EINVAL);
1099
1100 p = new(sd_radv_route_prefix, 1);
1101 if (!p)
1102 return -ENOMEM;
1103
1104 *p = (sd_radv_route_prefix) {
1105 .n_ref = 1,
1106
d6fc0d67 1107 .opt.type = RADV_OPT_ROUTE_INFORMATION,
203d4df5
SS		 1108 .opt.length = DIV_ROUND_UP(sizeof(p->opt), 8),
1109 .opt.prefixlen = 64,
1110
d951507d 1111 .lifetime_usec = RADV_DEFAULT_VALID_LIFETIME_USEC,
95e104e0 1112 .valid_until = USEC_INFINITY,
203d4df5
SS		 1113 };
1114
1115 *ret = p;
1116 return 0;
1117}
1118
1119DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_route_prefix, sd_radv_route_prefix, mfree);
1120
faaf3d66
YW		 1121int sd_radv_route_prefix_set_prefix(
1122 sd_radv_route_prefix *p,
1123 const struct in6_addr *in6_addr,
1124 unsigned char prefixlen) {
1125
203d4df5
SS		 1126 assert_return(p, -EINVAL);
1127 assert_return(in6_addr, -EINVAL);
1128
1129 if (prefixlen > 128)
1130 return -EINVAL;
1131
1132 if (prefixlen > 64)
1133 /* unusual but allowed, log it */
35388783 1134 log_radv(NULL, "Unusual prefix length %u greater than 64", prefixlen);
203d4df5
SS		 1135
1136 p->opt.in6_addr = *in6_addr;
1137 p->opt.prefixlen = prefixlen;
1138
1139 return 0;
1140}
1141
17347053 1142int sd_radv_route_prefix_set_lifetime(sd_radv_route_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
203d4df5
SS		 1143 assert_return(p, -EINVAL);
1144
95e104e0
YW		 1145 p->lifetime_usec = lifetime_usec;
1146 p->valid_until = valid_until;
203d4df5
SS		 1147
1148 return 0;
1149}
1925f829
SS		 1150
1151int sd_radv_pref64_prefix_new(sd_radv_pref64_prefix **ret) {
1152 sd_radv_pref64_prefix *p;
1153
1154 assert_return(ret, -EINVAL);
1155
1156 p = new(sd_radv_pref64_prefix, 1);
1157 if (!p)
1158 return -ENOMEM;
1159
1160 *p = (sd_radv_pref64_prefix) {
1161 .n_ref = 1,
1162
1163 .opt.type = RADV_OPT_PREF64,
1164 .opt.length = 2,
1165 };
1166
1167 *ret = p;
1168 return 0;
1169}
1170
1171DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_pref64_prefix, sd_radv_pref64_prefix, mfree);
1172
1173int sd_radv_pref64_prefix_set_prefix(
1174 sd_radv_pref64_prefix *p,
1175 const struct in6_addr *prefix,
1176 uint8_t prefixlen,
1177 uint64_t lifetime_usec) {
1178
1179 uint16_t pref64_lifetime;
1180 uint8_t prefixlen_code;
6e8f5e4c 1181 int r;
1925f829
SS		 1182
1183 assert_return(p, -EINVAL);
1184 assert_return(prefix, -EINVAL);
1185
6e8f5e4c
SS		 1186 r = pref64_prefix_length_to_plc(prefixlen, &prefixlen_code);
1187 if (r < 0)
f31fa080
ZJS		 1188 return log_radv_errno(NULL, r,
1189 "Unsupported PREF64 prefix length %u. Valid lengths are 32, 40, 48, 56, 64 and 96", prefixlen);
1925f829 1190
eca280c8 1191 if (lifetime_usec > PREF64_MAX_LIFETIME_USEC)
1925f829
SS		 1192 return -EINVAL;
1193
1194 /* RFC 8781 - 4.1 rounding up lifetime to multiply of 8 */
1195 pref64_lifetime = DIV_ROUND_UP(lifetime_usec, 8 * USEC_PER_SEC) << 3;
1196 pref64_lifetime |= prefixlen_code;
1197
1198 unaligned_write_be16(&p->opt.lifetime_and_plc, pref64_lifetime);
1199 memcpy(&p->opt.prefix, prefix, sizeof(p->opt.prefix));
1200
1201 p->in6_addr = *prefix;
1202 p->prefixlen = prefixlen;
1203
1204 return 0;
1205}
Unnamed repository; edit this file 'description' to name the repository.