1 /* main.c - Application main entry point */
2
3 /*
4 * Copyright (c) 2016 Intel Corporation
5 *
6 * SPDX-License-Identifier: Apache-2.0
7 */
8
9 #include <zephyr/logging/log.h>
10 LOG_MODULE_REGISTER(net_test, CONFIG_NET_UTILS_LOG_LEVEL);
11
12 #include <zephyr/kernel.h>
13 #include <zephyr/ztest_assert.h>
14 #include <zephyr/types.h>
15 #include <stddef.h>
16 #include <string.h>
17 #include <stdio.h>
18 #include <errno.h>
19 #include <zephyr/device.h>
20 #include <zephyr/init.h>
21 #include <zephyr/sys/printk.h>
22 #include <zephyr/net/net_core.h>
23 #include <zephyr/net/net_ip.h>
24 #include <zephyr/net/ethernet.h>
25 #include <zephyr/linker/sections.h>
26
27 #include <zephyr/tc_util.h>
28 #include <zephyr/ztest.h>
29
30 #define NET_LOG_ENABLED 1
31 #include "net_private.h"
32
33 struct net_addr_test_data {
34 net_sa_family_t family;
35 bool pton;
36
37 struct {
38 char c_addr[16];
39 char c_verify[16];
40 struct net_in_addr addr;
41 struct net_in_addr verify;
42 } ipv4;
43
44 struct {
45 char c_addr[46];
46 char c_verify[46];
47 struct net_in6_addr addr;
48 struct net_in6_addr verify;
49 } ipv6;
50 };
51
52 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_1 = {
53 .family = NET_AF_INET,
54 .pton = true,
55 .ipv4.c_addr = "192.0.0.1",
56 .ipv4.verify.s4_addr = { 192, 0, 0, 1 },
57 };
58
59 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_2 = {
60 .family = NET_AF_INET,
61 .pton = true,
62 .ipv4.c_addr = "192.1.0.0",
63 .ipv4.verify.s4_addr = { 192, 1, 0, 0 },
64 };
65
66 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_3 = {
67 .family = NET_AF_INET,
68 .pton = true,
69 .ipv4.c_addr = "192.0.0.0",
70 .ipv4.verify.s4_addr = { 192, 0, 0, 0 },
71 };
72
73 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_4 = {
74 .family = NET_AF_INET,
75 .pton = true,
76 .ipv4.c_addr = "255.255.255.255",
77 .ipv4.verify.s4_addr = { 255, 255, 255, 255 },
78 };
79
80 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_5 = {
81 .family = NET_AF_INET,
82 .pton = true,
83 .ipv4.c_addr = "0.0.0.0",
84 .ipv4.verify.s4_addr = { 0, 0, 0, 0 },
85 };
86
87 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_6 = {
88 .family = NET_AF_INET,
89 .pton = true,
90 .ipv4.c_addr = "0.0.0.1",
91 .ipv4.verify.s4_addr = { 0, 0, 0, 1 },
92 };
93
94 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_7 = {
95 .family = NET_AF_INET,
96 .pton = true,
97 .ipv4.c_addr = "0.0.1.0",
98 .ipv4.verify.s4_addr = { 0, 0, 1, 0 },
99 };
100
101 static ZTEST_DMEM struct net_addr_test_data ipv4_pton_8 = {
102 .family = NET_AF_INET,
103 .pton = true,
104 .ipv4.c_addr = "0.1.0.0",
105 .ipv4.verify.s4_addr = { 0, 1, 0, 0 },
106 };
107
108 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_1 = {
109 .family = NET_AF_INET6,
110 .pton = true,
111 .ipv6.c_addr = "ff08::",
112 .ipv6.verify.s6_addr16 = { net_htons(0xff08), 0, 0, 0, 0, 0, 0, 0 },
113 };
114
115 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_2 = {
116 .family = NET_AF_INET6,
117 .pton = true,
118 .ipv6.c_addr = "::",
119 .ipv6.verify.s6_addr16 = { 0 },
120 };
121
122 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_3 = {
123 .family = NET_AF_INET6,
124 .pton = true,
125 .ipv6.c_addr = "ff08::1",
126 .ipv6.verify.s6_addr16 = { net_htons(0xff08), 0, 0, 0, 0, 0, 0, net_htons(1) },
127 };
128
129 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_4 = {
130 .family = NET_AF_INET6,
131 .pton = true,
132 .ipv6.c_addr = "2001:db8::1",
133 .ipv6.verify.s6_addr16 = { net_htons(0x2001), net_htons(0xdb8),
134 0, 0, 0, 0, 0, net_htons(1) },
135 };
136
137 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_5 = {
138 .family = NET_AF_INET6,
139 .pton = true,
140 .ipv6.c_addr = "2001:db8::2:1",
141 .ipv6.verify.s6_addr16 = { net_htons(0x2001), net_htons(0xdb8),
142 0, 0, 0, 0, net_htons(2), net_htons(1) },
143 };
144
145 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_6 = {
146 .family = NET_AF_INET6,
147 .pton = true,
148 .ipv6.c_addr = "ff08:1122:3344:5566:7788:9900:aabb:ccdd",
149 .ipv6.verify.s6_addr16 = { net_htons(0xff08), net_htons(0x1122),
150 net_htons(0x3344), net_htons(0x5566),
151 net_htons(0x7788), net_htons(0x9900),
152 net_htons(0xaabb), net_htons(0xccdd) },
153 };
154
155 static ZTEST_DMEM struct net_addr_test_data ipv6_pton_7 = {
156 .family = NET_AF_INET6,
157 .pton = true,
158 .ipv6.c_addr = "0:ff08::",
159 .ipv6.verify.s6_addr16 = { 0, net_htons(0xff08), 0, 0, 0, 0, 0, 0 },
160 };
161
162 /* net_addr_ntop test cases */
163 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_1 = {
164 .family = NET_AF_INET,
165 .pton = false,
166 .ipv4.c_verify = "192.0.0.1",
167 .ipv4.addr.s4_addr = { 192, 0, 0, 1 },
168 };
169
170 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_2 = {
171 .family = NET_AF_INET,
172 .pton = false,
173 .ipv4.c_verify = "192.1.0.0",
174 .ipv4.addr.s4_addr = { 192, 1, 0, 0 },
175 };
176
177 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_3 = {
178 .family = NET_AF_INET,
179 .pton = false,
180 .ipv4.c_verify = "192.0.0.0",
181 .ipv4.addr.s4_addr = { 192, 0, 0, 0 },
182 };
183
184 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_4 = {
185 .family = NET_AF_INET,
186 .pton = false,
187 .ipv4.c_verify = "255.255.255.255",
188 .ipv4.addr.s4_addr = { 255, 255, 255, 255 },
189 };
190
191 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_5 = {
192 .family = NET_AF_INET,
193 .pton = false,
194 .ipv4.c_verify = "0.0.0.0",
195 .ipv4.addr.s4_addr = { 0, 0, 0, 0 },
196 };
197
198 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_6 = {
199 .family = NET_AF_INET,
200 .pton = false,
201 .ipv4.c_verify = "0.0.0.1",
202 .ipv4.addr.s4_addr = { 0, 0, 0, 1 },
203 };
204
205 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_7 = {
206 .family = NET_AF_INET,
207 .pton = false,
208 .ipv4.c_verify = "0.0.1.0",
209 .ipv4.addr.s4_addr = { 0, 0, 1, 0 },
210 };
211
212 static ZTEST_DMEM struct net_addr_test_data ipv4_ntop_8 = {
213 .family = NET_AF_INET,
214 .pton = false,
215 .ipv4.c_verify = "0.1.0.0",
216 .ipv4.addr.s4_addr = { 0, 1, 0, 0 },
217 };
218
219 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_1 = {
220 .family = NET_AF_INET6,
221 .pton = false,
222 .ipv6.c_verify = "ff08::",
223 .ipv6.addr.s6_addr16 = { net_htons(0xff08), 0, 0, 0, 0, 0, 0, 0 },
224 };
225
226 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_2 = {
227 .family = NET_AF_INET6,
228 .pton = false,
229 .ipv6.c_verify = "::",
230 .ipv6.addr.s6_addr16 = { 0 },
231 };
232
233 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_3 = {
234 .family = NET_AF_INET6,
235 .pton = false,
236 .ipv6.c_verify = "ff08::1",
237 .ipv6.addr.s6_addr16 = { net_htons(0xff08), 0, 0, 0, 0, 0, 0, net_htons(1) },
238 };
239
240 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_4 = {
241 .family = NET_AF_INET6,
242 .pton = false,
243 .ipv6.c_verify = "2001:db8::1",
244 .ipv6.addr.s6_addr16 = { net_htons(0x2001), net_htons(0xdb8),
245 0, 0, 0, 0, 0, net_htons(1) },
246 };
247
248 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_5 = {
249 .family = NET_AF_INET6,
250 .pton = false,
251 .ipv6.c_verify = "2001:db8::2:1",
252 .ipv6.addr.s6_addr16 = { net_htons(0x2001), net_htons(0xdb8),
253 0, 0, 0, 0, net_htons(2), net_htons(1) },
254 };
255
256 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_6 = {
257 .family = NET_AF_INET6,
258 .pton = false,
259 .ipv6.c_verify = "ff08:1122:3344:5566:7788:9900:aabb:ccdd",
260 .ipv6.addr.s6_addr16 = { net_htons(0xff08), net_htons(0x1122),
261 net_htons(0x3344), net_htons(0x5566),
262 net_htons(0x7788), net_htons(0x9900),
263 net_htons(0xaabb), net_htons(0xccdd) },
264 };
265
266 static ZTEST_DMEM struct net_addr_test_data ipv6_ntop_7 = {
267 .family = NET_AF_INET6,
268 .pton = false,
269 .ipv6.c_verify = "0:ff08::",
270 .ipv6.addr.s6_addr16 = { 0, net_htons(0xff08), 0, 0, 0, 0, 0, 0 },
271 };
272
273 static const struct {
274 const char *name;
275 struct net_addr_test_data *data;
276 } tests[] = {
277 /* IPv4 net_addr_pton */
278 { "test_ipv4_pton_1", &ipv4_pton_1},
279 { "test_ipv4_pton_2", &ipv4_pton_2},
280 { "test_ipv4_pton_3", &ipv4_pton_3},
281 { "test_ipv4_pton_4", &ipv4_pton_4},
282 { "test_ipv4_pton_5", &ipv4_pton_5},
283 { "test_ipv4_pton_6", &ipv4_pton_6},
284 { "test_ipv4_pton_7", &ipv4_pton_7},
285 { "test_ipv4_pton_8", &ipv4_pton_8},
286
287 /* IPv6 net_addr_pton */
288 { "test_ipv6_pton_1", &ipv6_pton_1},
289 { "test_ipv6_pton_2", &ipv6_pton_2},
290 { "test_ipv6_pton_3", &ipv6_pton_3},
291 { "test_ipv6_pton_4", &ipv6_pton_4},
292 { "test_ipv6_pton_5", &ipv6_pton_5},
293 { "test_ipv6_pton_6", &ipv6_pton_6},
294 { "test_ipv6_pton_7", &ipv6_pton_7},
295
296 /* IPv4 net_addr_ntop */
297 { "test_ipv4_ntop_1", &ipv4_ntop_1},
298 { "test_ipv4_ntop_2", &ipv4_ntop_2},
299 { "test_ipv4_ntop_3", &ipv4_ntop_3},
300 { "test_ipv4_ntop_4", &ipv4_ntop_4},
301 { "test_ipv4_ntop_5", &ipv4_ntop_5},
302 { "test_ipv4_ntop_6", &ipv4_ntop_6},
303 { "test_ipv4_ntop_7", &ipv4_ntop_7},
304 { "test_ipv4_ntop_8", &ipv4_ntop_8},
305
306 /* IPv6 net_addr_ntop */
307 { "test_ipv6_ntop_1", &ipv6_ntop_1},
308 { "test_ipv6_ntop_2", &ipv6_ntop_2},
309 { "test_ipv6_ntop_3", &ipv6_ntop_3},
310 { "test_ipv6_ntop_4", &ipv6_ntop_4},
311 { "test_ipv6_ntop_5", &ipv6_ntop_5},
312 { "test_ipv6_ntop_6", &ipv6_ntop_6},
313 { "test_ipv6_ntop_7", &ipv6_ntop_7},
314 };
315
check_net_addr(struct net_addr_test_data * data)316 static bool check_net_addr(struct net_addr_test_data *data)
317 {
318 switch (data->family) {
319 case NET_AF_INET:
320 if (data->pton) {
321 if (net_addr_pton(NET_AF_INET, (char *)data->ipv4.c_addr,
322 &data->ipv4.addr) < 0) {
323 printk("Failed to convert %s\n",
324 data->ipv4.c_addr);
325
326 return false;
327 }
328
329 if (!net_ipv4_addr_cmp(&data->ipv4.addr,
330 &data->ipv4.verify)) {
331 printk("Failed to verify %s\n",
332 data->ipv4.c_addr);
333
334 return false;
335 }
336 } else {
337 if (!net_addr_ntop(NET_AF_INET, &data->ipv4.addr,
338 data->ipv4.c_addr,
339 sizeof(data->ipv4.c_addr))) {
340 printk("Failed to convert %s\n",
341 net_sprint_ipv4_addr(&data->ipv4.addr));
342
343 return false;
344 }
345
346 if (strcmp(data->ipv4.c_addr, data->ipv4.c_verify)) {
347 printk("Failed to verify %s\n",
348 data->ipv4.c_addr);
349 printk("against %s\n",
350 data->ipv4.c_verify);
351
352 return false;
353 }
354 }
355
356 break;
357
358 case NET_AF_INET6:
359 if (data->pton) {
360 if (net_addr_pton(NET_AF_INET6, (char *)data->ipv6.c_addr,
361 &data->ipv6.addr) < 0) {
362 printk("Failed to convert %s\n",
363 data->ipv6.c_addr);
364
365 return false;
366 }
367
368 if (!net_ipv6_addr_cmp(&data->ipv6.addr,
369 &data->ipv6.verify)) {
370 printk("Failed to verify %s\n",
371 net_sprint_ipv6_addr(&data->ipv6.addr));
372 printk("against %s\n",
373 net_sprint_ipv6_addr(
374 &data->ipv6.verify));
375
376 return false;
377 }
378 } else {
379 if (!net_addr_ntop(NET_AF_INET6, &data->ipv6.addr,
380 data->ipv6.c_addr,
381 sizeof(data->ipv6.c_addr))) {
382 printk("Failed to convert %s\n",
383 net_sprint_ipv6_addr(&data->ipv6.addr));
384
385 return false;
386 }
387
388 if (strcmp(data->ipv6.c_addr, data->ipv6.c_verify)) {
389 printk("Failed to verify %s\n",
390 data->ipv6.c_addr);
391 printk("against %s\n",
392 data->ipv6.c_verify);
393
394 return false;
395 }
396
397 }
398
399 break;
400 }
401
402 return true;
403 }
404
ZTEST(test_utils_fn,test_net_addr)405 ZTEST(test_utils_fn, test_net_addr)
406 {
407 int count, pass;
408
409 for (count = 0, pass = 0; count < ARRAY_SIZE(tests); count++) {
410 TC_PRINT("Running test: %s: ", tests[count].name);
411
412 if (check_net_addr(tests[count].data)) {
413 TC_PRINT("passed\n");
414 pass++;
415 } else {
416 TC_PRINT("failed\n");
417 }
418 }
419
420 zassert_equal(pass, ARRAY_SIZE(tests), "check_net_addr error");
421 }
422
ZTEST(test_utils_fn,test_addr_parse)423 ZTEST(test_utils_fn, test_addr_parse)
424 {
425 struct net_sockaddr addr;
426 bool ret;
427 int i;
428 #if defined(CONFIG_NET_IPV4)
429 static const struct {
430 const char *address;
431 int len;
432 struct net_sockaddr_in result;
433 bool verdict;
434 } parse_ipv4_entries[] = {
435 {
436 .address = "192.0.2.1:80",
437 .len = sizeof("192.0.2.1:80") - 1,
438 .result = {
439 .sin_family = NET_AF_INET,
440 .sin_port = net_htons(80),
441 .sin_addr = {
442 .s4_addr[0] = 192,
443 .s4_addr[1] = 0,
444 .s4_addr[2] = 2,
445 .s4_addr[3] = 1
446 }
447 },
448 .verdict = true
449 },
450 {
451 .address = "192.0.2.2",
452 .len = sizeof("192.0.2.2") - 1,
453 .result = {
454 .sin_family = NET_AF_INET,
455 .sin_port = 0,
456 .sin_addr = {
457 .s4_addr[0] = 192,
458 .s4_addr[1] = 0,
459 .s4_addr[2] = 2,
460 .s4_addr[3] = 2
461 }
462 },
463 .verdict = true
464 },
465 {
466 .address = "192.0.2.3/foobar",
467 .len = sizeof("192.0.2.3/foobar") - 8,
468 .result = {
469 .sin_family = NET_AF_INET,
470 .sin_port = 0,
471 .sin_addr = {
472 .s4_addr[0] = 192,
473 .s4_addr[1] = 0,
474 .s4_addr[2] = 2,
475 .s4_addr[3] = 3
476 }
477 },
478 .verdict = true
479 },
480 {
481 .address = "255.255.255.255:0",
482 .len = sizeof("255.255.255.255:0") - 1,
483 .result = {
484 .sin_family = NET_AF_INET,
485 .sin_port = 0,
486 .sin_addr = {
487 .s4_addr[0] = 255,
488 .s4_addr[1] = 255,
489 .s4_addr[2] = 255,
490 .s4_addr[3] = 255
491 }
492 },
493 .verdict = true
494 },
495 {
496 .address = "127.0.0.42:65535",
497 .len = sizeof("127.0.0.42:65535") - 1,
498 .result = {
499 .sin_family = NET_AF_INET,
500 .sin_port = net_htons(65535),
501 .sin_addr = {
502 .s4_addr[0] = 127,
503 .s4_addr[1] = 0,
504 .s4_addr[2] = 0,
505 .s4_addr[3] = 42
506 }
507 },
508 .verdict = true
509 },
510 {
511 .address = "192.0.2.3:80/foobar",
512 .len = sizeof("192.0.2.3:80/foobar") - 1,
513 .verdict = false
514 },
515 {
516 .address = "192.168.1.1:65536/foobar",
517 .len = sizeof("192.168.1.1:65536") - 1,
518 .verdict = false
519 },
520 {
521 .address = "192.0.2.3:80/foobar",
522 .len = sizeof("192.0.2.3") - 1,
523 .result = {
524 .sin_family = NET_AF_INET,
525 .sin_port = 0,
526 .sin_addr = {
527 .s4_addr[0] = 192,
528 .s4_addr[1] = 0,
529 .s4_addr[2] = 2,
530 .s4_addr[3] = 3
531 }
532 },
533 .verdict = true
534 },
535 {
536 .address = "192.0.2.3:80/foobar",
537 .len = sizeof("192.0.2.3:80") - 1,
538 .result = {
539 .sin_family = NET_AF_INET,
540 .sin_port = net_htons(80),
541 .sin_addr = {
542 .s4_addr[0] = 192,
543 .s4_addr[1] = 0,
544 .s4_addr[2] = 2,
545 .s4_addr[3] = 3
546 }
547 },
548 .verdict = true
549 },
550 {
551 .address = "192.0.2.3/foobar",
552 .len = sizeof("192.0.2.3/foobar") - 1,
553 .verdict = false
554 },
555 {
556 .address = "192.0.2.3:80:80",
557 .len = sizeof("192.0.2.3:80:80") - 1,
558 .verdict = false
559 },
560 {
561 .address = "192.0.2.1:80000",
562 .len = sizeof("192.0.2.1:80000") - 1,
563 .verdict = false
564 },
565 {
566 .address = "192.168.0.1",
567 .len = sizeof("192.168.0.1:80000") - 1,
568 .result = {
569 .sin_family = NET_AF_INET,
570 .sin_port = 0,
571 .sin_addr = {
572 .s4_addr[0] = 192,
573 .s4_addr[1] = 168,
574 .s4_addr[2] = 0,
575 .s4_addr[3] = 1
576 }
577 },
578 .verdict = true
579 },
580 {
581 .address = "a.b.c.d",
582 .verdict = false
583 },
584 };
585 #endif
586 #if defined(CONFIG_NET_IPV6)
587 static const struct {
588 const char *address;
589 int len;
590 struct net_sockaddr_in6 result;
591 bool verdict;
592 } parse_ipv6_entries[] = {
593 {
594 .address = "[2001:db8::2]:80",
595 .len = sizeof("[2001:db8::2]:80") - 1,
596 .result = {
597 .sin6_family = NET_AF_INET6,
598 .sin6_port = net_htons(80),
599 .sin6_addr = {
600 .s6_addr16[0] = net_ntohs(0x2001),
601 .s6_addr16[1] = net_ntohs(0xdb8),
602 .s6_addr16[3] = 0,
603 .s6_addr16[4] = 0,
604 .s6_addr16[5] = 0,
605 .s6_addr16[6] = 0,
606 .s6_addr16[7] = net_ntohs(2)
607 }
608 },
609 .verdict = true
610 },
611 {
612 .address = "[2001:db8::a]/barfoo",
613 .len = sizeof("[2001:db8::a]/barfoo") - 8,
614 .result = {
615 .sin6_family = NET_AF_INET6,
616 .sin6_port = 0,
617 .sin6_addr = {
618 .s6_addr16[0] = net_ntohs(0x2001),
619 .s6_addr16[1] = net_ntohs(0xdb8),
620 .s6_addr16[3] = 0,
621 .s6_addr16[4] = 0,
622 .s6_addr16[5] = 0,
623 .s6_addr16[6] = 0,
624 .s6_addr16[7] = net_ntohs(0xa)
625 }
626 },
627 .verdict = true
628 },
629 {
630 .address = "[2001:db8::a]",
631 .len = sizeof("[2001:db8::a]") - 1,
632 .result = {
633 .sin6_family = NET_AF_INET6,
634 .sin6_port = 0,
635 .sin6_addr = {
636 .s6_addr16[0] = net_ntohs(0x2001),
637 .s6_addr16[1] = net_ntohs(0xdb8),
638 .s6_addr16[3] = 0,
639 .s6_addr16[4] = 0,
640 .s6_addr16[5] = 0,
641 .s6_addr16[6] = 0,
642 .s6_addr16[7] = net_ntohs(0xa)
643 }
644 },
645 .verdict = true
646 },
647 {
648 .address = "[2001:db8:3:4:5:6:7:8]:65535",
649 .len = sizeof("[2001:db8:3:4:5:6:7:8]:65535") - 1,
650 .result = {
651 .sin6_family = NET_AF_INET6,
652 .sin6_port = 65535,
653 .sin6_addr = {
654 .s6_addr16[0] = net_ntohs(0x2001),
655 .s6_addr16[1] = net_ntohs(0xdb8),
656 .s6_addr16[2] = net_ntohs(3),
657 .s6_addr16[3] = net_ntohs(4),
658 .s6_addr16[4] = net_ntohs(5),
659 .s6_addr16[5] = net_ntohs(6),
660 .s6_addr16[6] = net_ntohs(7),
661 .s6_addr16[7] = net_ntohs(8),
662 }
663 },
664 .verdict = true
665 },
666 {
667 .address = "[::]:0",
668 .len = sizeof("[::]:0") - 1,
669 .result = {
670 .sin6_family = NET_AF_INET6,
671 .sin6_port = 0,
672 .sin6_addr = {
673 .s6_addr16[0] = 0,
674 .s6_addr16[1] = 0,
675 .s6_addr16[2] = 0,
676 .s6_addr16[3] = 0,
677 .s6_addr16[4] = 0,
678 .s6_addr16[5] = 0,
679 .s6_addr16[6] = 0,
680 .s6_addr16[7] = 0,
681 }
682 },
683 .verdict = true
684 },
685 {
686 .address = "2001:db8::42",
687 .len = sizeof("2001:db8::42") - 1,
688 .result = {
689 .sin6_family = NET_AF_INET6,
690 .sin6_port = 0,
691 .sin6_addr = {
692 .s6_addr16[0] = net_ntohs(0x2001),
693 .s6_addr16[1] = net_ntohs(0xdb8),
694 .s6_addr16[3] = 0,
695 .s6_addr16[4] = 0,
696 .s6_addr16[5] = 0,
697 .s6_addr16[6] = 0,
698 .s6_addr16[7] = net_ntohs(0x42)
699 }
700 },
701 .verdict = true
702 },
703 {
704 .address = "[2001:db8::192.0.2.1]:80000",
705 .len = sizeof("[2001:db8::192.0.2.1]:80000") - 1,
706 .verdict = false
707 },
708 {
709 .address = "[2001:db8::1]:80",
710 .len = sizeof("[2001:db8::1") - 1,
711 .verdict = false
712 },
713 {
714 .address = "[2001:db8::1]:65536",
715 .len = sizeof("[2001:db8::1]:65536") - 1,
716 .verdict = false
717 },
718 {
719 .address = "[2001:db8::1]:80",
720 .len = sizeof("2001:db8::1") - 1,
721 .verdict = false
722 },
723 {
724 .address = "[2001:db8::1]:a",
725 .len = sizeof("[2001:db8::1]:a") - 1,
726 .verdict = false
727 },
728 {
729 .address = "[2001:db8::1]:10-12",
730 .len = sizeof("[2001:db8::1]:10-12") - 1,
731 .verdict = false
732 },
733 {
734 .address = "[2001:db8::]:80/url/continues",
735 .len = sizeof("[2001:db8::]") - 1,
736 .result = {
737 .sin6_family = NET_AF_INET6,
738 .sin6_port = 0,
739 .sin6_addr = {
740 .s6_addr16[0] = net_ntohs(0x2001),
741 .s6_addr16[1] = net_ntohs(0xdb8),
742 .s6_addr16[3] = 0,
743 .s6_addr16[4] = 0,
744 .s6_addr16[5] = 0,
745 .s6_addr16[6] = 0,
746 .s6_addr16[7] = 0,
747 }
748 },
749 .verdict = true
750 },
751 {
752 .address = "[2001:db8::200]:080",
753 .len = sizeof("[2001:db8:433:2]:80000") - 1,
754 .result = {
755 .sin6_family = NET_AF_INET6,
756 .sin6_port = net_htons(80),
757 .sin6_addr = {
758 .s6_addr16[0] = net_ntohs(0x2001),
759 .s6_addr16[1] = net_ntohs(0xdb8),
760 .s6_addr16[3] = 0,
761 .s6_addr16[4] = 0,
762 .s6_addr16[5] = 0,
763 .s6_addr16[6] = 0,
764 .s6_addr16[7] = net_ntohs(0x200)
765 }
766 },
767 .verdict = true
768 },
769 {
770 .address = "[2001:db8::]:8080/another/url",
771 .len = sizeof("[2001:db8::]:8080/another/url") - 1,
772 .verdict = false
773 },
774 {
775 .address = "[2001:db8::1",
776 .len = sizeof("[2001:db8::1") - 1,
777 .verdict = false
778 },
779 {
780 .address = "[2001:db8::1]:-1",
781 .len = sizeof("[2001:db8::1]:-1") - 1,
782 .verdict = false
783 },
784 {
785 /* Valid although user probably did not mean this */
786 .address = "2001:db8::1:80",
787 .len = sizeof("2001:db8::1:80") - 1,
788 .result = {
789 .sin6_family = NET_AF_INET6,
790 .sin6_port = 0,
791 .sin6_addr = {
792 .s6_addr16[0] = net_ntohs(0x2001),
793 .s6_addr16[1] = net_ntohs(0xdb8),
794 .s6_addr16[3] = 0,
795 .s6_addr16[4] = 0,
796 .s6_addr16[5] = 0,
797 .s6_addr16[6] = net_ntohs(0x01),
798 .s6_addr16[7] = net_ntohs(0x80)
799 }
800 },
801 .verdict = true
802 },
803 };
804 #endif
805
806 #if defined(CONFIG_NET_IPV4)
807 for (i = 0; i < ARRAY_SIZE(parse_ipv4_entries) - 1; i++) {
808 (void)memset(&addr, 0, sizeof(addr));
809
810 ret = net_ipaddr_parse(
811 parse_ipv4_entries[i].address,
812 parse_ipv4_entries[i].len,
813 &addr);
814 if (ret != parse_ipv4_entries[i].verdict) {
815 printk("IPv4 entry [%d] \"%s\" failed\n", i,
816 parse_ipv4_entries[i].address);
817 zassert_true(false, "failure");
818 }
819
820 if (ret == true) {
821 zassert_true(
822 net_ipv4_addr_cmp(
823 &net_sin(&addr)->sin_addr,
824 &parse_ipv4_entries[i].result.sin_addr) ==
825 parse_ipv4_entries[i].verdict);
826 zassert_true(net_sin(&addr)->sin_port ==
827 parse_ipv4_entries[i].result.sin_port,
828 "IPv4 port");
829 zassert_true(net_sin(&addr)->sin_family ==
830 parse_ipv4_entries[i].result.sin_family,
831 "IPv4 family");
832 }
833 }
834 #endif
835 #if defined(CONFIG_NET_IPV6)
836 for (i = 0; i < ARRAY_SIZE(parse_ipv6_entries) - 1; i++) {
837 (void)memset(&addr, 0, sizeof(addr));
838
839 ret = net_ipaddr_parse(
840 parse_ipv6_entries[i].address,
841 parse_ipv6_entries[i].len,
842 &addr);
843 if (ret != parse_ipv6_entries[i].verdict) {
844 printk("IPv6 entry [%d] \"%s\" failed\n", i,
845 parse_ipv6_entries[i].address);
846 zassert_true(false, "failure");
847 }
848
849 if (ret == true) {
850 zassert_true(
851 net_ipv6_addr_cmp(
852 &net_sin6(&addr)->sin6_addr,
853 &parse_ipv6_entries[i].result.sin6_addr) ==
854 parse_ipv6_entries[i].verdict);
855 zassert_true(net_sin6(&addr)->sin6_port ==
856 parse_ipv6_entries[i].result.sin6_port,
857 "IPv6 port");
858 zassert_true(net_sin6(&addr)->sin6_family ==
859 parse_ipv6_entries[i].result.sin6_family,
860 "IPv6 family");
861 }
862 }
863 #endif
864 }
865
866 #if defined(CONFIG_NET_IPV4) && defined(CONFIG_NET_IPV6)
check_ipaddr(const char * addresses)867 static const char *check_ipaddr(const char *addresses)
868 {
869 do {
870 char addr_str[NET_IPV6_ADDR_LEN + 4 + 1];
871 char expecting[NET_IPV6_ADDR_LEN + 4 + 1];
872 const char *orig = addresses;
873 struct net_sockaddr_storage addr;
874 struct net_sockaddr_storage mask;
875 uint8_t mask_len;
876 int ret;
877
878 memset(&addr, 0, sizeof(addr));
879 mask_len = 0;
880
881 memset(addr_str, 0, sizeof(addr_str));
882 memset(expecting, 0, sizeof(expecting));
883
884 addresses = net_ipaddr_parse_mask(addresses, strlen(addresses),
885 (struct net_sockaddr *)&addr, &mask_len);
886 zassert_not_null(addresses, "Invalid parse, expecting \"%s\"", orig);
887
888 strncpy(expecting, orig,
889 *addresses == '\0' ? strlen(orig) : addresses - orig - 1);
890
891 (void)net_addr_ntop(addr.ss_family,
892 &net_sin((struct net_sockaddr *)&addr)->sin_addr,
893 addr_str, sizeof(addr_str));
894
895 ret = net_mask_len_to_netmask(addr.ss_family, mask_len,
896 (struct net_sockaddr *)&mask);
897 zassert_equal(ret, 0, "Failed to convert mask %d", mask_len);
898
899 ret = net_netmask_to_mask_len(addr.ss_family,
900 (struct net_sockaddr *)&mask,
901 &mask_len);
902 zassert_equal(ret, 0, "Failed to convert mask %s",
903 net_sprint_addr(addr.ss_family,
904 (const void *)&net_sin(
905 ((struct net_sockaddr *)&mask))->sin_addr));
906
907 if (net_sin((struct net_sockaddr *)&mask)->sin_addr.s_addr != 0) {
908 int addr_len = strlen(addr_str);
909
910 snprintk(addr_str + addr_len,
911 sizeof(addr_str) - addr_len,
912 "/%d", mask_len);
913 }
914
915 zassert_mem_equal(addr_str, expecting,
916 *addresses == '\0' ? strlen(orig) : addresses - orig - 1,
917 "Address mismatch, expecing %s, got %s (len %d)\n",
918 expecting, addr_str, addresses - orig - 1);
919 } while (addresses != NULL && *addresses != '\0');
920
921 return addresses;
922 }
923 #endif /* CONFIG_NET_IPV4 && CONFIG_NET_IPV6 */
924
ZTEST(test_utils_fn,test_addr_parse_mask)925 ZTEST(test_utils_fn, test_addr_parse_mask)
926 {
927 struct net_sockaddr addr;
928 uint8_t mask_len;
929 const char *next;
930 int i;
931 #if defined(CONFIG_NET_IPV4)
932 static const struct {
933 const char *address;
934 int len;
935 struct net_sockaddr_in result;
936 uint8_t mask_len;
937 const char *verdict;
938 } parse_ipv4_entries[] = {
939 {
940 .address = "192.0.2.1:80",
941 .len = sizeof("192.0.2.1:80") - 1,
942 .verdict = NULL,
943 },
944 {
945 .address = "192.0.2.2",
946 .len = sizeof("192.0.2.2") - 1,
947 .result = {
948 .sin_family = NET_AF_INET,
949 .sin_addr = {
950 .s4_addr[0] = 192,
951 .s4_addr[1] = 0,
952 .s4_addr[2] = 2,
953 .s4_addr[3] = 2
954 }
955 },
956 .verdict = "",
957 },
958 {
959 .address = "192.0.2.3/foobar",
960 .len = sizeof("192.0.2.3/foobar") - 1,
961 .verdict = NULL,
962 },
963 {
964 .address = "127.0.0.42,1.2.3.4",
965 .len = sizeof("127.0.0.42,1.2.3.4") - 1,
966 .result = {
967 .sin_family = NET_AF_INET,
968 .sin_addr = {
969 .s4_addr[0] = 127,
970 .s4_addr[1] = 0,
971 .s4_addr[2] = 0,
972 .s4_addr[3] = 42
973 }
974 },
975 .mask_len = 32,
976 .verdict = &"127.0.0.42,1.2.3.4"[11],
977 },
978 {
979 .address = "127.0.0.42/8,1.2.3.4",
980 .len = sizeof("127.0.0.42/8,1.2.3.4") - 1,
981 .result = {
982 .sin_family = NET_AF_INET,
983 .sin_addr = {
984 .s4_addr[0] = 127,
985 .s4_addr[1] = 0,
986 .s4_addr[2] = 0,
987 .s4_addr[3] = 42
988 }
989 },
990 .mask_len = 8,
991 .verdict = &"127.0.0.42/8,1.2.3.4"[13],
992 },
993 {
994 .address = "192.0.2.3:80/foobar",
995 .len = sizeof("192.0.2.3:80/foobar") - 1,
996 .verdict = false
997 },
998 {
999 .address = "192.168.1.1:65536/foobar",
1000 .len = sizeof("192.168.1.1:65536") - 1,
1001 .verdict = false
1002 },
1003 {
1004 .address = "192.0.2.3:80/foobar",
1005 .len = sizeof("192.0.2.3") - 1,
1006 .result = {
1007 .sin_family = NET_AF_INET,
1008 .sin_port = 0,
1009 .sin_addr = {
1010 .s4_addr[0] = 192,
1011 .s4_addr[1] = 0,
1012 .s4_addr[2] = 2,
1013 .s4_addr[3] = 3
1014 }
1015 },
1016 .verdict = "",
1017 },
1018 {
1019 .address = "192.0.2.3:80/foobar",
1020 .len = sizeof("192.0.2.3:80") - 1,
1021 .verdict = NULL,
1022 },
1023 {
1024 .address = "a.b.c.d",
1025 .verdict = false
1026 },
1027 };
1028 #endif
1029 #if defined(CONFIG_NET_IPV6)
1030 static const struct {
1031 const char *address;
1032 int len;
1033 struct net_sockaddr_in6 result;
1034 uint8_t mask_len;
1035 const char *verdict;
1036 } parse_ipv6_entries[] = {
1037 {
1038 .address = "2001:db8::2",
1039 .len = sizeof("2001:db8::2") - 1,
1040 .result = {
1041 .sin6_family = NET_AF_INET6,
1042 .sin6_addr = {
1043 .s6_addr16[0] = net_ntohs(0x2001),
1044 .s6_addr16[1] = net_ntohs(0xdb8),
1045 .s6_addr16[3] = 0,
1046 .s6_addr16[4] = 0,
1047 .s6_addr16[5] = 0,
1048 .s6_addr16[6] = 0,
1049 .s6_addr16[7] = net_ntohs(2)
1050 }
1051 },
1052 .verdict = "",
1053 },
1054 {
1055 .address = "2001:db8::a/barfoo",
1056 .len = sizeof("2001:db8::a/barfoo") - 8,
1057 .result = {
1058 .sin6_family = NET_AF_INET6,
1059 .sin6_port = 0,
1060 .sin6_addr = {
1061 .s6_addr16[0] = net_ntohs(0x2001),
1062 .s6_addr16[1] = net_ntohs(0xdb8),
1063 .s6_addr16[3] = 0,
1064 .s6_addr16[4] = 0,
1065 .s6_addr16[5] = 0,
1066 .s6_addr16[6] = 0,
1067 .s6_addr16[7] = net_ntohs(0xa)
1068 }
1069 },
1070 .verdict = "",
1071 },
1072 {
1073 .address = "2001:db8::a",
1074 .len = sizeof("2001:db8::a") - 1,
1075 .result = {
1076 .sin6_family = NET_AF_INET6,
1077 .sin6_port = 0,
1078 .sin6_addr = {
1079 .s6_addr16[0] = net_ntohs(0x2001),
1080 .s6_addr16[1] = net_ntohs(0xdb8),
1081 .s6_addr16[3] = 0,
1082 .s6_addr16[4] = 0,
1083 .s6_addr16[5] = 0,
1084 .s6_addr16[6] = 0,
1085 .s6_addr16[7] = net_ntohs(0xa)
1086 }
1087 },
1088 .verdict = "",
1089 },
1090 {
1091 .address = "[2001:db8:3:4:5:6:7:8]:65535",
1092 .len = sizeof("[2001:db8:3:4:5:6:7:8]:65535") - 1,
1093 .verdict = NULL,
1094 },
1095 {
1096 .address = "[::]:0",
1097 .len = sizeof("[::]:0") - 1,
1098 .verdict = NULL,
1099 },
1100 {
1101 .address = "2001:db8::42",
1102 .len = sizeof("2001:db8::42") - 1,
1103 .result = {
1104 .sin6_family = NET_AF_INET6,
1105 .sin6_port = 0,
1106 .sin6_addr = {
1107 .s6_addr16[0] = net_ntohs(0x2001),
1108 .s6_addr16[1] = net_ntohs(0xdb8),
1109 .s6_addr16[3] = 0,
1110 .s6_addr16[4] = 0,
1111 .s6_addr16[5] = 0,
1112 .s6_addr16[6] = 0,
1113 .s6_addr16[7] = net_ntohs(0x42)
1114 }
1115 },
1116 .verdict = "",
1117 },
1118 {
1119 .address = "[2001:db8::192.0.2.1]:80000",
1120 .len = sizeof("[2001:db8::192.0.2.1]:80000") - 1,
1121 .verdict = NULL,
1122 },
1123 {
1124 .address = "[2001:db8::1]:80",
1125 .len = sizeof("[2001:db8::1") - 1,
1126 .verdict = NULL,
1127 },
1128 {
1129 .address = "[2001:db8::1]:65536",
1130 .len = sizeof("[2001:db8::1]:65536") - 1,
1131 .verdict = NULL,
1132 },
1133 {
1134 .address = "[2001:db8::1]:80",
1135 .len = sizeof("2001:db8::1") - 1,
1136 .verdict = NULL,
1137 },
1138 {
1139 .address = "[2001:db8::1]:a",
1140 .len = sizeof("[2001:db8::1]:a") - 1,
1141 .verdict = NULL,
1142 },
1143 {
1144 .address = "[2001:db8::1]:10-12",
1145 .len = sizeof("[2001:db8::1]:10-12") - 1,
1146 .verdict = NULL,
1147 },
1148 {
1149 .address = "[2001:db8::]:80/url/continues",
1150 .len = sizeof("[2001:db8::]") - 1,
1151 .verdict = NULL,
1152 },
1153 {
1154 .address = "[2001:db8::200]:080",
1155 .len = sizeof("[2001:db8:433:2]:80000") - 1,
1156 .verdict = NULL,
1157 },
1158 {
1159 .address = "[2001:db8::]:8080/another/url",
1160 .len = sizeof("[2001:db8::]:8080/another/url") - 1,
1161 .verdict = NULL,
1162 },
1163 {
1164 .address = "[2001:db8::1",
1165 .len = sizeof("[2001:db8::1") - 1,
1166 .verdict = NULL,
1167 },
1168 {
1169 .address = "[2001:db8::1]:-1",
1170 .len = sizeof("[2001:db8::1]:-1") - 1,
1171 .verdict = NULL,
1172 },
1173 {
1174 /* Valid although user probably did not mean this */
1175 .address = "2001:db8::1:80",
1176 .len = sizeof("2001:db8::1:80") - 1,
1177 .result = {
1178 .sin6_family = NET_AF_INET6,
1179 .sin6_addr = {
1180 .s6_addr16[0] = net_ntohs(0x2001),
1181 .s6_addr16[1] = net_ntohs(0xdb8),
1182 .s6_addr16[3] = 0,
1183 .s6_addr16[4] = 0,
1184 .s6_addr16[5] = 0,
1185 .s6_addr16[6] = net_ntohs(0x01),
1186 .s6_addr16[7] = net_ntohs(0x80)
1187 }
1188 },
1189 .verdict = "",
1190 },
1191 {
1192 .address = "2001:db8::1/64,2001:db8::2",
1193 .len = sizeof("2001:db8::1/64,2001:db8::2") - 1,
1194 .result = {
1195 .sin6_family = NET_AF_INET6,
1196 .sin6_addr = {
1197 .s6_addr16[0] = net_ntohs(0x2001),
1198 .s6_addr16[1] = net_ntohs(0xdb8),
1199 .s6_addr16[2] = 0,
1200 .s6_addr16[3] = 0,
1201 .s6_addr16[4] = 0,
1202 .s6_addr16[5] = 0,
1203 .s6_addr16[6] = 0,
1204 .s6_addr16[7] = net_ntohs(0x01)
1205 }
1206 },
1207 .mask_len = 64,
1208 .verdict = &"2001:db8::1/64,2001:db8::2"[14],
1209 },
1210 };
1211 #endif
1212
1213 #if defined(CONFIG_NET_IPV4)
1214 for (i = 0; i < ARRAY_SIZE(parse_ipv4_entries) - 1; i++) {
1215 (void)memset(&addr, 0, sizeof(addr));
1216 mask_len = 0;
1217
1218 next = net_ipaddr_parse_mask(
1219 parse_ipv4_entries[i].address,
1220 parse_ipv4_entries[i].len,
1221 &addr, &mask_len);
1222 if (next != parse_ipv4_entries[i].verdict) {
1223 printk("IPv4 entry [%d] \"%s\" failed\n", i,
1224 parse_ipv4_entries[i].address);
1225 printk("Points to \"%s\" but should point to \"%s\"\n",
1226 next == NULL ? "NULL" : next,
1227 parse_ipv4_entries[i].verdict == NULL ?
1228 "NULL" : parse_ipv4_entries[i].verdict);
1229 zassert_true(false, "failure");
1230 }
1231
1232 if (next != NULL && *next == '\0') {
1233 zassert_true(
1234 net_ipv4_addr_cmp(
1235 &net_sin(&addr)->sin_addr,
1236 &parse_ipv4_entries[i].result.sin_addr));
1237 zassert_true(net_sin(&addr)->sin_port == 0,
1238 "IPv4 port");
1239 zassert_true(net_sin(&addr)->sin_family ==
1240 parse_ipv4_entries[i].result.sin_family,
1241 "IPv4 family");
1242 }
1243 }
1244 #endif
1245 #if defined(CONFIG_NET_IPV6)
1246 for (i = 0; i < ARRAY_SIZE(parse_ipv6_entries) - 1; i++) {
1247 (void)memset(&addr, 0, sizeof(addr));
1248 mask_len = 0;
1249
1250 next = net_ipaddr_parse_mask(
1251 parse_ipv6_entries[i].address,
1252 parse_ipv6_entries[i].len,
1253 &addr, &mask_len);
1254 if (next != parse_ipv6_entries[i].verdict) {
1255 printk("IPv6 entry [%d] \"%s\" failed\n", i,
1256 parse_ipv6_entries[i].address);
1257 zassert_true(false, "failure");
1258 }
1259
1260 if (next != NULL && *next == '\0') {
1261 zassert_true(
1262 net_ipv6_addr_cmp(
1263 &net_sin6(&addr)->sin6_addr,
1264 &parse_ipv6_entries[i].result.sin6_addr));
1265 zassert_true(net_sin6(&addr)->sin6_port == 0,
1266 "IPv6 port");
1267 zassert_true(net_sin6(&addr)->sin6_family ==
1268 parse_ipv6_entries[i].result.sin6_family,
1269 "IPv6 family");
1270 }
1271 }
1272 #endif
1273
1274 #if defined(CONFIG_NET_IPV4) && defined(CONFIG_NET_IPV6)
1275 static const char * const addresses[] = {
1276 "2001:db8::1/64,192.0.2.1,2001:db8::2,192.0.2.2/24",
1277 "2001:db8::1/64 192.0.2.1 2001:db8::2 192.0.2.2/24",
1278 "2001:db8::1/64 192.0.2.1,2001:db8::2 192.0.2.2/24",
1279 NULL
1280 };
1281
1282 i = 0;
1283
1284 while (addresses[i] != NULL) {
1285 next = check_ipaddr(addresses[i]);
1286 zassert_true(next != NULL && *next == '\0',
1287 "Invalid parse, expecting \"\", got %p\n", next);
1288 i++;
1289 }
1290 #endif /* CONFIG_NET_IPV4 && CONFIG_NET_IPV6 */
1291 }
1292
calc_chksum_ref(uint16_t sum,const uint8_t * data,size_t len)1293 static uint16_t calc_chksum_ref(uint16_t sum, const uint8_t *data, size_t len)
1294 {
1295 const uint8_t *end;
1296 uint16_t tmp;
1297
1298 end = data + len - 1;
1299
1300 while (data < end) {
1301 tmp = (data[0] << 8) + data[1];
1302 sum += tmp;
1303 if (sum < tmp) {
1304 sum++;
1305 }
1306
1307 data += 2;
1308 }
1309
1310 if (data == end) {
1311 tmp = data[0] << 8;
1312 sum += tmp;
1313 if (sum < tmp) {
1314 sum++;
1315 }
1316 }
1317
1318 return sum;
1319 }
1320
1321 #define CHECKSUM_TEST_LENGTH 1500
1322
1323 uint8_t testdata[CHECKSUM_TEST_LENGTH];
1324
ZTEST(test_utils_fn,test_ip_checksum)1325 ZTEST(test_utils_fn, test_ip_checksum)
1326 {
1327 uint16_t sum_got;
1328 uint16_t sum_exp;
1329
1330 /* Simple test dataset */
1331 for (int i = 0; i < CHECKSUM_TEST_LENGTH; i++) {
1332 testdata[i] = (uint8_t)i;
1333 }
1334
1335 for (int i = 1; i <= CHECKSUM_TEST_LENGTH; i++) {
1336 sum_got = calc_chksum_ref(i ^ 0x1f13, testdata, i);
1337 sum_exp = calc_chksum(i ^ 0x1f13, testdata, i);
1338
1339 zassert_equal(sum_got, sum_exp,
1340 "Mismatch between reference and calculated checksum 1\n");
1341 }
1342
1343 /* Create a different patten in the data */
1344 for (int i = 0; i < CHECKSUM_TEST_LENGTH; i++) {
1345 testdata[i] = (uint8_t)(i + 13) * 17;
1346 }
1347
1348 for (int i = 1; i <= CHECKSUM_TEST_LENGTH; i++) {
1349 sum_got = calc_chksum_ref(i ^ 0x1f13, testdata + (CHECKSUM_TEST_LENGTH - i), i);
1350 sum_exp = calc_chksum(i ^ 0x1f13, testdata + (CHECKSUM_TEST_LENGTH - i), i);
1351
1352 zassert_equal(sum_got, sum_exp,
1353 "Mismatch between reference and calculated checksum 2\n");
1354 }
1355
1356 /* Work across all possible combination so offset and length */
1357 for (int offset = 0; offset < 7; offset++) {
1358 for (int length = 1; length < 32; length++) {
1359 sum_got = calc_chksum_ref(offset ^ 0x8e72, testdata + offset, length);
1360 sum_exp = calc_chksum(offset ^ 0x8e72, testdata + offset, length);
1361
1362 zassert_equal(sum_got, sum_exp,
1363 "Mismatch between reference and calculated checksum 3\n");
1364 }
1365 }
1366 }
1367
1368 /* Verify that the net_pkt pointer to the received link layer address
1369 * is correct.
1370 */
ZTEST(test_utils_fn,test_linkaddr_handling)1371 ZTEST(test_utils_fn, test_linkaddr_handling)
1372 {
1373 /* A simple Ethernet frame with IPv4 and UDP headers */
1374 static const uint8_t udp[] = {
1375 0x18, 0xfd, 0x74, 0x09, 0xcb, 0x62, 0xac, 0x91, /* 0000 */
1376 0xa1, 0x8f, 0x9d, 0xf8, 0x08, 0x00, 0x45, 0x00, /* 0008 */
1377 0x00, 0x4c, 0x48, 0x8e, 0x00, 0x00, 0x40, 0x11, /* 0010 */
1378 0x57, 0x34, 0xc0, 0xa8, 0x58, 0x29, 0xc1, 0xe5, /* 0018 */
1379 0x00, 0x28, 0xba, 0xf0, 0x00, 0x35, 0x00, 0x38, /* 0020 */
1380 0xdb, 0x28,
1381 };
1382
1383 /* Create net_pkt from the above data, then check the link layer
1384 * addresses are properly set even if we pull the data like how
1385 * the network stack would do in ethernet.c
1386 */
1387 const uint8_t *dst = &udp[0];
1388 const uint8_t *src = &udp[NET_ETH_ADDR_LEN];
1389 uint8_t hdr_len = sizeof(struct net_eth_hdr);
1390 struct net_linkaddr *lladdr;
1391 struct net_eth_hdr *hdr;
1392 struct net_pkt *pkt, *pkt2;
1393 int ret;
1394
1395 pkt = net_pkt_rx_alloc_with_buffer(net_if_get_default(),
1396 sizeof(udp), NET_AF_UNSPEC,
1397 0, K_NO_WAIT);
1398 zassert_not_null(pkt, "Cannot allocate pkt");
1399
1400 ret = net_pkt_write(pkt, udp, sizeof(udp));
1401 zassert_equal(ret, 0, "Cannot write data to pkt");
1402
1403 hdr = NET_ETH_HDR(pkt);
1404
1405 /* Set the pointers to ll src and dst addresses */
1406 lladdr = net_pkt_lladdr_src(pkt);
1407 memcpy(lladdr->addr, hdr->src.addr, sizeof(struct net_eth_addr));
1408 lladdr->len = sizeof(struct net_eth_addr);
1409 lladdr->type = NET_LINK_ETHERNET;
1410
1411 lladdr = net_pkt_lladdr_dst(pkt);
1412 memcpy(lladdr->addr, hdr->dst.addr, sizeof(struct net_eth_addr));
1413 lladdr->len = sizeof(struct net_eth_addr);
1414 lladdr->type = NET_LINK_ETHERNET;
1415
1416 zassert_mem_equal(net_pkt_lladdr_src(pkt)->addr,
1417 src, NET_ETH_ADDR_LEN,
1418 "Source address mismatch");
1419 zassert_mem_equal(net_pkt_lladdr_dst(pkt)->addr,
1420 dst, NET_ETH_ADDR_LEN,
1421 "Destination address mismatch");
1422
1423 pkt2 = net_pkt_clone(pkt, K_NO_WAIT);
1424 zassert_not_null(pkt2, "Cannot clone pkt");
1425
1426 /* Make sure we still point to the correct addresses after cloning */
1427 zassert_mem_equal(net_pkt_lladdr_src(pkt2)->addr,
1428 src, NET_ETH_ADDR_LEN,
1429 "Source address mismatch");
1430 zassert_mem_equal(net_pkt_lladdr_dst(pkt2)->addr,
1431 dst, NET_ETH_ADDR_LEN,
1432 "Destination address mismatch");
1433
1434 net_pkt_unref(pkt2);
1435
1436 /* Get rid of the Ethernet header. */
1437 net_buf_pull(pkt->frags, hdr_len);
1438
1439 /* Make sure we still point to the correct addresses after pulling
1440 * the Ethernet header.
1441 */
1442 zassert_mem_equal(net_pkt_lladdr_src(pkt)->addr,
1443 src, NET_ETH_ADDR_LEN,
1444 "Source address mismatch");
1445 zassert_mem_equal(net_pkt_lladdr_dst(pkt)->addr,
1446 dst, NET_ETH_ADDR_LEN,
1447 "Destination address mismatch");
1448
1449 /* Clone the packet and check that the link layer addresses are
1450 * still correct.
1451 */
1452
1453 pkt2 = net_pkt_clone(pkt, K_NO_WAIT);
1454 zassert_not_null(pkt2, "Cannot clone pkt");
1455
1456 zassert_not_equal(net_pkt_lladdr_src(pkt2)->addr,
1457 net_pkt_lladdr_src(pkt)->addr,
1458 "Source address should not be the same");
1459
1460 zassert_mem_equal(net_pkt_lladdr_src(pkt2)->addr,
1461 src, NET_ETH_ADDR_LEN,
1462 "Source address mismatch");
1463 zassert_mem_equal(net_pkt_lladdr_dst(pkt2)->addr,
1464 dst, NET_ETH_ADDR_LEN,
1465 "Destination address mismatch");
1466
1467 net_pkt_unref(pkt);
1468 net_pkt_unref(pkt2);
1469 }
1470
1471 ZTEST_SUITE(test_utils_fn, NULL, NULL, NULL, NULL, NULL);
1472
