Debian Codegraph @

src/libsystemd-network/sd-ndisc.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2 /***
3 Copyright © 2014 Intel Corporation. All rights reserved.
4 ***/
5
6 #include <netinet/icmp6.h>
7 #include <netinet/in.h>
8
9 #include "sd-ndisc.h"
10
11 #include "alloc-util.h"
12 #include "ether-addr-util.h"
13 #include "event-util.h"
14 #include "fd-util.h"
15 #include "icmp6-util.h"
16 #include "in-addr-util.h"
17 #include "memory-util.h"
18 #include "ndisc-internal.h"
19 #include "ndisc-neighbor-internal.h"
20 #include "ndisc-redirect-internal.h"
21 #include "ndisc-router-internal.h"
22 #include "network-common.h"
23 #include "random-util.h"
24 #include "set.h"
25 #include "socket-util.h"
26 #include "string-table.h"
27 #include "string-util.h"
28
29 #define NDISC_TIMEOUT_NO_RA_USEC (NDISC_ROUTER_SOLICITATION_INTERVAL * NDISC_MAX_ROUTER_SOLICITATIONS)
30
31 static const char * const ndisc_event_table[_SD_NDISC_EVENT_MAX] = {
32 [SD_NDISC_EVENT_TIMEOUT] = "timeout",
33 [SD_NDISC_EVENT_ROUTER] = "router",
34 [SD_NDISC_EVENT_NEIGHBOR] = "neighbor",
35 [SD_NDISC_EVENT_REDIRECT] = "redirect",
36 };
37
38 DEFINE_STRING_TABLE_LOOKUP(ndisc_event, sd_ndisc_event_t);
39
40 static void ndisc_callback(sd_ndisc *ndisc, sd_ndisc_event_t event, void *message) {
41 assert(ndisc);
42 assert(event >= 0 && event < _SD_NDISC_EVENT_MAX);
43
44 if (!ndisc->callback)
45 return (void) log_ndisc(ndisc, "Received '%s' event.", ndisc_event_to_string(event));
46
47 log_ndisc(ndisc, "Invoking callback for '%s' event.", ndisc_event_to_string(event));
48 ndisc->callback(ndisc, event, message, ndisc->userdata);
49 }
50
51 int sd_ndisc_is_running(sd_ndisc *nd) {
52 if (!nd)
53 return false;
54
55 return sd_event_source_get_enabled(nd->recv_event_source, NULL) > 0;
56 }
57
58 int sd_ndisc_set_callback(
59 sd_ndisc *nd,
60 sd_ndisc_callback_t callback,
61 void *userdata) {
62
63 assert_return(nd, -EINVAL);
64
65 nd->callback = callback;
66 nd->userdata = userdata;
67
68 return 0;
69 }
70
71 int sd_ndisc_set_ifindex(sd_ndisc *nd, int ifindex) {
72 assert_return(nd, -EINVAL);
73 assert_return(ifindex > 0, -EINVAL);
74 assert_return(!sd_ndisc_is_running(nd), -EBUSY);
75
76 nd->ifindex = ifindex;
77 return 0;
78 }
79
80 int sd_ndisc_set_ifname(sd_ndisc *nd, const char *ifname) {
81 assert_return(nd, -EINVAL);
82 assert_return(ifname, -EINVAL);
83
84 if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
85 return -EINVAL;
86
87 return free_and_strdup(&nd->ifname, ifname);
88 }
89
90 int sd_ndisc_get_ifname(sd_ndisc *nd, const char **ret) {
91 int r;
92
93 assert_return(nd, -EINVAL);
94
95 r = get_ifname(nd->ifindex, &nd->ifname);
96 if (r < 0)
97 return r;
98
99 if (ret)
100 *ret = nd->ifname;
101
102 return 0;
103 }
104
105 int sd_ndisc_set_link_local_address(sd_ndisc *nd, const struct in6_addr *addr) {
106 assert_return(nd, -EINVAL);
107 assert_return(!addr || in6_addr_is_link_local(addr), -EINVAL);
108
109 if (addr)
110 nd->link_local_addr = *addr;
111 else
112 zero(nd->link_local_addr);
113
114 return 0;
115 }
116
117 int sd_ndisc_set_mac(sd_ndisc *nd, const struct ether_addr *mac_addr) {
118 assert_return(nd, -EINVAL);
119
120 if (mac_addr)
121 nd->mac_addr = *mac_addr;
122 else
123 zero(nd->mac_addr);
124
125 return 0;
126 }
127
128 int sd_ndisc_attach_event(sd_ndisc *nd, sd_event *event, int64_t priority) {
129 int r;
130
131 assert_return(nd, -EINVAL);
132 assert_return(!sd_ndisc_is_running(nd), -EBUSY);
133 assert_return(!nd->event, -EBUSY);
134
135 if (event)
136 nd->event = sd_event_ref(event);
137 else {
138 r = sd_event_default(&nd->event);
139 if (r < 0)
140 return r;
141 }
142
143 nd->event_priority = priority;
144
145 return 0;
146 }
147
148 int sd_ndisc_detach_event(sd_ndisc *nd) {
149
150 assert_return(nd, -EINVAL);
151 assert_return(!sd_ndisc_is_running(nd), -EBUSY);
152
153 nd->event = sd_event_unref(nd->event);
154 return 0;
155 }
156
157 sd_event *sd_ndisc_get_event(sd_ndisc *nd) {
158 assert_return(nd, NULL);
159
160 return nd->event;
161 }
162
163 static void ndisc_reset(sd_ndisc *nd) {
164 assert(nd);
165
166 (void) event_source_disable(nd->timeout_event_source);
167 (void) event_source_disable(nd->timeout_no_ra);
168 nd->retransmit_time = 0;
169 nd->recv_event_source = sd_event_source_disable_unref(nd->recv_event_source);
170 nd->fd = safe_close(nd->fd);
171 }
172
173 static sd_ndisc *ndisc_free(sd_ndisc *nd) {
174 assert(nd);
175
176 ndisc_reset(nd);
177
178 sd_event_source_unref(nd->timeout_event_source);
179 sd_event_source_unref(nd->timeout_no_ra);
180 sd_ndisc_detach_event(nd);
181
182 free(nd->ifname);
183 return mfree(nd);
184 }
185
186 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_ndisc, sd_ndisc, ndisc_free);
187
188 int sd_ndisc_new(sd_ndisc **ret) {
189 _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
190
191 assert_return(ret, -EINVAL);
192
193 nd = new(sd_ndisc, 1);
194 if (!nd)
195 return -ENOMEM;
196
197 *nd = (sd_ndisc) {
198 .n_ref = 1,
199 .fd = -EBADF,
200 };
201
202 *ret = TAKE_PTR(nd);
203
204 return 0;
205 }
206
207 static int ndisc_handle_router(sd_ndisc *nd, ICMP6Packet *packet) {
208 _cleanup_(sd_ndisc_router_unrefp) sd_ndisc_router *rt = NULL;
209 int r;
210
211 assert(nd);
212 assert(packet);
213
214 rt = ndisc_router_new(packet);
215 if (!rt)
216 return -ENOMEM;
217
218 r = ndisc_router_parse(nd, rt);
219 if (r < 0)
220 return r;
221
222 (void) event_source_disable(nd->timeout_event_source);
223 (void) event_source_disable(nd->timeout_no_ra);
224
225 if (DEBUG_LOGGING) {
226 _cleanup_free_ char *s = NULL;
227 struct in6_addr a;
228 uint64_t flags;
229 uint8_t pref;
230 usec_t lifetime;
231
232 r = sd_ndisc_router_get_sender_address(rt, &a);
233 if (r < 0)
234 return r;
235
236 r = sd_ndisc_router_get_flags(rt, &flags);
237 if (r < 0)
238 return r;
239
240 r = ndisc_router_flags_to_string(flags, &s);
241 if (r < 0)
242 return r;
243
244 r = sd_ndisc_router_get_preference(rt, &pref);
245 if (r < 0)
246 return r;
247
248 r = sd_ndisc_router_get_lifetime(rt, &lifetime);
249 if (r < 0)
250 return r;
251
252 log_ndisc(nd, "Received Router Advertisement from %s: flags=0x%0*"PRIx64"(%s), preference=%s, lifetime=%s",
253 IN6_ADDR_TO_STRING(&a),
254 flags & UINT64_C(0x00ffffffffffff00) ? 14 : 2, flags, /* suppress too many zeros if no extension */
255 s ?: "none",
256 ndisc_router_preference_to_string(pref),
257 FORMAT_TIMESPAN(lifetime, USEC_PER_SEC));
258 }
259
260 ndisc_callback(nd, SD_NDISC_EVENT_ROUTER, rt);
261 return 0;
262 }
263
264 static int ndisc_handle_neighbor(sd_ndisc *nd, ICMP6Packet *packet) {
265 _cleanup_(sd_ndisc_neighbor_unrefp) sd_ndisc_neighbor *na = NULL;
266 int r;
267
268 assert(nd);
269 assert(packet);
270
271 na = ndisc_neighbor_new(packet);
272 if (!na)
273 return -ENOMEM;
274
275 r = ndisc_neighbor_parse(nd, na);
276 if (r < 0)
277 return r;
278
279 if (DEBUG_LOGGING) {
280 struct in6_addr a;
281
282 r = sd_ndisc_neighbor_get_sender_address(na, &a);
283 if (r < 0)
284 return r;
285
286 log_ndisc(nd, "Received Neighbor Advertisement from %s: Router=%s, Solicited=%s, Override=%s",
287 IN6_ADDR_TO_STRING(&a),
288 yes_no(sd_ndisc_neighbor_is_router(na) > 0),
289 yes_no(sd_ndisc_neighbor_is_solicited(na) > 0),
290 yes_no(sd_ndisc_neighbor_is_override(na) > 0));
291 }
292
293 ndisc_callback(nd, SD_NDISC_EVENT_NEIGHBOR, na);
294 return 0;
295 }
296
297 static int ndisc_handle_redirect(sd_ndisc *nd, ICMP6Packet *packet) {
298 _cleanup_(sd_ndisc_redirect_unrefp) sd_ndisc_redirect *rd = NULL;
299 int r;
300
301 assert(nd);
302 assert(packet);
303
304 rd = ndisc_redirect_new(packet);
305 if (!rd)
306 return -ENOMEM;
307
308 r = ndisc_redirect_parse(nd, rd);
309 if (r < 0)
310 return r;
311
312 if (DEBUG_LOGGING) {
313 struct in6_addr sender, target, dest;
314
315 r = sd_ndisc_redirect_get_sender_address(rd, &sender);
316 if (r < 0)
317 return r;
318
319 r = sd_ndisc_redirect_get_target_address(rd, &target);
320 if (r < 0)
321 return r;
322
323 r = sd_ndisc_redirect_get_destination_address(rd, &dest);
324 if (r < 0)
325 return r;
326
327 log_ndisc(nd, "Received Redirect message from %s: Target=%s, Destination=%s",
328 IN6_ADDR_TO_STRING(&sender),
329 IN6_ADDR_TO_STRING(&target),
330 IN6_ADDR_TO_STRING(&dest));
331 }
332
333 ndisc_callback(nd, SD_NDISC_EVENT_REDIRECT, rd);
334 return 0;
335 }
336
337 static int ndisc_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
338 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
339 sd_ndisc *nd = ASSERT_PTR(userdata);
340 int r;
341
342 assert(s);
343 assert(nd->event);
344
345 r = icmp6_packet_receive(fd, &packet);
346 if (r < 0) {
347 log_ndisc_errno(nd, r, "Failed to receive ICMPv6 packet, ignoring: %m");
348 return 0;
349 }
350
351 if (packet->ifindex != nd->ifindex) {
352 log_ndisc(nd, "Received an ICMPv6 packet on interface %i, expected %i, ignoring.",
353 packet->ifindex, nd->ifindex);
354 return 0;
355 }
356
357 /* The function icmp6_receive() accepts the null source address, but RFC 4861 Section 6.1.2 states
358 * that hosts MUST discard messages with the null source address. */
359 if (in6_addr_is_null(&packet->sender_address)) {
360 log_ndisc(nd, "Received an ICMPv6 packet from null address, ignoring.");
361 return 0;
362 }
363
364 if (in6_addr_equal(&packet->sender_address, &nd->link_local_addr)) {
365 log_ndisc(nd, "Received an ICMPv6 packet sent by the same interface, ignoring.");
366 return 0;
367 }
368
369 r = icmp6_packet_get_type(packet);
370 if (r < 0) {
371 log_ndisc_errno(nd, r, "Received an invalid ICMPv6 packet, ignoring: %m");
372 return 0;
373 }
374
375 switch (r) {
376 case ND_ROUTER_ADVERT:
377 (void) ndisc_handle_router(nd, packet);
378 break;
379
380 case ND_NEIGHBOR_ADVERT:
381 (void) ndisc_handle_neighbor(nd, packet);
382 break;
383
384 case ND_REDIRECT:
385 (void) ndisc_handle_redirect(nd, packet);
386 break;
387
388 default:
389 log_ndisc(nd, "Received an ICMPv6 packet with unexpected type %i, ignoring.", r);
390 }
391
392 return 0;
393 }
394
395 static int ndisc_send_router_solicitation(sd_ndisc *nd) {
396 static const struct nd_router_solicit header = {
397 .nd_rs_type = ND_ROUTER_SOLICIT,
398 };
399
400 _cleanup_set_free_ Set *options = NULL;
401 int r;
402
403 assert(nd);
404
405 if (!ether_addr_is_null(&nd->mac_addr)) {
406 r = ndisc_option_set_link_layer_address(&options, SD_NDISC_OPTION_SOURCE_LL_ADDRESS, &nd->mac_addr);
407 if (r < 0)
408 return r;
409 }
410
411 return ndisc_send(nd->fd, &IN6_ADDR_ALL_ROUTERS_MULTICAST, &header.nd_rs_hdr, options, USEC_INFINITY);
412 }
413
414 static usec_t ndisc_timeout_compute_random(usec_t val) {
415 /* compute a time that is random within ±10% of the given value */
416 return val - val / 10 +
417 (random_u64() % (2 * USEC_PER_SEC)) * val / 10 / USEC_PER_SEC;
418 }
419
420 static int ndisc_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
421 sd_ndisc *nd = ASSERT_PTR(userdata);
422 usec_t time_now;
423 int r;
424
425 assert(s);
426 assert(nd->event);
427
428 assert_se(sd_event_now(nd->event, CLOCK_BOOTTIME, &time_now) >= 0);
429
430 if (!nd->retransmit_time)
431 nd->retransmit_time = ndisc_timeout_compute_random(NDISC_ROUTER_SOLICITATION_INTERVAL);
432 else {
433 if (nd->retransmit_time > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 2)
434 nd->retransmit_time = ndisc_timeout_compute_random(NDISC_MAX_ROUTER_SOLICITATION_INTERVAL);
435 else
436 nd->retransmit_time += ndisc_timeout_compute_random(nd->retransmit_time);
437 }
438
439 r = event_reset_time(nd->event, &nd->timeout_event_source,
440 CLOCK_BOOTTIME,
441 time_now + nd->retransmit_time, 10 * USEC_PER_MSEC,
442 ndisc_timeout, nd,
443 nd->event_priority, "ndisc-timeout-no-ra", true);
444 if (r < 0)
445 goto fail;
446
447 r = ndisc_send_router_solicitation(nd);
448 if (r < 0)
449 log_ndisc_errno(nd, r, "Failed to send Router Solicitation, next solicitation in %s, ignoring: %m",
450 FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_SEC));
451 else
452 log_ndisc(nd, "Sent Router Solicitation, next solicitation in %s",
453 FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_SEC));
454
455 return 0;
456
457 fail:
458 (void) sd_ndisc_stop(nd);
459 return 0;
460 }
461
462 static int ndisc_timeout_no_ra(sd_event_source *s, uint64_t usec, void *userdata) {
463 sd_ndisc *nd = ASSERT_PTR(userdata);
464
465 assert(s);
466
467 log_ndisc(nd, "No RA received before link confirmation timeout");
468
469 (void) event_source_disable(nd->timeout_no_ra);
470 ndisc_callback(nd, SD_NDISC_EVENT_TIMEOUT, NULL);
471
472 return 0;
473 }
474
475 int sd_ndisc_stop(sd_ndisc *nd) {
476 if (!nd)
477 return 0;
478
479 if (!sd_ndisc_is_running(nd))
480 return 0;
481
482 log_ndisc(nd, "Stopping IPv6 Router Solicitation client");
483
484 ndisc_reset(nd);
485 return 1;
486 }
487
488 static int ndisc_setup_recv_event(sd_ndisc *nd) {
489 int r;
490
491 assert(nd);
492 assert(nd->event);
493 assert(nd->ifindex > 0);
494
495 _cleanup_close_ int fd = -EBADF;
496 fd = icmp6_bind(nd->ifindex, /* is_router= */ false);
497 if (fd < 0)
498 return fd;
499
500 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
501 r = sd_event_add_io(nd->event, &s, fd, EPOLLIN, ndisc_recv, nd);
502 if (r < 0)
503 return r;
504
505 r = sd_event_source_set_priority(s, nd->event_priority);
506 if (r < 0)
507 return r;
508
509 (void) sd_event_source_set_description(s, "ndisc-receive-router-message");
510
511 nd->fd = TAKE_FD(fd);
512 nd->recv_event_source = TAKE_PTR(s);
513 return 1;
514 }
515
516 static int ndisc_setup_timer(sd_ndisc *nd) {
517 int r;
518
519 assert(nd);
520 assert(nd->event);
521
522 r = event_reset_time_relative(nd->event, &nd->timeout_event_source,
523 CLOCK_BOOTTIME,
524 USEC_PER_SEC / 2, 1 * USEC_PER_SEC, /* See RFC 8415 sec. 18.2.1 */
525 ndisc_timeout, nd,
526 nd->event_priority, "ndisc-timeout", true);
527 if (r < 0)
528 return r;
529
530 r = event_reset_time_relative(nd->event, &nd->timeout_no_ra,
531 CLOCK_BOOTTIME,
532 NDISC_TIMEOUT_NO_RA_USEC, 10 * USEC_PER_MSEC,
533 ndisc_timeout_no_ra, nd,
534 nd->event_priority, "ndisc-timeout-no-ra", true);
535 if (r < 0)
536 return r;
537
538 return 0;
539 }
540
541 int sd_ndisc_start(sd_ndisc *nd) {
542 int r;
543
544 assert_return(nd, -EINVAL);
545 assert_return(nd->event, -EINVAL);
546 assert_return(nd->ifindex > 0, -EINVAL);
547
548 if (sd_ndisc_is_running(nd))
549 return 0;
550
551 r = ndisc_setup_recv_event(nd);
552 if (r < 0)
553 goto fail;
554
555 r = ndisc_setup_timer(nd);
556 if (r < 0)
557 goto fail;
558
559 log_ndisc(nd, "Started IPv6 Router Solicitation client");
560 return 1;
561
562 fail:
563 ndisc_reset(nd);
564 return r;
565 }