src/libsystemd-network/test-ndisc-ra.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2017 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <netinet/icmp6.h>
   7 #include <arpa/inet.h>
   8 #include <unistd.h>
   9
  10 #include "sd-radv.h"
  11
  12 #include "alloc-util.h"
  13 #include "hexdecoct.h"
  14 #include "icmp6-test-util.h"
  15 #include "socket-util.h"
  16 #include "strv.h"
  17 #include "tests.h"
  18
  19 static struct ether_addr mac_addr = {
  20         .ether_addr_octet = { 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53 }
  21 };
  22
  23 static bool test_stopped;
  24 static struct {
  25         struct in6_addr address;
  26         unsigned char prefixlen;
  27         uint32_t valid;
  28         uint32_t preferred;
  29         bool successful;
  30 } prefix[] = {
  31         { { { { 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
  32                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 64,
  33           500, 440, true },
  34         { { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
  35                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 64,
  36           /* indicate default valid and preferred lifetimes for the test code */
  37           0, 0, true },
  38         { { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
  39                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 58,
  40           0, 0,
  41           /* indicate that this prefix already exists */
  42           false },
  43         { { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
  44                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 120,
  45           0, 0,
  46           /* indicate that this prefix already exists */
  47           false },
  48         { { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
  49                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 12,
  50           0, 0,
  51           /* indicate that this prefix already exists */
  52           false },
  53         { { { { 0x20, 0x01, 0x0d, 0xb8, 0xc0, 0x01, 0x0d, 0xad,
  54                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 48,
  55           0, 0, true },
  56         { { { { 0x20, 0x01, 0x0d, 0xb8, 0xc0, 0x01, 0x0d, 0xad,
  57                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 60,
  58           0, 0,
  59           /* indicate that this prefix already exists */
  60           false },
  61 };
  62
  63 static const struct in6_addr test_rdnss = { { { 0x20, 0x01, 0x0d, 0xb8,
  64                                                 0xde, 0xad, 0xbe, 0xef,
  65                                                 0x00, 0x00, 0x00, 0x00,
  66                                                 0x00, 0x00, 0x00, 0x01 } } };
  67 static const char *test_dnssl[] = { "lab.intra",
  68                                     NULL };
  69
  70 TEST(radv_prefix) {
  71         sd_radv_prefix *p;
  72
  73         assert_se(sd_radv_prefix_new(&p) >= 0);
  74
  75         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_onlink(NULL, true) < 0);
  76         assert_se(sd_radv_prefix_set_onlink(p, true) >= 0);
  77         assert_se(sd_radv_prefix_set_onlink(p, false) >= 0);
  78
  79         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_address_autoconfiguration(NULL, true) < 0);
  80         assert_se(sd_radv_prefix_set_address_autoconfiguration(p, true) >= 0);
  81         assert_se(sd_radv_prefix_set_address_autoconfiguration(p, false) >= 0);
  82
  83         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_valid_lifetime(NULL, 1, 1) < 0);
  84         assert_se(sd_radv_prefix_set_valid_lifetime(p, 0, 0) >= 0);
  85         assert_se(sd_radv_prefix_set_valid_lifetime(p, 300 * USEC_PER_SEC, USEC_INFINITY) >= 0);
  86         assert_se(sd_radv_prefix_set_valid_lifetime(p, 300 * USEC_PER_SEC, USEC_PER_YEAR) >= 0);
  87
  88         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_preferred_lifetime(NULL, 1, 1) < 0);
  89         assert_se(sd_radv_prefix_set_preferred_lifetime(p, 0, 0) >= 0);
  90         assert_se(sd_radv_prefix_set_preferred_lifetime(p, 300 * USEC_PER_SEC, USEC_INFINITY) >= 0);
  91         assert_se(sd_radv_prefix_set_preferred_lifetime(p, 300 * USEC_PER_SEC, USEC_PER_YEAR) >= 0);
  92
  93         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_prefix(NULL, NULL, 0) < 0);
  94         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_prefix(p, NULL, 0) < 0);
  95
  96         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 64) >= 0);
  97         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 0) < 0);
  98         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 1) < 0);
  99         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 2) < 0);
 100         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 3) >= 0);
 101         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 125) >= 0);
 102         assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 128) >= 0);
 103         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_prefix(p, &prefix[0].address, 129) < 0);
 104         ASSERT_RETURN_EXPECTED_SE(sd_radv_prefix_set_prefix(p, &prefix[0].address, 255) < 0);
 105
 106         assert_se(!sd_radv_prefix_unref(p));
 107 }
 108
 109 TEST(radv_route_prefix) {
 110         sd_radv_route_prefix *p;
 111
 112         assert_se(sd_radv_route_prefix_new(&p) >= 0);
 113
 114         ASSERT_RETURN_EXPECTED_SE(sd_radv_route_prefix_set_lifetime(NULL, 1, 1) < 0);
 115         assert_se(sd_radv_route_prefix_set_lifetime(p, 0, 0) >= 0);
 116         assert_se(sd_radv_route_prefix_set_lifetime(p, 300 * USEC_PER_SEC, USEC_INFINITY) >= 0);
 117         assert_se(sd_radv_route_prefix_set_lifetime(p, 300 * USEC_PER_SEC, USEC_PER_YEAR) >= 0);
 118
 119         ASSERT_RETURN_EXPECTED_SE(sd_radv_route_prefix_set_prefix(NULL, NULL, 0) < 0);
 120         ASSERT_RETURN_EXPECTED_SE(sd_radv_route_prefix_set_prefix(p, NULL, 0) < 0);
 121
 122         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 64) >= 0);
 123         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 0) >= 0);
 124         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 1) >= 0);
 125         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 2) >= 0);
 126         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 3) >= 0);
 127         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 125) >= 0);
 128         assert_se(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 128) >= 0);
 129         ASSERT_RETURN_EXPECTED_SE(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 129) < 0);
 130         ASSERT_RETURN_EXPECTED_SE(sd_radv_route_prefix_set_prefix(p, &prefix[0].address, 255) < 0);
 131
 132         assert_se(!sd_radv_route_prefix_unref(p));
 133 }
 134
 135 TEST(radv_pref64_prefix) {
 136         sd_radv_pref64_prefix *p;
 137
 138         assert_se(sd_radv_pref64_prefix_new(&p) >= 0);
 139
 140         ASSERT_RETURN_EXPECTED_SE(sd_radv_pref64_prefix_set_prefix(NULL, NULL, 0, 0) < 0);
 141         ASSERT_RETURN_EXPECTED_SE(sd_radv_pref64_prefix_set_prefix(p, NULL, 0, 0) < 0);
 142
 143         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 32, 300 * USEC_PER_SEC) >= 0);
 144         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 40, 300 * USEC_PER_SEC) >= 0);
 145         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 48, 300 * USEC_PER_SEC) >= 0);
 146         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 56, 300 * USEC_PER_SEC) >= 0);
 147         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 64, 300 * USEC_PER_SEC) >= 0);
 148         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 96, 300 * USEC_PER_SEC) >= 0);
 149
 150         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 80, 300 * USEC_PER_SEC) < 0);
 151         assert_se(sd_radv_pref64_prefix_set_prefix(p, &prefix[0].address, 80, USEC_PER_DAY) < 0);
 152
 153         assert_se(!sd_radv_pref64_prefix_unref(p));
 154 }
 155
 156 TEST(radv) {
 157         sd_radv *ra;
 158
 159         assert_se(sd_radv_new(&ra) >= 0);
 160         assert_se(ra);
 161
 162         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_ifindex(NULL, 0) < 0);
 163         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_ifindex(ra, 0) < 0);
 164         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_ifindex(ra, -1) < 0);
 165         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_ifindex(ra, -2) < 0);
 166         assert_se(sd_radv_set_ifindex(ra, 42) >= 0);
 167
 168         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_mac(NULL, NULL) < 0);
 169         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_mac(ra, NULL) >= 0);
 170         assert_se(sd_radv_set_mac(ra, &mac_addr) >= 0);
 171
 172         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_mtu(NULL, 0) < 0);
 173         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_mtu(ra, 0) < 0);
 174         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_mtu(ra, 1279) < 0);
 175         assert_se(sd_radv_set_mtu(ra, 1280) >= 0);
 176         assert_se(sd_radv_set_mtu(ra, ~0) >= 0);
 177
 178         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_hop_limit(NULL, 0) < 0);
 179         assert_se(sd_radv_set_hop_limit(ra, 0) >= 0);
 180         assert_se(sd_radv_set_hop_limit(ra, ~0) >= 0);
 181
 182         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_router_lifetime(NULL, 0) < 0);
 183         assert_se(sd_radv_set_router_lifetime(ra, 0) >= 0);
 184         assert_se(sd_radv_set_router_lifetime(ra, USEC_INFINITY) < 0);
 185         assert_se(sd_radv_set_router_lifetime(ra, USEC_PER_YEAR) < 0);
 186         assert_se(sd_radv_set_router_lifetime(ra, 300 * USEC_PER_SEC) >= 0);
 187
 188         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_preference(NULL, 0) < 0);
 189         assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_LOW) >= 0);
 190         assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_MEDIUM) >= 0);
 191         assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_HIGH) >= 0);
 192         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_preference(ra, ~0) < 0);
 193
 194         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_managed_information(NULL, true) < 0);
 195         assert_se(sd_radv_set_managed_information(ra, true) >= 0);
 196         assert_se(sd_radv_set_managed_information(ra, false) >= 0);
 197
 198         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_other_information(NULL, true) < 0);
 199         assert_se(sd_radv_set_other_information(ra, true) >= 0);
 200         assert_se(sd_radv_set_other_information(ra, false) >= 0);
 201
 202         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_reachable_time(NULL, 10 * USEC_PER_MSEC) < 0);
 203         assert_se(sd_radv_set_reachable_time(ra, 10 * USEC_PER_MSEC) >= 0);
 204         assert_se(sd_radv_set_reachable_time(ra, 0) >= 0);
 205         assert_se(sd_radv_set_reachable_time(ra, USEC_INFINITY) >= 0);
 206
 207         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_retransmit(NULL, 10 * USEC_PER_MSEC) < 0);
 208         assert_se(sd_radv_set_retransmit(ra, 10 * USEC_PER_MSEC) >= 0);
 209         assert_se(sd_radv_set_retransmit(ra, 0) >= 0);
 210         assert_se(sd_radv_set_retransmit(ra, USEC_INFINITY) >= 0);
 211
 212         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_rdnss(NULL, 0, NULL, 0) < 0);
 213         assert_se(sd_radv_set_rdnss(ra, 0, NULL, 0) >= 0);
 214         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_rdnss(ra, 0, NULL, 128) < 0);
 215         assert_se(sd_radv_set_rdnss(ra, 600 * USEC_PER_SEC, &test_rdnss, 0) >= 0);
 216         assert_se(sd_radv_set_rdnss(ra, 600 * USEC_PER_SEC, &test_rdnss, 1) >= 0);
 217         assert_se(sd_radv_set_rdnss(ra, 0, &test_rdnss, 1) >= 0);
 218         assert_se(sd_radv_set_rdnss(ra, 0, NULL, 0) >= 0);
 219
 220         assert_se(sd_radv_set_dnssl(ra, 0, NULL) >= 0);
 221         assert_se(sd_radv_set_dnssl(ra, 600 * USEC_PER_SEC, NULL) >= 0);
 222         assert_se(sd_radv_set_dnssl(ra, 0, (char **)test_dnssl) >= 0);
 223         assert_se(sd_radv_set_dnssl(ra, 600 * USEC_PER_SEC, (char **)test_dnssl) >= 0);
 224
 225         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_home_agent_information(NULL, true) < 0);
 226         assert_se(sd_radv_set_home_agent_information(ra, true) >= 0);
 227         assert_se(sd_radv_set_home_agent_information(ra, false) >= 0);
 228
 229         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_home_agent_preference(NULL, 10) < 0);
 230         assert_se(sd_radv_set_home_agent_preference(ra, 10) >= 0);
 231         assert_se(sd_radv_set_home_agent_preference(ra, 0) >= 0);
 232
 233         ASSERT_RETURN_EXPECTED_SE(sd_radv_set_home_agent_lifetime(NULL, 300 * USEC_PER_SEC) < 0);
 234         assert_se(sd_radv_set_home_agent_lifetime(ra, 300 * USEC_PER_SEC) >= 0);
 235         assert_se(sd_radv_set_home_agent_lifetime(ra, 0) >= 0);
 236         assert_se(sd_radv_set_home_agent_lifetime(ra, USEC_PER_DAY) < 0);
 237
 238         ra = sd_radv_unref(ra);
 239         assert_se(!ra);
 240 }
 241
 242 static void dump_message(const uint8_t *buf, size_t len) {
 243         assert(len >= sizeof(struct nd_router_advert));
 244
 245         printf("Received Router Advertisement with lifetime %i sec\n",
 246                (buf[6] << 8) + buf[7]);
 247
 248         for (size_t i = 0; i < len; i++) {
 249                 if (!(i % 8))
 250                         printf("%3zu: ", i);
 251
 252                 printf("0x%02x", buf[i]);
 253
 254                 if ((i + 1) % 8)
 255                         printf(", ");
 256                 else
 257                         printf("\n");
 258         }
 259 }
 260
 261 static void verify_message(const uint8_t *buf, size_t len) {
 262         static const uint8_t advertisement[] = {
 263                 /* ICMPv6 Router Advertisement, no checksum */
 264                 0x86, 0x00, 0x00, 0x00, 0x40, 0xc0, 0x00, 0xb4,
 265                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 266                 /* Source Link Layer Address Option */
 267                 0x01, 0x01, 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53,
 268                 /* Prefix Information Option */
 269                 0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x01, 0xf4,
 270                 0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x00,
 271                 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
 272                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 273                 /* Prefix Information Option */
 274                 0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x0e, 0x10,
 275                 0x00, 0x00, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00,
 276                 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
 277                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 278                 /* Prefix Information Option */
 279                 0x03, 0x04, 0x30, 0xc0, 0x00, 0x00, 0x0e, 0x10,
 280                 0x00, 0x00, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00,
 281                 0x20, 0x01, 0x0d, 0xb8, 0xc0, 0x01, 0x0d, 0xad,
 282                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 283                 /* Recursive DNS Server Option */
 284                 0x19, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
 285                 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
 286                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 287                 /* DNS Search List Option */
 288                 0x1f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
 289                 0x03, 0x6c, 0x61, 0x62, 0x05, 0x69, 0x6e, 0x74,
 290                 0x72, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 291         };
 292
 293         /* verify only up to known options, rest is not yet implemented */
 294         for (size_t i = 0, m = MIN(len, sizeof(advertisement)); i < m; i++) {
 295                 if (test_stopped)
 296                         /* on stop, many header fields are zero */
 297                         switch (i) {
 298                         case 4: /* hop limit */
 299                         case 5: /* flags */
 300                         case 6 ... 7: /* router lifetime */
 301                         case 8 ... 11: /* reachable time */
 302                         case 12 ... 15: /* retrans timer */
 303                                 assert_se(buf[i] == 0);
 304                                 continue;
 305                         }
 306
 307                 assert_se(buf[i] == advertisement[i]);
 308         }
 309 }
 310
 311 static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 312         sd_radv *ra = ASSERT_PTR(userdata);
 313         _cleanup_free_ uint8_t *buf = NULL;
 314         ssize_t buflen;
 315
 316         buflen = next_datagram_size_fd(fd);
 317         assert_se(buflen >= 0);
 318         assert_se(buf = new0(uint8_t, buflen));
 319
 320         assert_se(read(fd, buf, buflen) == buflen);
 321
 322         dump_message(buf, buflen);
 323         verify_message(buf, buflen);
 324
 325         if (test_stopped) {
 326                 assert_se(sd_event_exit(sd_radv_get_event(ra), 0) >= 0);
 327                 return 0;
 328         }
 329
 330         assert_se(sd_radv_stop(ra) >= 0);
 331         test_stopped = true;
 332         return 0;
 333 }
 334
 335 TEST(ra) {
 336         _cleanup_(sd_event_unrefp) sd_event *e = NULL;
 337         _cleanup_(sd_event_source_unrefp) sd_event_source *recv_router_advertisement = NULL;
 338         _cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
 339
 340         assert_se(socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) >= 0);
 341
 342         assert_se(sd_event_new(&e) >= 0);
 343
 344         assert_se(sd_radv_new(&ra) >= 0);
 345         assert_se(ra);
 346
 347         assert_se(sd_radv_attach_event(ra, e, 0) >= 0);
 348
 349         assert_se(sd_radv_set_ifindex(ra, 42) >= 0);
 350         assert_se(sd_radv_set_mac(ra, &mac_addr) >= 0);
 351         assert_se(sd_radv_set_router_lifetime(ra, 180 * USEC_PER_SEC) >= 0);
 352         assert_se(sd_radv_set_hop_limit(ra, 64) >= 0);
 353         assert_se(sd_radv_set_managed_information(ra, true) >= 0);
 354         assert_se(sd_radv_set_other_information(ra, true) >= 0);
 355         assert_se(sd_radv_set_rdnss(ra, 60 * USEC_PER_SEC, &test_rdnss, 1) >= 0);
 356         assert_se(sd_radv_set_dnssl(ra, 60 * USEC_PER_SEC, (char **)test_dnssl) >= 0);
 357
 358         for (unsigned i = 0; i < ELEMENTSOF(prefix); i++) {
 359                 sd_radv_prefix *p;
 360
 361                 printf("Test prefix %u\n", i);
 362                 assert_se(sd_radv_prefix_new(&p) >= 0);
 363
 364                 assert_se(sd_radv_prefix_set_prefix(p, &prefix[i].address,
 365                                                     prefix[i].prefixlen) >= 0);
 366                 if (prefix[i].valid > 0)
 367                         assert_se(sd_radv_prefix_set_valid_lifetime(p, prefix[i].valid * USEC_PER_SEC, USEC_INFINITY) >= 0);
 368                 if (prefix[i].preferred > 0)
 369                         assert_se(sd_radv_prefix_set_preferred_lifetime(p, prefix[i].preferred * USEC_PER_SEC, USEC_INFINITY) >= 0);
 370
 371                 assert_se((sd_radv_add_prefix(ra, p) >= 0) == prefix[i].successful);
 372                 /* If the previous sd_radv_add_prefix() succeeds, then also the second call should also succeed. */
 373                 assert_se((sd_radv_add_prefix(ra, p) >= 0) == prefix[i].successful);
 374
 375                 p = sd_radv_prefix_unref(p);
 376                 assert_se(!p);
 377         }
 378
 379         assert_se(sd_event_add_io(e, &recv_router_advertisement, test_fd[0], EPOLLIN, radv_recv, ra) >= 0);
 380         assert_se(sd_event_source_set_io_fd_own(recv_router_advertisement, true) >= 0);
 381
 382         assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
 383                                              2 * USEC_PER_SEC, 0,
 384                                              NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
 385
 386         assert_se(sd_radv_start(ra) >= 0);
 387
 388         assert_se(sd_event_loop(e) >= 0);
 389 }
 390
 391 DEFINE_TEST_MAIN(LOG_DEBUG);