]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/libsystemd-network/test-ndisc-rs.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
man/systemd-sysext: list ephemeral/ephemeral-import in the list of options
[thirdparty/systemd.git] / src / libsystemd-network / test-ndisc-rs.c
... / ...
CommitLineData
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 <unistd.h>
8
9#include "sd-ndisc.h"
10
11#include "alloc-util.h"
12#include "fd-util.h"
13#include "hexdecoct.h"
14#include "icmp6-packet.h"
15#include "icmp6-test-util.h"
16#include "in-addr-util.h"
17#include "ndisc-internal.h"
18#include "strv.h"
19#include "tests.h"
20
21static struct ether_addr mac_addr = {
22 .ether_addr_octet = {'A', 'B', 'C', '1', '2', '3'}
23};
24
25static bool verbose = false;
26
27static void router_dump(sd_ndisc_router *rt) {
28 struct in6_addr addr;
29 uint8_t hop_limit;
30 usec_t t, lifetime, retrans_time;
31 uint64_t flags;
32 uint32_t mtu;
33 uint8_t preference;
34 int r;
35
36 assert_se(rt);
37
38 log_info("--");
39 assert_se(sd_ndisc_router_get_sender_address(rt, &addr) >= 0);
40 log_info("Sender: %s", IN6_ADDR_TO_STRING(&addr));
41
42 assert_se(sd_ndisc_router_get_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
43 log_info("Timestamp: %s", FORMAT_TIMESTAMP(t));
44
45 assert_se(sd_ndisc_router_get_timestamp(rt, CLOCK_MONOTONIC, &t) >= 0);
46 log_info("Monotonic: %" PRIu64, t);
47
48 if (sd_ndisc_router_get_hop_limit(rt, &hop_limit) < 0)
49 log_info("No hop limit set");
50 else
51 log_info("Hop limit: %u", hop_limit);
52
53 assert_se(sd_ndisc_router_get_flags(rt, &flags) >= 0);
54 log_info("Flags: <%s|%s>",
55 flags & ND_RA_FLAG_OTHER ? "OTHER" : "",
56 flags & ND_RA_FLAG_MANAGED ? "MANAGED" : "");
57
58 assert_se(sd_ndisc_router_get_preference(rt, &preference) >= 0);
59 log_info("Preference: %s",
60 preference == SD_NDISC_PREFERENCE_LOW ? "low" :
61 preference == SD_NDISC_PREFERENCE_HIGH ? "high" : "medium");
62
63 assert_se(sd_ndisc_router_get_lifetime(rt, &lifetime) >= 0);
64 assert_se(sd_ndisc_router_get_lifetime_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
65 log_info("Lifetime: %s (%s)", FORMAT_TIMESPAN(lifetime, USEC_PER_SEC), FORMAT_TIMESTAMP(t));
66
67 assert_se(sd_ndisc_router_get_retransmission_time(rt, &retrans_time) >= 0);
68 log_info("Retransmission Time: %s", FORMAT_TIMESPAN(retrans_time, USEC_PER_SEC));
69
70 if (sd_ndisc_router_get_mtu(rt, &mtu) < 0)
71 log_info("No MTU set");
72 else
73 log_info("MTU: %" PRIu32, mtu);
74
75 r = sd_ndisc_router_option_rewind(rt);
76 for (;;) {
77 uint8_t type;
78
79 assert_se(r >= 0);
80
81 if (r == 0)
82 break;
83
84 assert_se(sd_ndisc_router_option_get_type(rt, &type) >= 0);
85
86 log_info(">> Option %u", type);
87
88 switch (type) {
89
90 case SD_NDISC_OPTION_SOURCE_LL_ADDRESS:
91 case SD_NDISC_OPTION_TARGET_LL_ADDRESS: {
92 _cleanup_free_ char *c = NULL;
93 const uint8_t *p;
94 size_t n;
95
96 assert_se(sd_ndisc_router_option_get_raw(rt, &p, &n) >= 0);
97 assert_se(n > 2);
98 assert_se(c = hexmem(p + 2, n - 2));
99
100 log_info("Address: %s", c);
101 break;
102 }
103
104 case SD_NDISC_OPTION_PREFIX_INFORMATION: {
105 uint8_t prefix_len, pfl;
106 struct in6_addr a;
107
108 assert_se(sd_ndisc_router_prefix_get_valid_lifetime(rt, &lifetime) >= 0);
109 assert_se(sd_ndisc_router_prefix_get_valid_lifetime_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
110 log_info("Valid Lifetime: %s (%s)", FORMAT_TIMESPAN(lifetime, USEC_PER_SEC), FORMAT_TIMESTAMP(t));
111
112 assert_se(sd_ndisc_router_prefix_get_preferred_lifetime(rt, &lifetime) >= 0);
113 assert_se(sd_ndisc_router_prefix_get_preferred_lifetime_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
114 log_info("Preferred Lifetime: %s (%s)", FORMAT_TIMESPAN(lifetime, USEC_PER_SEC), FORMAT_TIMESTAMP(t));
115
116 assert_se(sd_ndisc_router_prefix_get_flags(rt, &pfl) >= 0);
117 log_info("Flags: <%s|%s>",
118 pfl & ND_OPT_PI_FLAG_ONLINK ? "ONLINK" : "",
119 pfl & ND_OPT_PI_FLAG_AUTO ? "AUTO" : "");
120
121 assert_se(sd_ndisc_router_prefix_get_prefixlen(rt, &prefix_len) >= 0);
122 log_info("Prefix Length: %u", prefix_len);
123
124 assert_se(sd_ndisc_router_prefix_get_address(rt, &a) >= 0);
125 log_info("Prefix: %s", IN6_ADDR_TO_STRING(&a));
126
127 break;
128 }
129
130 case SD_NDISC_OPTION_RDNSS: {
131 const struct in6_addr *a;
132 int n, i;
133
134 n = sd_ndisc_router_rdnss_get_addresses(rt, &a);
135 assert_se(n > 0);
136
137 for (i = 0; i < n; i++)
138 log_info("DNS: %s", IN6_ADDR_TO_STRING(a + i));
139
140 assert_se(sd_ndisc_router_rdnss_get_lifetime(rt, &lifetime) >= 0);
141 assert_se(sd_ndisc_router_rdnss_get_lifetime_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
142 log_info("Lifetime: %s (%s)", FORMAT_TIMESPAN(lifetime, USEC_PER_SEC), FORMAT_TIMESTAMP(t));
143 break;
144 }
145
146 case SD_NDISC_OPTION_DNSSL: {
147 char **l;
148
149 assert_se(sd_ndisc_router_dnssl_get_domains(rt, &l) >= 0);
150
151 STRV_FOREACH(s, l)
152 log_info("Domain: %s", *s);
153
154 assert_se(sd_ndisc_router_dnssl_get_lifetime(rt, &lifetime) >= 0);
155 assert_se(sd_ndisc_router_dnssl_get_lifetime_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
156 log_info("Lifetime: %s (%s)", FORMAT_TIMESPAN(lifetime, USEC_PER_SEC), FORMAT_TIMESTAMP(t));
157 break;
158 }}
159
160 r = sd_ndisc_router_option_next(rt);
161 }
162}
163
164static int send_ra(uint8_t flags) {
165 uint8_t advertisement[] = {
166 /* struct nd_router_advert */
167 0x86, 0x00, 0xde, 0x83, 0x40, 0xc0, 0x00, 0xb4,
168 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
169 /* type = 0x03 (SD_NDISC_OPTION_PREFIX_INFORMATION), length = 32 */
170 0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x01, 0xf4,
171 0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x00,
172 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
173 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
174 /* type = 0x19 (SD_NDISC_OPTION_RDNSS), length = 24 */
175 0x19, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
176 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
177 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
178 /* type = 0x1f (SD_NDISC_OPTION_DNSSL), length = 24 */
179 0x1f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
180 0x03, 0x6c, 0x61, 0x62, 0x05, 0x69, 0x6e, 0x74,
181 0x72, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
182 /* type = 0x01 (SD_NDISC_OPTION_SOURCE_LL_ADDRESS), length = 8 */
183 0x01, 0x01, 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53,
184 };
185
186 advertisement[5] = flags;
187
188 assert_se(write(test_fd[1], advertisement, sizeof(advertisement)) ==
189 sizeof(advertisement));
190
191 if (verbose)
192 printf(" sent RA with flag 0x%02x\n", flags);
193
194 return 0;
195}
196
197static void test_callback_ra(sd_ndisc *nd, sd_ndisc_event_t event, void *message, void *userdata) {
198 sd_event *e = userdata;
199 static unsigned idx = 0;
200 uint64_t flags_array[] = {
201 0,
202 0,
203 0,
204 ND_RA_FLAG_OTHER,
205 ND_RA_FLAG_MANAGED
206 };
207 uint64_t flags;
208
209 assert_se(nd);
210
211 if (event != SD_NDISC_EVENT_ROUTER)
212 return;
213
214 sd_ndisc_router *rt = ASSERT_PTR(message);
215
216 router_dump(rt);
217
218 assert_se(sd_ndisc_router_get_flags(rt, &flags) >= 0);
219 assert_se(flags == flags_array[idx]);
220 idx++;
221
222 if (verbose)
223 printf(" got event 0x%02" PRIx64 "\n", flags);
224
225 if (idx < ELEMENTSOF(flags_array)) {
226 send_ra(flags_array[idx]);
227 return;
228 }
229
230 idx = 0;
231 sd_event_exit(e, 0);
232}
233
234static int on_recv_rs(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
235 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
236 assert_se(icmp6_packet_receive(fd, &packet) >= 0);
237
238 return send_ra(0);
239}
240
241TEST(rs) {
242 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
243 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
244 _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
245
246 assert_se(sd_event_new(&e) >= 0);
247
248 assert_se(sd_ndisc_new(&nd) >= 0);
249 assert_se(nd);
250
251 assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
252
253 assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
254 assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
255 assert_se(sd_ndisc_set_callback(nd, test_callback_ra, e) >= 0);
256
257 assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
258 30 * USEC_PER_SEC, 0,
259 NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
260
261 assert_se(sd_ndisc_stop(nd) >= 0);
262 assert_se(sd_ndisc_start(nd) >= 0);
263 assert_se(sd_ndisc_start(nd) >= 0);
264 assert_se(sd_ndisc_stop(nd) >= 0);
265 test_fd[1] = safe_close(test_fd[1]);
266
267 assert_se(sd_ndisc_start(nd) >= 0);
268
269 assert_se(sd_event_add_io(e, &s, test_fd[1], EPOLLIN, on_recv_rs, nd) >= 0);
270 assert_se(sd_event_source_set_io_fd_own(s, true) >= 0);
271
272 assert_se(sd_event_loop(e) >= 0);
273
274 test_fd[1] = -EBADF;
275}
276
277static int send_ra_invalid_domain(uint8_t flags) {
278 uint8_t advertisement[] = {
279 /* struct nd_router_advert */
280 0x86, 0x00, 0xde, 0x83, 0x40, 0xc0, 0x00, 0xb4,
281 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
282 /* type = 0x03 (SD_NDISC_OPTION_PREFIX_INFORMATION), length = 32 */
283 0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x01, 0xf4,
284 0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x00,
285 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
286 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
287 /* type = 0x19 (SD_NDISC_OPTION_RDNSS), length = 24 */
288 0x19, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
289 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
290 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
291 /* type = 0x1f (SD_NDISC_OPTION_DNSSL), length = 112 */
292 0x1f, 0x0e, 0xee, 0x68, 0xb0, 0xf4, 0x36, 0x39,
293 0x2c, 0xbc, 0x0b, 0xbc, 0xa9, 0x97, 0x71, 0x37,
294 0xad, 0x86, 0x80, 0x14, 0x2e, 0x58, 0xaa, 0x8a,
295 0xb7, 0xa1, 0xbe, 0x91, 0x59, 0x00, 0xc4, 0xe8,
296 0xdd, 0xd8, 0x6d, 0xe5, 0x4a, 0x7a, 0x71, 0x42,
297 0x74, 0x45, 0x9e, 0x2e, 0xfd, 0x9d, 0x71, 0x1d,
298 0xd0, 0xc0, 0x54, 0x0c, 0x4d, 0x1f, 0xbf, 0x90,
299 0xd9, 0x79, 0x58, 0xc0, 0x1d, 0xa3, 0x39, 0xcf,
300 0xb8, 0xec, 0xd2, 0xe4, 0xcd, 0xb6, 0x13, 0x2f,
301 0xc0, 0x46, 0xe8, 0x07, 0x3f, 0xaa, 0x28, 0xa5,
302 0x23, 0xf1, 0xf0, 0xca, 0xd3, 0x19, 0x3f, 0xfa,
303 0x6c, 0x7c, 0xec, 0x1b, 0xcf, 0x71, 0xeb, 0xba,
304 0x68, 0x1b, 0x8e, 0x7d, 0x93, 0x7e, 0x0b, 0x9f,
305 0xdb, 0x12, 0x9c, 0x75, 0x22, 0x5f, 0x12, 0x00,
306 /* type = 0x01 (SD_NDISC_OPTION_SOURCE_LL_ADDRESS), length = 8 */
307 0x01, 0x01, 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53,
308 };
309
310 advertisement[5] = flags;
311
312 printf("sizeof(nd_router_advert)=%zu\n", sizeof(struct nd_router_advert));
313
314 assert_se(write(test_fd[1], advertisement, sizeof(advertisement)) ==
315 sizeof(advertisement));
316
317 if (verbose)
318 printf(" sent RA with flag 0x%02x\n", flags);
319
320 return 0;
321}
322
323static int on_recv_rs_invalid_domain(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
324 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
325 assert_se(icmp6_packet_receive(fd, &packet) >= 0);
326
327 return send_ra_invalid_domain(0);
328}
329
330TEST(invalid_domain) {
331 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
332 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
333 _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
334
335 assert_se(sd_event_new(&e) >= 0);
336
337 assert_se(sd_ndisc_new(&nd) >= 0);
338 assert_se(nd);
339
340 assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
341
342 assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
343 assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
344 assert_se(sd_ndisc_set_callback(nd, test_callback_ra, e) >= 0);
345
346 assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
347 30 * USEC_PER_SEC, 0,
348 NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
349
350 assert_se(sd_ndisc_start(nd) >= 0);
351
352 assert_se(sd_event_add_io(e, &s, test_fd[1], EPOLLIN, on_recv_rs_invalid_domain, nd) >= 0);
353 assert_se(sd_event_source_set_io_fd_own(s, true) >= 0);
354
355 assert_se(sd_event_loop(e) >= 0);
356
357 test_fd[1] = -EBADF;
358}
359
360static void neighbor_dump(sd_ndisc_neighbor *na) {
361 struct in6_addr addr;
362 uint32_t flags;
363
364 assert_se(na);
365
366 log_info("--");
367 assert_se(sd_ndisc_neighbor_get_sender_address(na, &addr) >= 0);
368 log_info("Sender: %s", IN6_ADDR_TO_STRING(&addr));
369
370 assert_se(sd_ndisc_neighbor_get_flags(na, &flags) >= 0);
371 log_info("Flags: Router:%s, Solicited:%s, Override: %s",
372 yes_no(flags & ND_NA_FLAG_ROUTER),
373 yes_no(flags & ND_NA_FLAG_SOLICITED),
374 yes_no(flags & ND_NA_FLAG_OVERRIDE));
375
376 assert_se(sd_ndisc_neighbor_is_router(na) == FLAGS_SET(flags, ND_NA_FLAG_ROUTER));
377 assert_se(sd_ndisc_neighbor_is_solicited(na) == FLAGS_SET(flags, ND_NA_FLAG_SOLICITED));
378 assert_se(sd_ndisc_neighbor_is_override(na) == FLAGS_SET(flags, ND_NA_FLAG_OVERRIDE));
379}
380
381static int send_na(uint32_t flags) {
382 uint8_t advertisement[] = {
383 /* struct nd_neighbor_advert */
384 0x88, 0x00, 0xde, 0x83, 0x00, 0x00, 0x00, 0x00,
385 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
386 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
387 /* type = 0x02 (SD_NDISC_OPTION_TARGET_LL_ADDRESS), length = 8 */
388 0x01, 0x01, 'A', 'B', 'C', '1', '2', '3',
389 };
390
391 ((struct nd_neighbor_advert*) advertisement)->nd_na_flags_reserved = flags;
392
393 assert_se(write(test_fd[1], advertisement, sizeof(advertisement)) == sizeof(advertisement));
394 if (verbose)
395 printf(" sent NA with flag 0x%02x\n", flags);
396
397 return 0;
398}
399
400static void test_callback_na(sd_ndisc *nd, sd_ndisc_event_t event, void *message, void *userdata) {
401 sd_event *e = userdata;
402 static unsigned idx = 0;
403 uint32_t flags_array[] = {
404 0,
405 0,
406 ND_NA_FLAG_ROUTER,
407 ND_NA_FLAG_SOLICITED,
408 ND_NA_FLAG_SOLICITED | ND_NA_FLAG_OVERRIDE,
409 };
410 uint32_t flags;
411
412 assert_se(nd);
413
414 if (event != SD_NDISC_EVENT_NEIGHBOR)
415 return;
416
417 sd_ndisc_neighbor *rt = ASSERT_PTR(message);
418
419 neighbor_dump(rt);
420
421 assert_se(sd_ndisc_neighbor_get_flags(rt, &flags) >= 0);
422 assert_se(flags == flags_array[idx]);
423 idx++;
424
425 if (verbose)
426 printf(" got event 0x%02" PRIx32 "\n", flags);
427
428 if (idx < ELEMENTSOF(flags_array)) {
429 send_na(flags_array[idx]);
430 return;
431 }
432
433 idx = 0;
434 sd_event_exit(e, 0);
435}
436
437static int on_recv_rs_na(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
438 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
439 assert_se(icmp6_packet_receive(fd, &packet) >= 0);
440
441 return send_na(0);
442}
443
444TEST(na) {
445 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
446 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
447 _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
448
449 assert_se(sd_event_new(&e) >= 0);
450
451 assert_se(sd_ndisc_new(&nd) >= 0);
452 assert_se(nd);
453
454 assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
455
456 assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
457 assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
458 assert_se(sd_ndisc_set_callback(nd, test_callback_na, e) >= 0);
459
460 assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
461 30 * USEC_PER_SEC, 0,
462 NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
463
464 assert_se(sd_ndisc_start(nd) >= 0);
465
466 assert_se(sd_event_add_io(e, &s, test_fd[1], EPOLLIN, on_recv_rs_na, nd) >= 0);
467 assert_se(sd_event_source_set_io_fd_own(s, true) >= 0);
468
469 assert_se(sd_event_loop(e) >= 0);
470
471 test_fd[1] = -EBADF;
472}
473
474static int on_recv_rs_timeout(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
475 _cleanup_(icmp6_packet_unrefp) ICMP6Packet *packet = NULL;
476 sd_ndisc *nd = ASSERT_PTR(userdata);
477 static int count = 0;
478 static usec_t last = 0;
479 usec_t min, max;
480
481 assert_se(icmp6_packet_receive(fd, &packet) >= 0);
482
483 if (++count >= 20)
484 sd_event_exit(nd->event, 0);
485
486 if (last == 0) {
487 /* initial RT = IRT + RAND*IRT */
488 min = NDISC_ROUTER_SOLICITATION_INTERVAL -
489 NDISC_ROUTER_SOLICITATION_INTERVAL / 10;
490 max = NDISC_ROUTER_SOLICITATION_INTERVAL +
491 NDISC_ROUTER_SOLICITATION_INTERVAL / 10;
492 } else {
493 /* next RT = 2*RTprev + RAND*RTprev */
494 min = 2 * last - last / 10;
495 max = 2 * last + last / 10;
496 }
497
498 /* final RT > MRT */
499 if (last * 2 > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL) {
500 min = NDISC_MAX_ROUTER_SOLICITATION_INTERVAL -
501 NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 10;
502 max = NDISC_MAX_ROUTER_SOLICITATION_INTERVAL +
503 NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 10;
504 }
505
506 log_info("backoff timeout interval %2d %s%s <= %s <= %s",
507 count,
508 last * 2 > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL ? "(max) ": "",
509 FORMAT_TIMESPAN(min, USEC_PER_MSEC),
510 FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_MSEC),
511 FORMAT_TIMESPAN(max, USEC_PER_MSEC));
512
513 assert_se(min <= nd->retransmit_time);
514 assert_se(max >= nd->retransmit_time);
515
516 last = nd->retransmit_time;
517
518 assert_se(sd_event_source_set_time(nd->timeout_event_source, 0) >= 0);
519
520 return 0;
521}
522
523TEST(timeout) {
524 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
525 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
526 _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
527
528 assert_se(sd_event_new(&e) >= 0);
529
530 assert_se(sd_ndisc_new(&nd) >= 0);
531 assert_se(nd);
532
533 assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
534
535 assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
536 assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
537
538 assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
539 30 * USEC_PER_SEC, 0,
540 NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
541
542 assert_se(sd_ndisc_start(nd) >= 0);
543
544 assert_se(sd_event_add_io(e, &s, test_fd[1], EPOLLIN, on_recv_rs_timeout, nd) >= 0);
545 assert_se(sd_event_source_set_io_fd_own(s, true) >= 0);
546
547 assert_se(sd_event_loop(e) >= 0);
548
549 test_fd[1] = -EBADF;
550}
551
552DEFINE_TEST_MAIN(LOG_DEBUG);
Unnamed repository; edit this file 'description' to name the repository.