1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2015 National Instruments
6 * Joe Hershberger <joe.hershberger@ni.com>
19 #include <dm/device-internal.h>
20 #include <dm/uclass-internal.h>
21 #include <test/test.h>
25 #define DM_TEST_ETH_NUM 4
27 #if IS_ENABLED(CONFIG_IPV6)
28 static int dm_test_string_to_ip6(struct unit_test_state *uts)
31 struct test_ip6_pair {
33 struct in6_addr ip6_addr;
36 struct in6_addr ip6 = {0};
38 /* Correct statements */
39 struct test_ip6_pair test_suite[] = {
40 {"2001:db8::0:1234:1", {.s6_addr32[0] = 0xb80d0120,
41 .s6_addr32[1] = 0x00000000,
42 .s6_addr32[2] = 0x00000000,
43 .s6_addr32[3] = 0x01003412}},
44 {"2001:0db8:0000:0000:0000:0000:1234:0001",
45 {.s6_addr32[0] = 0xb80d0120,
46 .s6_addr32[1] = 0x00000000,
47 .s6_addr32[2] = 0x00000000,
48 .s6_addr32[3] = 0x01003412}},
49 {"::1", {.s6_addr32[0] = 0x00000000,
50 .s6_addr32[1] = 0x00000000,
51 .s6_addr32[2] = 0x00000000,
52 .s6_addr32[3] = 0x01000000}},
53 {"::ffff:192.168.1.1", {.s6_addr32[0] = 0x00000000,
54 .s6_addr32[1] = 0x00000000,
55 .s6_addr32[2] = 0xffff0000,
56 .s6_addr32[3] = 0x0101a8c0}},
59 for (int i = 0; i < ARRAY_SIZE(test_suite); ++i) {
60 ut_assertok(string_to_ip6(test_suite[i].string_addr,
61 strlen(test_suite[i].string_addr), &ip6));
62 ut_asserteq_mem(&ip6, &test_suite[i].ip6_addr,
63 sizeof(struct in6_addr));
66 /* Incorrect statements */
68 ut_assertok(!string_to_ip6(str, strlen(str), &ip6));
69 str = "2001:db8::0::0";
70 ut_assertok(!string_to_ip6(str, strlen(str), &ip6));
71 str = "2001:db8:192.168.1.1::1";
72 ut_assertok(!string_to_ip6(str, strlen(str), &ip6));
74 ut_assertok(!string_to_ip6(str, strlen(str), &ip6));
78 DM_TEST(dm_test_string_to_ip6, 0);
80 static int dm_test_csum_ipv6_magic(struct unit_test_state *uts)
82 unsigned short csum = 0xbeef;
83 /* Predefined correct parameters */
84 unsigned short correct_csum = 0xd8ac;
85 struct in6_addr saddr = {.s6_addr32[0] = 0x000080fe,
86 .s6_addr32[1] = 0x00000000,
87 .s6_addr32[2] = 0xffe9f242,
88 .s6_addr32[3] = 0xe8f66dfe};
89 struct in6_addr daddr = {.s6_addr32[0] = 0x000080fe,
90 .s6_addr32[1] = 0x00000000,
91 .s6_addr32[2] = 0xffd5b372,
92 .s6_addr32[3] = 0x3ef692fe};
94 unsigned short proto = 17;
95 unsigned int head_csum = 0x91f0;
97 csum = csum_ipv6_magic(&saddr, &daddr, len, proto, head_csum);
98 ut_asserteq(csum, correct_csum);
100 /* Broke a parameter */
102 csum = csum_ipv6_magic(&saddr, &daddr, len, proto, head_csum);
103 ut_assert(csum != correct_csum);
107 DM_TEST(dm_test_csum_ipv6_magic, 0);
109 static int dm_test_ip6_addr_in_subnet(struct unit_test_state *uts)
111 struct in6_addr our = {.s6_addr32[0] = 0x000080fe,
112 .s6_addr32[1] = 0x00000000,
113 .s6_addr32[2] = 0xffe9f242,
114 .s6_addr32[3] = 0xe8f66dfe};
115 struct in6_addr neigh1 = {.s6_addr32[0] = 0x000080fe,
116 .s6_addr32[1] = 0x00000000,
117 .s6_addr32[2] = 0xffd5b372,
118 .s6_addr32[3] = 0x3ef692fe};
119 struct in6_addr neigh2 = {.s6_addr32[0] = 0x60480120,
120 .s6_addr32[1] = 0x00006048,
121 .s6_addr32[2] = 0x00000000,
122 .s6_addr32[3] = 0x00008888};
125 ut_assert(ip6_addr_in_subnet(&our, &neigh1, 64));
127 ut_assert(!ip6_addr_in_subnet(&our, &neigh2, 64));
128 ut_assert(!ip6_addr_in_subnet(&our, &neigh1, 128));
132 DM_TEST(dm_test_ip6_addr_in_subnet, 0);
134 static int dm_test_ip6_make_snma(struct unit_test_state *uts)
136 struct in6_addr mult = {0};
137 struct in6_addr correct_addr = {
138 .s6_addr32[0] = 0x000002ff,
139 .s6_addr32[1] = 0x00000000,
140 .s6_addr32[2] = 0x01000000,
141 .s6_addr32[3] = 0xe8f66dff};
142 struct in6_addr addr = { .s6_addr32[0] = 0x000080fe,
143 .s6_addr32[1] = 0x00000000,
144 .s6_addr32[2] = 0xffe9f242,
145 .s6_addr32[3] = 0xe8f66dfe};
147 ip6_make_snma(&mult, &addr);
148 ut_asserteq_mem(&mult, &correct_addr, sizeof(struct in6_addr));
152 DM_TEST(dm_test_ip6_make_snma, 0);
154 static int dm_test_ip6_make_lladdr(struct unit_test_state *uts)
156 struct in6_addr generated_lladdr = {0};
157 struct in6_addr correct_lladdr = {
158 .s6_addr32[0] = 0x000080fe,
159 .s6_addr32[1] = 0x00000000,
160 .s6_addr32[2] = 0xffabf33a,
161 .s6_addr32[3] = 0xfbb352fe};
162 const unsigned char mac[6] = {0x38, 0xf3, 0xab, 0x52, 0xb3, 0xfb};
164 ip6_make_lladdr(&generated_lladdr, mac);
165 ut_asserteq_mem(&generated_lladdr, &correct_lladdr,
166 sizeof(struct in6_addr));
170 DM_TEST(dm_test_ip6_make_lladdr, UT_TESTF_SCAN_FDT);
173 static int dm_test_eth(struct unit_test_state *uts)
175 net_ping_ip = string_to_ip("1.1.2.2");
177 env_set("ethact", "eth@10002000");
178 ut_assertok(net_loop(PING));
179 ut_asserteq_str("eth@10002000", env_get("ethact"));
181 env_set("ethact", "eth@10003000");
182 ut_assertok(net_loop(PING));
183 ut_asserteq_str("eth@10003000", env_get("ethact"));
185 env_set("ethact", "eth@10004000");
186 ut_assertok(net_loop(PING));
187 ut_asserteq_str("eth@10004000", env_get("ethact"));
191 DM_TEST(dm_test_eth, UT_TESTF_SCAN_FDT);
193 static int dm_test_eth_alias(struct unit_test_state *uts)
195 net_ping_ip = string_to_ip("1.1.2.2");
196 env_set("ethact", "eth0");
197 ut_assertok(net_loop(PING));
198 ut_asserteq_str("eth@10002000", env_get("ethact"));
200 env_set("ethact", "eth6");
201 ut_assertok(net_loop(PING));
202 ut_asserteq_str("eth@10004000", env_get("ethact"));
204 /* Expected to fail since eth1 is not defined in the device tree */
205 env_set("ethact", "eth1");
206 ut_assertok(net_loop(PING));
207 ut_asserteq_str("eth@10002000", env_get("ethact"));
209 env_set("ethact", "eth5");
210 ut_assertok(net_loop(PING));
211 ut_asserteq_str("eth@10003000", env_get("ethact"));
215 DM_TEST(dm_test_eth_alias, UT_TESTF_SCAN_FDT);
217 static int dm_test_eth_prime(struct unit_test_state *uts)
219 net_ping_ip = string_to_ip("1.1.2.2");
221 /* Expected to be "eth@10003000" because of ethprime variable */
222 env_set("ethact", NULL);
223 env_set("ethprime", "eth5");
224 ut_assertok(net_loop(PING));
225 ut_asserteq_str("eth@10003000", env_get("ethact"));
227 /* Expected to be "eth@10002000" because it is first */
228 env_set("ethact", NULL);
229 env_set("ethprime", NULL);
230 ut_assertok(net_loop(PING));
231 ut_asserteq_str("eth@10002000", env_get("ethact"));
235 DM_TEST(dm_test_eth_prime, UT_TESTF_SCAN_FDT);
238 * This test case is trying to test the following scenario:
239 * - All ethernet devices are not probed
240 * - "ethaddr" for all ethernet devices are not set
241 * - "ethact" is set to a valid ethernet device name
243 * With Sandbox default test configuration, all ethernet devices are
244 * probed after power-up, so we have to manually create such scenario:
245 * - Remove all ethernet devices
246 * - Remove all "ethaddr" environment variables
247 * - Set "ethact" to the first ethernet device
249 * Do a ping test to see if anything goes wrong.
251 static int dm_test_eth_act(struct unit_test_state *uts)
253 struct udevice *dev[DM_TEST_ETH_NUM];
254 const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000",
255 "sbe5", "eth@10004000"};
256 const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr",
257 "eth3addr", "eth6addr"};
258 char ethaddr[DM_TEST_ETH_NUM][18];
261 memset(ethaddr, '\0', sizeof(ethaddr));
262 net_ping_ip = string_to_ip("1.1.2.2");
264 /* Prepare the test scenario */
265 for (i = 0; i < DM_TEST_ETH_NUM; i++) {
266 ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
267 ethname[i], &dev[i]));
268 ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
270 /* Invalidate MAC address */
271 strncpy(ethaddr[i], env_get(addrname[i]), 17);
272 /* Must disable access protection for ethaddr before clearing */
273 env_set(".flags", addrname[i]);
274 env_set(addrname[i], NULL);
277 /* Set ethact to "eth@10002000" */
278 env_set("ethact", ethname[0]);
280 /* Segment fault might happen if something is wrong */
281 ut_asserteq(-ENODEV, net_loop(PING));
283 for (i = 0; i < DM_TEST_ETH_NUM; i++) {
284 /* Restore the env */
285 env_set(".flags", addrname[i]);
286 env_set(addrname[i], ethaddr[i]);
288 /* Probe the device again */
289 ut_assertok(device_probe(dev[i]));
291 env_set(".flags", NULL);
292 env_set("ethact", NULL);
296 DM_TEST(dm_test_eth_act, UT_TESTF_SCAN_FDT);
298 /* Ensure that all addresses are loaded properly */
299 static int dm_test_ethaddr(struct unit_test_state *uts)
301 static const char *const addr[] = {
303 "02:00:11:22:33:48", /* dsa slave */
305 "02:00:11:22:33:48", /* dsa master */
308 "02:00:11:22:33:48", /* dsa slave */
313 for (i = 0; i < ARRAY_SIZE(addr); i++) {
317 snprintf(addrname, sizeof(addrname), "eth%daddr", i + 1);
319 strcpy(addrname, "ethaddr");
320 ut_asserteq_str(addr[i], env_get(addrname));
325 DM_TEST(dm_test_ethaddr, UT_TESTF_SCAN_FDT);
327 /* The asserts include a return on fail; cleanup in the caller */
328 static int _dm_test_eth_rotate1(struct unit_test_state *uts)
330 /* Make sure that the default is to rotate to the next interface */
331 env_set("ethact", "eth@10004000");
332 ut_assertok(net_loop(PING));
333 ut_asserteq_str("eth@10002000", env_get("ethact"));
335 /* If ethrotate is no, then we should fail on a bad MAC */
336 env_set("ethact", "eth@10004000");
337 env_set("ethrotate", "no");
338 ut_asserteq(-EINVAL, net_loop(PING));
339 ut_asserteq_str("eth@10004000", env_get("ethact"));
344 static int _dm_test_eth_rotate2(struct unit_test_state *uts)
346 /* Make sure we can skip invalid devices */
347 env_set("ethact", "eth@10004000");
348 ut_assertok(net_loop(PING));
349 ut_asserteq_str("eth@10004000", env_get("ethact"));
351 /* Make sure we can handle device name which is not eth# */
352 env_set("ethact", "sbe5");
353 ut_assertok(net_loop(PING));
354 ut_asserteq_str("sbe5", env_get("ethact"));
359 static int dm_test_eth_rotate(struct unit_test_state *uts)
364 /* Set target IP to mock ping */
365 net_ping_ip = string_to_ip("1.1.2.2");
367 /* Invalidate eth1's MAC address */
368 memset(ethaddr, '\0', sizeof(ethaddr));
369 strncpy(ethaddr, env_get("eth6addr"), 17);
370 /* Must disable access protection for eth6addr before clearing */
371 env_set(".flags", "eth6addr");
372 env_set("eth6addr", NULL);
374 retval = _dm_test_eth_rotate1(uts);
376 /* Restore the env */
377 env_set("eth6addr", ethaddr);
378 env_set("ethrotate", NULL);
381 /* Invalidate eth0's MAC address */
382 strncpy(ethaddr, env_get("ethaddr"), 17);
383 /* Must disable access protection for ethaddr before clearing */
384 env_set(".flags", "ethaddr");
385 env_set("ethaddr", NULL);
387 retval = _dm_test_eth_rotate2(uts);
389 /* Restore the env */
390 env_set("ethaddr", ethaddr);
392 /* Restore the env */
393 env_set(".flags", NULL);
397 DM_TEST(dm_test_eth_rotate, UT_TESTF_SCAN_FDT);
399 /* The asserts include a return on fail; cleanup in the caller */
400 static int _dm_test_net_retry(struct unit_test_state *uts)
403 * eth1 is disabled and netretry is yes, so the ping should succeed and
404 * the active device should be eth0
406 sandbox_eth_disable_response(1, true);
407 env_set("ethact", "lan1");
408 env_set("netretry", "yes");
409 sandbox_eth_skip_timeout();
410 ut_assertok(net_loop(PING));
411 ut_asserteq_str("eth@10002000", env_get("ethact"));
414 * eth1 is disabled and netretry is no, so the ping should fail and the
415 * active device should be eth1
417 env_set("ethact", "lan1");
418 env_set("netretry", "no");
419 sandbox_eth_skip_timeout();
420 ut_asserteq(-ENONET, net_loop(PING));
421 ut_asserteq_str("lan1", env_get("ethact"));
426 static int dm_test_net_retry(struct unit_test_state *uts)
430 net_ping_ip = string_to_ip("1.1.2.2");
432 retval = _dm_test_net_retry(uts);
434 /* Restore the env */
435 env_set("netretry", NULL);
436 sandbox_eth_disable_response(1, false);
440 DM_TEST(dm_test_net_retry, UT_TESTF_SCAN_FDT);
442 static int sb_check_arp_reply(struct udevice *dev, void *packet,
445 struct eth_sandbox_priv *priv = dev_get_priv(dev);
446 struct ethernet_hdr *eth = packet;
448 /* Used by all of the ut_assert macros */
449 struct unit_test_state *uts = priv->priv;
451 if (ntohs(eth->et_protlen) != PROT_ARP)
454 arp = packet + ETHER_HDR_SIZE;
456 if (ntohs(arp->ar_op) != ARPOP_REPLY)
459 /* This test would be worthless if we are not waiting */
460 ut_assert(arp_is_waiting());
462 /* Validate response */
463 ut_asserteq_mem(eth->et_src, net_ethaddr, ARP_HLEN);
464 ut_asserteq_mem(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN);
465 ut_assert(eth->et_protlen == htons(PROT_ARP));
467 ut_assert(arp->ar_hrd == htons(ARP_ETHER));
468 ut_assert(arp->ar_pro == htons(PROT_IP));
469 ut_assert(arp->ar_hln == ARP_HLEN);
470 ut_assert(arp->ar_pln == ARP_PLEN);
471 ut_asserteq_mem(&arp->ar_sha, net_ethaddr, ARP_HLEN);
472 ut_assert(net_read_ip(&arp->ar_spa).s_addr == net_ip.s_addr);
473 ut_asserteq_mem(&arp->ar_tha, priv->fake_host_hwaddr, ARP_HLEN);
474 ut_assert(net_read_ip(&arp->ar_tpa).s_addr ==
475 string_to_ip("1.1.2.4").s_addr);
480 static int sb_with_async_arp_handler(struct udevice *dev, void *packet,
483 struct eth_sandbox_priv *priv = dev_get_priv(dev);
484 struct ethernet_hdr *eth = packet;
485 struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
489 * If we are about to generate a reply to ARP, first inject a request
492 if (ntohs(eth->et_protlen) == PROT_ARP &&
493 ntohs(arp->ar_op) == ARPOP_REQUEST) {
494 /* Make sure sandbox_eth_recv_arp_req() knows who is asking */
495 priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
497 ret = sandbox_eth_recv_arp_req(dev);
502 sandbox_eth_arp_req_to_reply(dev, packet, len);
503 sandbox_eth_ping_req_to_reply(dev, packet, len);
505 return sb_check_arp_reply(dev, packet, len);
508 static int dm_test_eth_async_arp_reply(struct unit_test_state *uts)
510 net_ping_ip = string_to_ip("1.1.2.2");
512 sandbox_eth_set_tx_handler(0, sb_with_async_arp_handler);
513 /* Used by all of the ut_assert macros in the tx_handler */
514 sandbox_eth_set_priv(0, uts);
516 env_set("ethact", "eth@10002000");
517 ut_assertok(net_loop(PING));
518 ut_asserteq_str("eth@10002000", env_get("ethact"));
520 sandbox_eth_set_tx_handler(0, NULL);
525 DM_TEST(dm_test_eth_async_arp_reply, UT_TESTF_SCAN_FDT);
527 static int sb_check_ping_reply(struct udevice *dev, void *packet,
530 struct eth_sandbox_priv *priv = dev_get_priv(dev);
531 struct ethernet_hdr *eth = packet;
532 struct ip_udp_hdr *ip;
533 struct icmp_hdr *icmp;
534 /* Used by all of the ut_assert macros */
535 struct unit_test_state *uts = priv->priv;
537 if (ntohs(eth->et_protlen) != PROT_IP)
540 ip = packet + ETHER_HDR_SIZE;
542 if (ip->ip_p != IPPROTO_ICMP)
545 icmp = (struct icmp_hdr *)&ip->udp_src;
547 if (icmp->type != ICMP_ECHO_REPLY)
550 /* This test would be worthless if we are not waiting */
551 ut_assert(arp_is_waiting());
553 /* Validate response */
554 ut_asserteq_mem(eth->et_src, net_ethaddr, ARP_HLEN);
555 ut_asserteq_mem(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN);
556 ut_assert(eth->et_protlen == htons(PROT_IP));
558 ut_assert(net_read_ip(&ip->ip_src).s_addr == net_ip.s_addr);
559 ut_assert(net_read_ip(&ip->ip_dst).s_addr ==
560 string_to_ip("1.1.2.4").s_addr);
565 static int sb_with_async_ping_handler(struct udevice *dev, void *packet,
568 struct eth_sandbox_priv *priv = dev_get_priv(dev);
569 struct ethernet_hdr *eth = packet;
570 struct arp_hdr *arp = packet + ETHER_HDR_SIZE;
574 * If we are about to generate a reply to ARP, first inject a request
577 if (ntohs(eth->et_protlen) == PROT_ARP &&
578 ntohs(arp->ar_op) == ARPOP_REQUEST) {
579 /* Make sure sandbox_eth_recv_arp_req() knows who is asking */
580 priv->fake_host_ipaddr = string_to_ip("1.1.2.4");
582 ret = sandbox_eth_recv_ping_req(dev);
587 sandbox_eth_arp_req_to_reply(dev, packet, len);
588 sandbox_eth_ping_req_to_reply(dev, packet, len);
590 return sb_check_ping_reply(dev, packet, len);
593 static int dm_test_eth_async_ping_reply(struct unit_test_state *uts)
595 net_ping_ip = string_to_ip("1.1.2.2");
597 sandbox_eth_set_tx_handler(0, sb_with_async_ping_handler);
598 /* Used by all of the ut_assert macros in the tx_handler */
599 sandbox_eth_set_priv(0, uts);
601 env_set("ethact", "eth@10002000");
602 ut_assertok(net_loop(PING));
603 ut_asserteq_str("eth@10002000", env_get("ethact"));
605 sandbox_eth_set_tx_handler(0, NULL);
610 DM_TEST(dm_test_eth_async_ping_reply, UT_TESTF_SCAN_FDT);
612 #if IS_ENABLED(CONFIG_IPV6_ROUTER_DISCOVERY)
614 static u8 ip6_ra_buf[] = {0x60, 0xf, 0xc5, 0x4a, 0x0, 0x38, 0x3a, 0xff, 0xfe,
615 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x85, 0xe6,
616 0x29, 0x77, 0xcb, 0xc8, 0x53, 0xff, 0x2, 0x0, 0x0,
617 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
618 0x1, 0x86, 0x0, 0xdc, 0x90, 0x40, 0x80, 0x15, 0x18,
619 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x4,
620 0x40, 0xc0, 0x0, 0x0, 0x37, 0xdc, 0x0, 0x0, 0x37,
621 0x78, 0x0, 0x0, 0x0, 0x0, 0x20, 0x1, 0xca, 0xfe, 0xca,
622 0xfe, 0xca, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
623 0x0, 0x1, 0x1, 0x0, 0x15, 0x5d, 0xe2, 0x8a, 0x2};
625 static int dm_test_validate_ra(struct unit_test_state *uts)
627 struct ip6_hdr *ip6 = (struct ip6_hdr *)ip6_ra_buf;
628 struct icmp6hdr *icmp = (struct icmp6hdr *)(ip6 + 1);
631 ut_assert(validate_ra(ip6) == true);
633 temp = ip6->payload_len;
634 ip6->payload_len = 15;
635 ut_assert(validate_ra(ip6) == false);
636 ip6->payload_len = temp;
638 temp = ip6->saddr.s6_addr16[0];
639 ip6->saddr.s6_addr16[0] = 0x2001;
640 ut_assert(validate_ra(ip6) == false);
641 ip6->saddr.s6_addr16[0] = temp;
643 temp = ip6->hop_limit;
645 ut_assert(validate_ra(ip6) == false);
646 ip6->hop_limit = temp;
648 temp = icmp->icmp6_code;
649 icmp->icmp6_code = 15;
650 ut_assert(validate_ra(ip6) == false);
651 icmp->icmp6_code = temp;
656 DM_TEST(dm_test_validate_ra, 0);
658 static int dm_test_process_ra(struct unit_test_state *uts)
660 int len = sizeof(ip6_ra_buf);
661 struct ip6_hdr *ip6 = (struct ip6_hdr *)ip6_ra_buf;
662 struct icmp6hdr *icmp = (struct icmp6hdr *)(ip6 + 1);
663 struct ra_msg *msg = (struct ra_msg *)icmp;
664 unsigned char *option = msg->opt;
665 struct icmp6_ra_prefix_info *prefix =
666 (struct icmp6_ra_prefix_info *)option;
668 unsigned char option_len = option[1];
670 ut_assert(process_ra(ip6, len) == 0);
672 temp = icmp->icmp6_rt_lifetime;
673 icmp->icmp6_rt_lifetime = 0;
674 ut_assert(process_ra(ip6, len) != 0);
675 icmp->icmp6_rt_lifetime = temp;
677 ut_assert(process_ra(ip6, 0) != 0);
680 ut_assert(process_ra(ip6, len) != 0);
681 option[1] = option_len;
683 prefix->on_link = false;
684 ut_assert(process_ra(ip6, len) != 0);
685 prefix->on_link = true;
687 temp = prefix->prefix.s6_addr16[0];
688 prefix->prefix.s6_addr16[0] = 0x80fe;
689 ut_assert(process_ra(ip6, len) != 0);
690 prefix->prefix.s6_addr16[0] = temp;
695 DM_TEST(dm_test_process_ra, 0);