1 /*
2 * Copyright (c) 2017 Linaro Limited
3 * Copyright (c) 2021 Nordic Semiconductor
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8 #include <zephyr/logging/log.h>
9 LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
10
11 #include <stdio.h>
12 #include <zephyr/sys/mutex.h>
13 #include <zephyr/ztest_assert.h>
14
15 #include <zephyr/net/socket.h>
16 #include <zephyr/net/ethernet.h>
17 #include <zephyr/net/net_mgmt.h>
18 #include <zephyr/net/net_event.h>
19
20 #include "ipv6.h"
21 #include "net_private.h"
22 #include "../../socket_helpers.h"
23
24 #if defined(CONFIG_NET_SOCKETS_LOG_LEVEL_DBG)
25 #define DBG(fmt, ...) printk(fmt, ##__VA_ARGS__)
26 #else
27 #define DBG(fmt, ...)
28 #endif
29
30 #define BUF_AND_SIZE(buf) buf, sizeof(buf) - 1
31 #define STRLEN(buf) (sizeof(buf) - 1)
32
33 #define TEST_STR_SMALL "test"
34 /* More than 256 bytes, to use >1 net_buf. */
35 #define TEST_STR2 \
36 "The Zephyr Project, a Linux Foundation hosted Collaboration " \
37 "Project, is an open source collaborative effort uniting leaders " \
38 "from across the industry to build a best-in-breed small, scalable, " \
39 "real-time operating system (RTOS) optimized for resource-" \
40 "constrained devices, across multiple architectures."
41 /* More than available TX buffers */
42 static const char test_str_all_tx_bufs[] =
43 #include <string_all_tx_bufs.inc>
44 "!"
45 ;
46
47 #define MY_IPV4_ADDR "127.0.0.1"
48 #define MY_IPV6_ADDR "::1"
49 #define MY_MCAST_IPV4_ADDR "224.0.0.1"
50 #define MY_MCAST_IPV6_ADDR "ff01::1"
51
52 #define ANY_PORT 0
53 #define SERVER_PORT 4242
54 #define CLIENT_PORT 9898
55
56 static ZTEST_BMEM char rx_buf[NET_ETH_MTU + 1];
57
58 /* Common routine to communicate packets over pair of sockets. */
comm_sendto_recvfrom(int client_sock,struct sockaddr * client_addr,socklen_t client_addrlen,int server_sock,struct sockaddr * server_addr,socklen_t server_addrlen)59 static void comm_sendto_recvfrom(int client_sock,
60 struct sockaddr *client_addr,
61 socklen_t client_addrlen,
62 int server_sock,
63 struct sockaddr *server_addr,
64 socklen_t server_addrlen)
65 {
66 int avail;
67 ssize_t sent = 0;
68 ssize_t recved = 0;
69 struct sockaddr addr;
70 socklen_t addrlen;
71 struct sockaddr addr2;
72 socklen_t addrlen2;
73
74 zassert_not_null(client_addr, "null client addr");
75 zassert_not_null(server_addr, "null server addr");
76
77 /*
78 * Test client -> server sending
79 */
80
81 sent = zsock_sendto(client_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL),
82 0, server_addr, server_addrlen);
83 zassert_equal(sent, strlen(TEST_STR_SMALL), "sendto failed");
84
85 k_msleep(100);
86
87 avail = 42;
88 zassert_ok(zsock_ioctl(server_sock, ZFD_IOCTL_FIONREAD, &avail));
89 zassert_equal(avail, strlen(TEST_STR_SMALL));
90
91 /* Test recvfrom(MSG_PEEK) */
92 addrlen = sizeof(addr);
93 clear_buf(rx_buf);
94 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
95 ZSOCK_MSG_PEEK, &addr, &addrlen);
96 zassert_true(recved >= 0, "recvfrom fail");
97 zassert_equal(recved, strlen(TEST_STR_SMALL),
98 "unexpected received bytes");
99 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
100 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
101
102 /* Test normal recvfrom() */
103 addrlen = sizeof(addr);
104 clear_buf(rx_buf);
105 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
106 0, &addr, &addrlen);
107 zassert_true(recved >= 0, "recvfrom fail");
108 zassert_equal(recved, strlen(TEST_STR_SMALL),
109 "unexpected received bytes");
110 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
111 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
112
113 /* Check the client port */
114 if (net_sin(client_addr)->sin_port != ANY_PORT) {
115 zassert_equal(net_sin(client_addr)->sin_port,
116 net_sin(&addr)->sin_port,
117 "unexpected client port");
118 }
119
120 /*
121 * Test server -> client sending
122 */
123
124 sent = zsock_sendto(server_sock, TEST_STR2, sizeof(TEST_STR2) - 1,
125 0, &addr, addrlen);
126 zassert_equal(sent, STRLEN(TEST_STR2), "sendto failed");
127
128 /* Test normal recvfrom() */
129 addrlen2 = sizeof(addr);
130 clear_buf(rx_buf);
131 recved = zsock_recvfrom(client_sock, rx_buf, sizeof(rx_buf),
132 0, &addr2, &addrlen2);
133 zassert_true(recved >= 0, "recvfrom fail");
134 zassert_equal(recved, STRLEN(TEST_STR2),
135 "unexpected received bytes");
136 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR2), "wrong data");
137 zassert_equal(addrlen2, server_addrlen, "unexpected addrlen");
138
139 /* Check the server port */
140 zassert_equal(net_sin(server_addr)->sin_port,
141 net_sin(&addr2)->sin_port,
142 "unexpected server port");
143
144 /* Test that unleft leftover data from datagram is discarded. */
145
146 /* Send 2 datagrams */
147 sent = zsock_sendto(server_sock, TEST_STR2, sizeof(TEST_STR2) - 1,
148 0, &addr, addrlen);
149 zassert_equal(sent, STRLEN(TEST_STR2), "sendto failed");
150 sent = zsock_sendto(server_sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
151 0, &addr, addrlen);
152 zassert_equal(sent, STRLEN(TEST_STR_SMALL), "sendto failed");
153
154 /* Receive just beginning of 1st datagram */
155 addrlen2 = sizeof(addr);
156 clear_buf(rx_buf);
157 recved = zsock_recvfrom(client_sock, rx_buf, 16, 0, &addr2, &addrlen2);
158 zassert_true(recved == 16, "recvfrom fail");
159 zassert_mem_equal(rx_buf, TEST_STR2, 16, "wrong data");
160
161 /* Make sure that now we receive 2nd datagram */
162 addrlen2 = sizeof(addr);
163 clear_buf(rx_buf);
164 recved = zsock_recvfrom(client_sock, rx_buf, 16, 0, &addr2, &addrlen2);
165 zassert_true(recved == STRLEN(TEST_STR_SMALL), "recvfrom fail");
166 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
167 }
168
ZTEST(net_socket_udp,test_02_v4_sendto_recvfrom)169 ZTEST(net_socket_udp, test_02_v4_sendto_recvfrom)
170 {
171 int rv;
172 int client_sock;
173 int server_sock;
174 struct sockaddr_in client_addr;
175 struct sockaddr_in server_addr;
176
177 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
178 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
179
180 rv = zsock_bind(server_sock,
181 (struct sockaddr *)&server_addr,
182 sizeof(server_addr));
183 zassert_equal(rv, 0, "bind failed");
184
185 comm_sendto_recvfrom(client_sock,
186 (struct sockaddr *)&client_addr,
187 sizeof(client_addr),
188 server_sock,
189 (struct sockaddr *)&server_addr,
190 sizeof(server_addr));
191
192 rv = zsock_close(client_sock);
193 zassert_equal(rv, 0, "close failed");
194 rv = zsock_close(server_sock);
195 zassert_equal(rv, 0, "close failed");
196 }
197
ZTEST(net_socket_udp,test_03_v6_sendto_recvfrom)198 ZTEST(net_socket_udp, test_03_v6_sendto_recvfrom)
199 {
200 int rv;
201 int client_sock;
202 int server_sock;
203 struct sockaddr_in6 client_addr;
204 struct sockaddr_in6 server_addr;
205
206 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
207 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
208
209 rv = zsock_bind(server_sock,
210 (struct sockaddr *)&server_addr, sizeof(server_addr));
211 zassert_equal(rv, 0, "bind failed");
212
213 comm_sendto_recvfrom(client_sock,
214 (struct sockaddr *)&client_addr,
215 sizeof(client_addr),
216 server_sock,
217 (struct sockaddr *)&server_addr,
218 sizeof(server_addr));
219
220 rv = zsock_close(client_sock);
221 zassert_equal(rv, 0, "close failed");
222 rv = zsock_close(server_sock);
223 zassert_equal(rv, 0, "close failed");
224 }
225
ZTEST(net_socket_udp,test_04_v4_bind_sendto)226 ZTEST(net_socket_udp, test_04_v4_bind_sendto)
227 {
228 int rv;
229 int client_sock;
230 int server_sock;
231 struct sockaddr_in client_addr;
232 struct sockaddr_in server_addr;
233
234 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
235 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
236
237 rv = zsock_bind(client_sock,
238 (struct sockaddr *)&client_addr, sizeof(client_addr));
239 zassert_equal(rv, 0, "bind failed");
240
241 rv = zsock_bind(server_sock,
242 (struct sockaddr *)&server_addr, sizeof(server_addr));
243 zassert_equal(rv, 0, "bind failed");
244
245 comm_sendto_recvfrom(client_sock,
246 (struct sockaddr *)&client_addr,
247 sizeof(client_addr),
248 server_sock,
249 (struct sockaddr *)&server_addr,
250 sizeof(server_addr));
251
252 rv = zsock_close(client_sock);
253 zassert_equal(rv, 0, "close failed");
254 rv = zsock_close(server_sock);
255 zassert_equal(rv, 0, "close failed");
256 }
257
ZTEST(net_socket_udp,test_05_v6_bind_sendto)258 ZTEST(net_socket_udp, test_05_v6_bind_sendto)
259 {
260 int rv;
261 int client_sock;
262 int server_sock;
263 struct sockaddr_in6 client_addr;
264 struct sockaddr_in6 server_addr;
265
266 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
267 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
268
269 rv = zsock_bind(client_sock,
270 (struct sockaddr *)&client_addr, sizeof(client_addr));
271 zassert_equal(rv, 0, "bind failed");
272
273 rv = zsock_bind(server_sock,
274 (struct sockaddr *)&server_addr, sizeof(server_addr));
275 zassert_equal(rv, 0, "bind failed");
276
277 comm_sendto_recvfrom(client_sock,
278 (struct sockaddr *)&client_addr,
279 sizeof(client_addr),
280 server_sock,
281 (struct sockaddr *)&server_addr,
282 sizeof(server_addr));
283
284 rv = zsock_close(client_sock);
285 zassert_equal(rv, 0, "close failed");
286 rv = zsock_close(server_sock);
287 zassert_equal(rv, 0, "close failed");
288 }
289
ZTEST(net_socket_udp,test_01_send_recv_2_sock)290 ZTEST(net_socket_udp, test_01_send_recv_2_sock)
291 {
292 int sock1, sock2;
293 struct sockaddr_in bind_addr, conn_addr;
294 char buf[10];
295 int len, rv;
296
297 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr);
298 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock2, &conn_addr);
299
300 rv = zsock_bind(sock1, (struct sockaddr *)&bind_addr, sizeof(bind_addr));
301 zassert_equal(rv, 0, "bind failed");
302
303 rv = zsock_connect(sock2, (struct sockaddr *)&conn_addr, sizeof(conn_addr));
304 zassert_equal(rv, 0, "connect failed");
305
306 len = zsock_send(sock2, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0);
307 zassert_equal(len, STRLEN(TEST_STR_SMALL), "invalid send len");
308
309 clear_buf(buf);
310 len = zsock_recv(sock1, buf, sizeof(buf), ZSOCK_MSG_PEEK);
311 zassert_equal(len, STRLEN(TEST_STR_SMALL), "Invalid recv len");
312 zassert_mem_equal(buf, BUF_AND_SIZE(TEST_STR_SMALL), "Wrong data");
313
314 clear_buf(buf);
315 len = zsock_recv(sock1, buf, sizeof(buf), 0);
316 zassert_equal(len, STRLEN(TEST_STR_SMALL), "Invalid recv len");
317 zassert_mem_equal(buf, BUF_AND_SIZE(TEST_STR_SMALL), "Wrong data");
318
319 rv = zsock_close(sock1);
320 zassert_equal(rv, 0, "close failed");
321 rv = zsock_close(sock2);
322 zassert_equal(rv, 0, "close failed");
323 }
324
ZTEST(net_socket_udp,test_07_so_priority)325 ZTEST(net_socket_udp, test_07_so_priority)
326 {
327 struct sockaddr_in bind_addr4;
328 struct sockaddr_in6 bind_addr6;
329 int sock1, sock2, rv;
330 uint8_t optval;
331
332 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
333 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
334
335 rv = zsock_bind(sock1, (struct sockaddr *)&bind_addr4, sizeof(bind_addr4));
336 zassert_equal(rv, 0, "bind failed");
337
338 rv = zsock_bind(sock2, (struct sockaddr *)&bind_addr6, sizeof(bind_addr6));
339 zassert_equal(rv, 0, "bind failed");
340
341 optval = 2;
342 rv = zsock_setsockopt(sock1, SOL_SOCKET, SO_PRIORITY, &optval,
343 sizeof(optval));
344 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
345
346 optval = 6;
347 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_PRIORITY, &optval,
348 sizeof(optval));
349 zassert_equal(rv, 0, "setsockopt failed");
350
351 rv = zsock_close(sock1);
352 zassert_equal(rv, 0, "close failed");
353 rv = zsock_close(sock2);
354 zassert_equal(rv, 0, "close failed");
355 }
356
comm_sendmsg_recvfrom(int client_sock,struct sockaddr * client_addr,socklen_t client_addrlen,const struct msghdr * client_msg,int server_sock,struct sockaddr * server_addr,socklen_t server_addrlen)357 static void comm_sendmsg_recvfrom(int client_sock,
358 struct sockaddr *client_addr,
359 socklen_t client_addrlen,
360 const struct msghdr *client_msg,
361 int server_sock,
362 struct sockaddr *server_addr,
363 socklen_t server_addrlen)
364 {
365 ssize_t sent;
366 ssize_t recved;
367 struct sockaddr addr;
368 socklen_t addrlen;
369 int len, i;
370
371 zassert_not_null(client_addr, "null client addr");
372 zassert_not_null(server_addr, "null server addr");
373
374 /*
375 * Test client -> server sending
376 */
377
378 sent = zsock_sendmsg(client_sock, client_msg, 0);
379 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
380
381 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
382 len += client_msg->msg_iov[i].iov_len;
383 }
384
385 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
386
387 /* Test recvfrom(MSG_PEEK) */
388 addrlen = sizeof(addr);
389 clear_buf(rx_buf);
390 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
391 ZSOCK_MSG_PEEK, &addr, &addrlen);
392 zassert_true(recved >= 0, "recvfrom fail");
393 zassert_equal(recved, strlen(TEST_STR_SMALL),
394 "unexpected received bytes");
395 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
396 sent, recved);
397
398 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL),
399 "wrong data (%s)", rx_buf);
400 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
401
402 /* Test normal recvfrom() */
403 addrlen = sizeof(addr);
404 clear_buf(rx_buf);
405 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
406 0, &addr, &addrlen);
407 zassert_true(recved >= 0, "recvfrom fail");
408 zassert_equal(recved, strlen(TEST_STR_SMALL),
409 "unexpected received bytes");
410 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
411 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
412
413 /* Check the client port */
414 if (net_sin(client_addr)->sin_port != ANY_PORT) {
415 zassert_equal(net_sin(client_addr)->sin_port,
416 net_sin(&addr)->sin_port,
417 "unexpected client port");
418 }
419 }
420
ZTEST_USER(net_socket_udp,test_12_v4_sendmsg_recvfrom)421 ZTEST_USER(net_socket_udp, test_12_v4_sendmsg_recvfrom)
422 {
423 int rv;
424 int client_sock;
425 int server_sock;
426 struct sockaddr_in client_addr;
427 struct sockaddr_in server_addr;
428 struct msghdr msg;
429 struct cmsghdr *cmsg;
430 struct iovec io_vector[1];
431 union {
432 struct cmsghdr hdr;
433 unsigned char buf[CMSG_SPACE(sizeof(int))];
434 } cmsgbuf;
435
436 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
437 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
438
439 rv = zsock_bind(server_sock,
440 (struct sockaddr *)&server_addr,
441 sizeof(server_addr));
442 zassert_equal(rv, 0, "server bind failed");
443
444 rv = zsock_bind(client_sock,
445 (struct sockaddr *)&client_addr,
446 sizeof(client_addr));
447 zassert_equal(rv, 0, "client bind failed");
448
449 io_vector[0].iov_base = TEST_STR_SMALL;
450 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
451
452 memset(&msg, 0, sizeof(msg));
453 msg.msg_control = &cmsgbuf.buf;
454 msg.msg_controllen = sizeof(cmsgbuf.buf);
455 msg.msg_iov = io_vector;
456 msg.msg_iovlen = 1;
457 msg.msg_name = &server_addr;
458 msg.msg_namelen = sizeof(server_addr);
459
460 cmsg = CMSG_FIRSTHDR(&msg);
461 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
462 cmsg->cmsg_level = SOL_SOCKET;
463 cmsg->cmsg_type = 1122;
464 *(int *)CMSG_DATA(cmsg) = 42;
465
466 comm_sendmsg_recvfrom(client_sock,
467 (struct sockaddr *)&client_addr,
468 sizeof(client_addr),
469 &msg,
470 server_sock,
471 (struct sockaddr *)&server_addr,
472 sizeof(server_addr));
473
474 rv = zsock_close(client_sock);
475 zassert_equal(rv, 0, "close failed");
476 rv = zsock_close(server_sock);
477 zassert_equal(rv, 0, "close failed");
478 }
479
ZTEST_USER(net_socket_udp,test_13_v4_sendmsg_recvfrom_no_aux_data)480 ZTEST_USER(net_socket_udp, test_13_v4_sendmsg_recvfrom_no_aux_data)
481 {
482 int rv;
483 int client_sock;
484 int server_sock;
485 struct sockaddr_in client_addr;
486 struct sockaddr_in server_addr;
487 struct msghdr msg;
488 struct iovec io_vector[1];
489
490 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
491 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
492
493 rv = zsock_bind(server_sock,
494 (struct sockaddr *)&server_addr,
495 sizeof(server_addr));
496 zassert_equal(rv, 0, "server bind failed");
497
498 rv = zsock_bind(client_sock,
499 (struct sockaddr *)&client_addr,
500 sizeof(client_addr));
501 zassert_equal(rv, 0, "client bind failed");
502
503 io_vector[0].iov_base = TEST_STR_SMALL;
504 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
505
506 memset(&msg, 0, sizeof(msg));
507 msg.msg_iov = io_vector;
508 msg.msg_iovlen = 1;
509 msg.msg_name = &server_addr;
510 msg.msg_namelen = sizeof(server_addr);
511
512 comm_sendmsg_recvfrom(client_sock,
513 (struct sockaddr *)&client_addr,
514 sizeof(client_addr),
515 &msg,
516 server_sock,
517 (struct sockaddr *)&server_addr,
518 sizeof(server_addr));
519
520 rv = zsock_close(client_sock);
521 zassert_equal(rv, 0, "close failed");
522 rv = zsock_close(server_sock);
523 zassert_equal(rv, 0, "close failed");
524 }
525
ZTEST_USER(net_socket_udp,test_14_v6_sendmsg_recvfrom)526 ZTEST_USER(net_socket_udp, test_14_v6_sendmsg_recvfrom)
527 {
528 int rv;
529 int client_sock;
530 int server_sock;
531 struct sockaddr_in6 client_addr;
532 struct sockaddr_in6 server_addr;
533 struct msghdr msg;
534 struct cmsghdr *cmsg;
535 struct iovec io_vector[1];
536 union {
537 struct cmsghdr hdr;
538 unsigned char buf[CMSG_SPACE(sizeof(int))];
539 } cmsgbuf;
540
541 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
542 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
543
544 rv = zsock_bind(server_sock,
545 (struct sockaddr *)&server_addr, sizeof(server_addr));
546 zassert_equal(rv, 0, "server bind failed");
547
548 rv = zsock_bind(client_sock,
549 (struct sockaddr *)&client_addr,
550 sizeof(client_addr));
551 zassert_equal(rv, 0, "client bind failed");
552
553 io_vector[0].iov_base = TEST_STR_SMALL;
554 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
555
556 memset(&msg, 0, sizeof(msg));
557 msg.msg_control = &cmsgbuf.buf;
558 msg.msg_controllen = sizeof(cmsgbuf.buf);
559 msg.msg_iov = io_vector;
560 msg.msg_iovlen = 1;
561 msg.msg_name = &server_addr;
562 msg.msg_namelen = sizeof(server_addr);
563
564 cmsg = CMSG_FIRSTHDR(&msg);
565 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
566 cmsg->cmsg_level = SOL_SOCKET;
567 cmsg->cmsg_type = 1122;
568 *(int *)CMSG_DATA(cmsg) = 42;
569
570 comm_sendmsg_recvfrom(client_sock,
571 (struct sockaddr *)&client_addr,
572 sizeof(client_addr),
573 &msg,
574 server_sock,
575 (struct sockaddr *)&server_addr,
576 sizeof(server_addr));
577
578 rv = zsock_close(client_sock);
579 zassert_equal(rv, 0, "close failed");
580 rv = zsock_close(server_sock);
581 zassert_equal(rv, 0, "close failed");
582 }
583
ZTEST_USER(net_socket_udp,test_15_v4_sendmsg_recvfrom_connected)584 ZTEST_USER(net_socket_udp, test_15_v4_sendmsg_recvfrom_connected)
585 {
586 int rv;
587 int client_sock;
588 int server_sock;
589 struct sockaddr_in client_addr;
590 struct sockaddr_in server_addr;
591 struct msghdr msg;
592 struct cmsghdr *cmsg;
593 struct iovec io_vector[1];
594 union {
595 struct cmsghdr hdr;
596 unsigned char buf[CMSG_SPACE(sizeof(int))];
597 } cmsgbuf;
598
599 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
600 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
601
602 rv = zsock_bind(server_sock,
603 (struct sockaddr *)&server_addr,
604 sizeof(server_addr));
605 zassert_equal(rv, 0, "server bind failed");
606
607 rv = zsock_bind(client_sock,
608 (struct sockaddr *)&client_addr,
609 sizeof(client_addr));
610 zassert_equal(rv, 0, "client bind failed");
611
612 rv = zsock_connect(client_sock, (struct sockaddr *)&server_addr,
613 sizeof(server_addr));
614 zassert_equal(rv, 0, "connect failed");
615
616 io_vector[0].iov_base = TEST_STR_SMALL;
617 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
618
619 memset(&msg, 0, sizeof(msg));
620 msg.msg_control = &cmsgbuf.buf;
621 msg.msg_controllen = sizeof(cmsgbuf.buf);
622 msg.msg_iov = io_vector;
623 msg.msg_iovlen = 1;
624
625 cmsg = CMSG_FIRSTHDR(&msg);
626 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
627 cmsg->cmsg_level = SOL_SOCKET;
628 cmsg->cmsg_type = 1122;
629 *(int *)CMSG_DATA(cmsg) = 42;
630
631 comm_sendmsg_recvfrom(client_sock,
632 (struct sockaddr *)&client_addr,
633 sizeof(client_addr),
634 &msg,
635 server_sock,
636 (struct sockaddr *)&server_addr,
637 sizeof(server_addr));
638
639 rv = zsock_close(client_sock);
640 zassert_equal(rv, 0, "close failed");
641 rv = zsock_close(server_sock);
642 zassert_equal(rv, 0, "close failed");
643 }
644
ZTEST_USER(net_socket_udp,test_06_v6_sendmsg_recvfrom_connected)645 ZTEST_USER(net_socket_udp, test_06_v6_sendmsg_recvfrom_connected)
646 {
647 int rv;
648 int client_sock;
649 int server_sock;
650 struct sockaddr_in6 client_addr;
651 struct sockaddr_in6 server_addr;
652 struct msghdr msg;
653 struct cmsghdr *cmsg;
654 struct iovec io_vector[1];
655 union {
656 struct cmsghdr hdr;
657 unsigned char buf[CMSG_SPACE(sizeof(int))];
658 } cmsgbuf;
659
660 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
661 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
662
663 rv = zsock_bind(server_sock,
664 (struct sockaddr *)&server_addr, sizeof(server_addr));
665 zassert_equal(rv, 0, "server bind failed");
666
667 rv = zsock_bind(client_sock,
668 (struct sockaddr *)&client_addr,
669 sizeof(client_addr));
670 zassert_equal(rv, 0, "client bind failed");
671
672 rv = zsock_connect(client_sock, (struct sockaddr *)&server_addr,
673 sizeof(server_addr));
674 zassert_equal(rv, 0, "connect failed");
675
676 io_vector[0].iov_base = TEST_STR_SMALL;
677 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
678
679 memset(&msg, 0, sizeof(msg));
680 msg.msg_control = &cmsgbuf.buf;
681 msg.msg_controllen = sizeof(cmsgbuf.buf);
682 msg.msg_iov = io_vector;
683 msg.msg_iovlen = 1;
684
685 cmsg = CMSG_FIRSTHDR(&msg);
686 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
687 cmsg->cmsg_level = SOL_SOCKET;
688 cmsg->cmsg_type = 1122;
689 *(int *)CMSG_DATA(cmsg) = 42;
690
691 comm_sendmsg_recvfrom(client_sock,
692 (struct sockaddr *)&client_addr,
693 sizeof(client_addr),
694 &msg,
695 server_sock,
696 (struct sockaddr *)&server_addr,
697 sizeof(server_addr));
698
699 rv = zsock_close(client_sock);
700 zassert_equal(rv, 0, "close failed");
701 rv = zsock_close(server_sock);
702 zassert_equal(rv, 0, "close failed");
703 }
704
ZTEST(net_socket_udp,test_06_so_type)705 ZTEST(net_socket_udp, test_06_so_type)
706 {
707 struct sockaddr_in bind_addr4;
708 struct sockaddr_in6 bind_addr6;
709 int sock1, sock2, rv;
710 int optval;
711 socklen_t optsize = sizeof(optval);
712
713 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
714 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
715
716 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_TYPE, &optval, &optsize);
717 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
718 zassert_equal(optval, SOCK_DGRAM, "getsockopt got invalid type");
719 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
720
721 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_TYPE, &optval, &optsize);
722 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
723 zassert_equal(optval, SOCK_DGRAM, "getsockopt got invalid type");
724 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
725
726 rv = zsock_close(sock1);
727 zassert_equal(rv, 0, "close failed");
728 rv = zsock_close(sock2);
729 zassert_equal(rv, 0, "close failed");
730 }
731
ZTEST(net_socket_udp,test_08_so_txtime)732 ZTEST(net_socket_udp, test_08_so_txtime)
733 {
734 struct sockaddr_in bind_addr4;
735 struct sockaddr_in6 bind_addr6;
736 int sock1, sock2, rv;
737 socklen_t optlen;
738 int optval;
739
740 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
741 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
742
743 rv = zsock_bind(sock1, (struct sockaddr *)&bind_addr4, sizeof(bind_addr4));
744 zassert_equal(rv, 0, "bind failed");
745
746 rv = zsock_bind(sock2, (struct sockaddr *)&bind_addr6, sizeof(bind_addr6));
747 zassert_equal(rv, 0, "bind failed");
748
749 optval = true;
750 rv = zsock_setsockopt(sock1, SOL_SOCKET, SO_TXTIME, &optval,
751 sizeof(optval));
752 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
753
754 optval = false;
755 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_TXTIME, &optval,
756 sizeof(optval));
757 zassert_equal(rv, 0, "setsockopt failed");
758
759 optlen = sizeof(optval);
760 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_TXTIME, &optval, &optlen);
761 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
762 zassert_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
763 optlen, sizeof(optval));
764 zassert_equal(optval, true, "getsockopt txtime");
765
766 optlen = sizeof(optval);
767 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_TXTIME, &optval, &optlen);
768 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
769 zassert_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
770 optlen, sizeof(optval));
771 zassert_equal(optval, false, "getsockopt txtime");
772
773 rv = zsock_close(sock1);
774 zassert_equal(rv, 0, "close failed");
775 rv = zsock_close(sock2);
776 zassert_equal(rv, 0, "close failed");
777 }
778
ZTEST(net_socket_udp,test_09_so_rcvtimeo)779 ZTEST(net_socket_udp, test_09_so_rcvtimeo)
780 {
781 struct sockaddr_in bind_addr4;
782 struct sockaddr_in6 bind_addr6;
783 int sock1, sock2, rv;
784 ssize_t recved = 0;
785 struct sockaddr addr;
786 socklen_t addrlen;
787 uint32_t start_time, time_diff;
788
789 struct timeval optval = {
790 .tv_sec = 0,
791 .tv_usec = 300000,
792 };
793
794 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
795 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
796
797 rv = zsock_bind(sock1, (struct sockaddr *)&bind_addr4, sizeof(bind_addr4));
798 zassert_equal(rv, 0, "bind failed");
799
800 rv = zsock_bind(sock2, (struct sockaddr *)&bind_addr6, sizeof(bind_addr6));
801 zassert_equal(rv, 0, "bind failed");
802
803 rv = zsock_setsockopt(sock1, SOL_SOCKET, SO_RCVTIMEO, &optval,
804 sizeof(optval));
805 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
806
807 optval.tv_usec = 400000;
808 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO, &optval,
809 sizeof(optval));
810 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
811
812 addrlen = sizeof(addr);
813 clear_buf(rx_buf);
814 start_time = k_uptime_get_32();
815 recved = zsock_recvfrom(sock1, rx_buf, sizeof(rx_buf),
816 0, &addr, &addrlen);
817 time_diff = k_uptime_get_32() - start_time;
818
819 zassert_equal(recved, -1, "Unexpected return code");
820 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
821 zassert_true(time_diff >= 300, "Expected timeout after 300ms but "
822 "was %dms", time_diff);
823
824 start_time = k_uptime_get_32();
825 recved = zsock_recvfrom(sock2, rx_buf, sizeof(rx_buf),
826 0, &addr, &addrlen);
827 time_diff = k_uptime_get_32() - start_time;
828
829 zassert_equal(recved, -1, "Unexpected return code");
830 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
831 zassert_true(time_diff >= 400, "Expected timeout after 400ms but "
832 "was %dms", time_diff);
833
834 rv = zsock_close(sock1);
835 zassert_equal(rv, 0, "close failed");
836 rv = zsock_close(sock2);
837 zassert_equal(rv, 0, "close failed");
838 }
839
ZTEST(net_socket_udp,test_10_so_sndtimeo)840 ZTEST(net_socket_udp, test_10_so_sndtimeo)
841 {
842 struct sockaddr_in bind_addr4;
843 struct sockaddr_in6 bind_addr6;
844 int sock1, sock2, rv;
845
846 struct timeval optval = {
847 .tv_sec = 2,
848 .tv_usec = 500000,
849 };
850
851 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
852 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
853
854 rv = zsock_bind(sock1, (struct sockaddr *)&bind_addr4, sizeof(bind_addr4));
855 zassert_equal(rv, 0, "bind failed");
856
857 rv = zsock_bind(sock2, (struct sockaddr *)&bind_addr6, sizeof(bind_addr6));
858 zassert_equal(rv, 0, "bind failed");
859
860 rv = zsock_setsockopt(sock1, SOL_SOCKET, SO_SNDTIMEO, &optval,
861 sizeof(optval));
862 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
863
864 optval.tv_usec = 0;
865 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO, &optval,
866 sizeof(optval));
867 zassert_equal(rv, 0, "setsockopt failed");
868
869 rv = zsock_close(sock1);
870 zassert_equal(rv, 0, "close failed");
871 rv = zsock_close(sock2);
872 zassert_equal(rv, 0, "close failed");
873 }
874
ZTEST(net_socket_udp,test_11_so_protocol)875 ZTEST(net_socket_udp, test_11_so_protocol)
876 {
877 struct sockaddr_in bind_addr4;
878 struct sockaddr_in6 bind_addr6;
879 int sock1, sock2, rv;
880 int optval;
881 socklen_t optsize = sizeof(optval);
882
883 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
884 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
885
886 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_PROTOCOL, &optval, &optsize);
887 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
888 zassert_equal(optval, IPPROTO_UDP, "getsockopt got invalid protocol");
889 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
890
891 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_PROTOCOL, &optval, &optsize);
892 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
893 zassert_equal(optval, IPPROTO_UDP, "getsockopt got invalid protocol");
894 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
895
896 rv = zsock_close(sock1);
897 zassert_equal(rv, 0, "close failed");
898 rv = zsock_close(sock2);
899 zassert_equal(rv, 0, "close failed");
900 }
901
comm_sendmsg_with_txtime(int client_sock,struct sockaddr * client_addr,socklen_t client_addrlen,const struct msghdr * client_msg)902 static void comm_sendmsg_with_txtime(int client_sock,
903 struct sockaddr *client_addr,
904 socklen_t client_addrlen,
905 const struct msghdr *client_msg)
906 {
907 ssize_t sent;
908 int len, i;
909
910 zassert_not_null(client_addr, "null client addr");
911
912 /*
913 * Test client -> server sending
914 */
915
916 sent = zsock_sendmsg(client_sock, client_msg, 0);
917 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
918
919 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
920 len += client_msg->msg_iov[i].iov_len;
921 }
922
923 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
924 }
925
926 /* In order to verify that the network device driver is able to receive
927 * the TXTIME option, create a separate network device and catch the packets
928 * we are sending.
929 */
930 struct eth_fake_context {
931 struct net_if *iface;
932 uint8_t mac_address[6];
933 };
934
935 static struct eth_fake_context eth_fake_data;
936 static ZTEST_BMEM struct sockaddr_in6 udp_server_addr;
937
938 /* The semaphore is there to wait the data to be received. */
939 static ZTEST_BMEM SYS_MUTEX_DEFINE(wait_data);
940
941 static struct net_if *eth_iface;
942 static struct net_if *lo0;
943 static ZTEST_BMEM bool test_started;
944 static ZTEST_BMEM bool test_failed;
945 static struct in6_addr my_addr1 = { { { 0x20, 0x01, 0x0d, 0xb8, 1, 0, 0, 0,
946 0, 0, 0, 0, 0, 0, 0, 0x1 } } };
947 static struct in_addr my_addr2 = { { { 192, 0, 2, 2 } } };
948 static struct in6_addr my_addr3 = { { { 0x20, 0x01, 0x0d, 0xb8, 1, 0, 0, 0,
949 0, 0, 0, 0, 0, 0, 0, 0x3 } } };
950 static struct in6_addr my_mcast_addr1 = { { { 0xff, 0x01, 0, 0, 0, 0, 0, 0,
951 0, 0, 0, 0, 0, 0, 0, 0x1 } } };
952 static struct in_addr my_mcast_addr2 = { { { 224, 0, 0, 2 } } };
953 static struct net_linkaddr server_link_addr = {
954 .addr = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 },
955 .len = NET_ETH_ADDR_LEN,
956 };
957 #define MY_IPV6_ADDR_ETH "2001:db8:100::1"
958 #define PEER_IPV6_ADDR_ETH "2001:db8:100::2"
959 #define TEST_TXTIME INT64_MAX
960 #define WAIT_TIME K_MSEC(250)
961 #define WAIT_TIME_LONG K_MSEC(1000)
962
eth_fake_iface_init(struct net_if * iface)963 static void eth_fake_iface_init(struct net_if *iface)
964 {
965 const struct device *dev = net_if_get_device(iface);
966 struct eth_fake_context *ctx = dev->data;
967
968 ctx->iface = iface;
969
970 net_if_set_link_addr(iface, ctx->mac_address,
971 sizeof(ctx->mac_address),
972 NET_LINK_ETHERNET);
973
974 ethernet_init(iface);
975 }
976
eth_fake_send(const struct device * dev,struct net_pkt * pkt)977 static int eth_fake_send(const struct device *dev, struct net_pkt *pkt)
978 {
979 net_time_t txtime;
980
981 ARG_UNUSED(dev);
982 ARG_UNUSED(pkt);
983
984 if (!test_started) {
985 return 0;
986 }
987
988 txtime = net_pkt_timestamp_ns(pkt);
989 if (txtime != TEST_TXTIME) {
990 test_failed = true;
991 } else {
992 test_failed = false;
993 }
994
995 sys_mutex_unlock(&wait_data);
996
997 return 0;
998 }
999
1000 static struct ethernet_api eth_fake_api_funcs = {
1001 .iface_api.init = eth_fake_iface_init,
1002 .send = eth_fake_send,
1003 };
1004
1005 ETH_NET_DEVICE_INIT(eth_fake, "eth_fake", NULL, NULL, ð_fake_data, NULL,
1006 CONFIG_ETH_INIT_PRIORITY, ð_fake_api_funcs, NET_ETH_MTU);
1007
iface_cb(struct net_if * iface,void * user_data)1008 static void iface_cb(struct net_if *iface, void *user_data)
1009 {
1010 struct net_if **my_iface = user_data;
1011
1012 if (net_if_l2(iface) == &NET_L2_GET_NAME(ETHERNET)) {
1013 if (PART_OF_ARRAY(NET_IF_GET_NAME(eth_fake, 0), iface)) {
1014 *my_iface = iface;
1015 }
1016 }
1017
1018 if (net_if_l2(iface) == &NET_L2_GET_NAME(DUMMY)) {
1019 lo0 = iface;
1020 net_if_set_default(iface);
1021 }
1022 }
1023
ZTEST(net_socket_udp,test_17_setup_eth_for_ipv6)1024 ZTEST(net_socket_udp, test_17_setup_eth_for_ipv6)
1025 {
1026 struct net_if_addr *ifaddr;
1027 int ret;
1028
1029 net_if_foreach(iface_cb, ð_iface);
1030 zassert_not_null(eth_iface, "No ethernet interface found");
1031
1032 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr1,
1033 NET_ADDR_MANUAL, 0);
1034 if (!ifaddr) {
1035 DBG("Cannot add IPv6 address %s\n",
1036 net_sprint_ipv6_addr(&my_addr1));
1037 zassert_not_null(ifaddr, "addr1");
1038 }
1039
1040 net_if_up(eth_iface);
1041
1042 (void)memset(&udp_server_addr, 0, sizeof(udp_server_addr));
1043 udp_server_addr.sin6_family = AF_INET6;
1044 udp_server_addr.sin6_port = htons(1234);
1045 ret = zsock_inet_pton(AF_INET6, PEER_IPV6_ADDR_ETH, &udp_server_addr.sin6_addr);
1046 zassert_equal(ret, 1, "inet_pton failed");
1047
1048 /* In order to avoid neighbor discovery, populate neighbor cache */
1049 net_ipv6_nbr_add(eth_iface, &udp_server_addr.sin6_addr, &server_link_addr,
1050 true, NET_IPV6_NBR_STATE_REACHABLE);
1051 }
1052
ZTEST_USER(net_socket_udp,test_18_v6_sendmsg_with_txtime)1053 ZTEST_USER(net_socket_udp, test_18_v6_sendmsg_with_txtime)
1054 {
1055 int rv;
1056 int client_sock;
1057 int optval;
1058 net_time_t txtime;
1059 struct sockaddr_in6 client_addr;
1060 struct msghdr msg;
1061 struct cmsghdr *cmsg;
1062 struct iovec io_vector[1];
1063 union {
1064 struct cmsghdr hdr;
1065 unsigned char buf[CMSG_SPACE(sizeof(uint64_t))];
1066 } cmsgbuf;
1067
1068 prepare_sock_udp_v6(MY_IPV6_ADDR_ETH, ANY_PORT, &client_sock, &client_addr);
1069
1070 rv = zsock_bind(client_sock,
1071 (struct sockaddr *)&client_addr,
1072 sizeof(client_addr));
1073 zassert_equal(rv, 0, "client bind failed");
1074
1075 io_vector[0].iov_base = TEST_STR_SMALL;
1076 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1077
1078 memset(&msg, 0, sizeof(msg));
1079 msg.msg_control = &cmsgbuf.buf;
1080 msg.msg_controllen = sizeof(cmsgbuf.buf);
1081 msg.msg_iov = io_vector;
1082 msg.msg_iovlen = 1;
1083 msg.msg_name = &udp_server_addr;
1084 msg.msg_namelen = sizeof(udp_server_addr);
1085
1086 txtime = TEST_TXTIME;
1087
1088 cmsg = CMSG_FIRSTHDR(&msg);
1089 cmsg->cmsg_len = CMSG_LEN(sizeof(txtime));
1090 cmsg->cmsg_level = SOL_SOCKET;
1091 cmsg->cmsg_type = SCM_TXTIME;
1092 *(net_time_t *)CMSG_DATA(cmsg) = txtime;
1093
1094 optval = true;
1095 rv = zsock_setsockopt(client_sock, SOL_SOCKET, SO_TXTIME, &optval,
1096 sizeof(optval));
1097
1098 test_started = true;
1099
1100 comm_sendmsg_with_txtime(client_sock,
1101 (struct sockaddr *)&client_addr,
1102 sizeof(client_addr),
1103 &msg);
1104
1105 rv = zsock_close(client_sock);
1106 zassert_equal(rv, 0, "close failed");
1107
1108 if (sys_mutex_lock(&wait_data, WAIT_TIME)) {
1109 zassert_true(false, "Timeout DNS query not received");
1110 }
1111
1112 zassert_false(test_failed, "Invalid txtime received");
1113
1114 test_started = false;
1115 }
1116
test_msg_trunc(int sock_c,int sock_s,struct sockaddr * addr_c,socklen_t addrlen_c,struct sockaddr * addr_s,socklen_t addrlen_s)1117 void test_msg_trunc(int sock_c, int sock_s, struct sockaddr *addr_c,
1118 socklen_t addrlen_c, struct sockaddr *addr_s,
1119 socklen_t addrlen_s)
1120 {
1121 int rv;
1122 uint8_t str_buf[sizeof(TEST_STR_SMALL) - 1];
1123
1124 rv = zsock_bind(sock_s, addr_s, addrlen_s);
1125 zassert_equal(rv, 0, "server bind failed");
1126
1127 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1128 zassert_equal(rv, 0, "client bind failed");
1129
1130 rv = zsock_connect(sock_c, addr_s, addrlen_s);
1131 zassert_equal(rv, 0, "connect failed");
1132
1133 /* MSG_TRUNC */
1134
1135 rv = zsock_send(sock_c, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0);
1136 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "send failed");
1137
1138 memset(str_buf, 0, sizeof(str_buf));
1139 rv = zsock_recv(sock_s, str_buf, 2, ZSOCK_MSG_TRUNC);
1140 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "MSG_TRUNC flag failed");
1141 zassert_mem_equal(str_buf, TEST_STR_SMALL, 2, "invalid rx data");
1142 zassert_equal(str_buf[2], 0, "received more than requested");
1143
1144 /* The remaining data should've been discarded */
1145 rv = zsock_recv(sock_s, str_buf, sizeof(str_buf), ZSOCK_MSG_DONTWAIT);
1146 zassert_equal(rv, -1, "consecutive recv should've failed");
1147 zassert_equal(errno, EAGAIN, "incorrect errno value");
1148
1149 /* MSG_TRUNC & MSG_PEEK combo */
1150
1151 rv = zsock_send(sock_c, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0);
1152 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "send failed");
1153
1154 memset(str_buf, 0, sizeof(str_buf));
1155 rv = zsock_recv(sock_s, str_buf, 2, ZSOCK_MSG_TRUNC | ZSOCK_MSG_PEEK);
1156 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "MSG_TRUNC flag failed");
1157
1158 /* The packet should still be available due to MSG_PEEK */
1159 rv = zsock_recv(sock_s, str_buf, sizeof(str_buf), ZSOCK_MSG_TRUNC);
1160 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1,
1161 "recv after MSG_PEEK failed");
1162 zassert_mem_equal(str_buf, BUF_AND_SIZE(TEST_STR_SMALL),
1163 "invalid rx data");
1164
1165 rv = zsock_close(sock_c);
1166 zassert_equal(rv, 0, "close failed");
1167 rv = zsock_close(sock_s);
1168 zassert_equal(rv, 0, "close failed");
1169 }
1170
ZTEST(net_socket_udp,test_19_v4_msg_trunc)1171 ZTEST(net_socket_udp, test_19_v4_msg_trunc)
1172 {
1173 int client_sock;
1174 int server_sock;
1175 struct sockaddr_in client_addr;
1176 struct sockaddr_in server_addr;
1177
1178 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1179 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1180
1181 test_msg_trunc(client_sock, server_sock,
1182 (struct sockaddr *)&client_addr, sizeof(client_addr),
1183 (struct sockaddr *)&server_addr, sizeof(server_addr));
1184 }
1185
ZTEST(net_socket_udp,test_20_v6_msg_trunc)1186 ZTEST(net_socket_udp, test_20_v6_msg_trunc)
1187 {
1188 int client_sock;
1189 int server_sock;
1190 struct sockaddr_in6 client_addr;
1191 struct sockaddr_in6 server_addr;
1192
1193 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1194 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1195
1196 test_msg_trunc(client_sock, server_sock,
1197 (struct sockaddr *)&client_addr, sizeof(client_addr),
1198 (struct sockaddr *)&server_addr, sizeof(server_addr));
1199 }
1200
test_dgram_overflow(int sock_c,int sock_s,struct sockaddr * addr_c,socklen_t addrlen_c,struct sockaddr * addr_s,socklen_t addrlen_s,const void * buf,size_t buf_size)1201 static void test_dgram_overflow(int sock_c, int sock_s,
1202 struct sockaddr *addr_c, socklen_t addrlen_c,
1203 struct sockaddr *addr_s, socklen_t addrlen_s,
1204 const void *buf, size_t buf_size)
1205 {
1206 int rv;
1207
1208 rv = zsock_bind(sock_s, addr_s, addrlen_s);
1209 zassert_equal(rv, 0, "server bind failed");
1210
1211 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1212 zassert_equal(rv, 0, "client bind failed");
1213
1214 rv = zsock_connect(sock_c, addr_s, addrlen_s);
1215 zassert_equal(rv, 0, "connect failed");
1216
1217 rv = zsock_send(sock_c, buf, buf_size, 0);
1218 zassert_equal(rv, -1, "send succeeded");
1219 zassert_equal(errno, ENOMEM, "incorrect errno value");
1220
1221 rv = zsock_close(sock_c);
1222 zassert_equal(rv, 0, "close failed");
1223 rv = zsock_close(sock_s);
1224 zassert_equal(rv, 0, "close failed");
1225 }
1226
test_dgram_fragmented(int sock_c,int sock_s,struct sockaddr * addr_c,socklen_t addrlen_c,struct sockaddr * addr_s,socklen_t addrlen_s,const void * buf,size_t buf_size)1227 static void test_dgram_fragmented(int sock_c, int sock_s,
1228 struct sockaddr *addr_c, socklen_t addrlen_c,
1229 struct sockaddr *addr_s, socklen_t addrlen_s,
1230 const void *buf, size_t buf_size)
1231 {
1232 int rv;
1233
1234 rv = zsock_bind(sock_s, addr_s, addrlen_s);
1235 zassert_equal(rv, 0, "server bind failed");
1236
1237 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1238 zassert_equal(rv, 0, "client bind failed");
1239
1240 rv = zsock_connect(sock_c, addr_s, addrlen_s);
1241 zassert_equal(rv, 0, "connect failed");
1242
1243 rv = zsock_send(sock_c, buf, buf_size, 0);
1244 zassert_equal(rv, buf_size, "send failed");
1245
1246 memset(rx_buf, 0, sizeof(rx_buf));
1247 rv = zsock_recv(sock_s, rx_buf, sizeof(rx_buf), 0);
1248 zassert_equal(rv, buf_size, "recv failed");
1249 zassert_mem_equal(rx_buf, buf, buf_size, "wrong data");
1250
1251 rv = zsock_close(sock_c);
1252 zassert_equal(rv, 0, "close failed");
1253 rv = zsock_close(sock_s);
1254 zassert_equal(rv, 0, "close failed");
1255 }
1256
ZTEST(net_socket_udp,test_21_v4_dgram_overflow)1257 ZTEST(net_socket_udp, test_21_v4_dgram_overflow)
1258 {
1259 int client_sock;
1260 int server_sock;
1261 struct sockaddr_in client_addr;
1262 struct sockaddr_in server_addr;
1263
1264 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1265 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1266
1267 test_dgram_overflow(client_sock, server_sock,
1268 (struct sockaddr *)&client_addr, sizeof(client_addr),
1269 (struct sockaddr *)&server_addr, sizeof(server_addr),
1270 test_str_all_tx_bufs, NET_ETH_MTU + 1);
1271 }
1272
ZTEST(net_socket_udp,test_22_v6_dgram_fragmented_or_overflow)1273 ZTEST(net_socket_udp, test_22_v6_dgram_fragmented_or_overflow)
1274 {
1275 int client_sock;
1276 int server_sock;
1277 struct sockaddr_in6 client_addr;
1278 struct sockaddr_in6 server_addr;
1279
1280 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1281 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1282
1283 if (IS_ENABLED(CONFIG_NET_IPV6_FRAGMENT)) {
1284 test_dgram_fragmented(client_sock, server_sock,
1285 (struct sockaddr *)&client_addr, sizeof(client_addr),
1286 (struct sockaddr *)&server_addr, sizeof(server_addr),
1287 test_str_all_tx_bufs, NET_ETH_MTU + 1);
1288 } else {
1289 test_dgram_overflow(client_sock, server_sock,
1290 (struct sockaddr *)&client_addr, sizeof(client_addr),
1291 (struct sockaddr *)&server_addr, sizeof(server_addr),
1292 test_str_all_tx_bufs, NET_ETH_MTU + 1);
1293 }
1294 }
1295
ZTEST(net_socket_udp,test_23_v6_dgram_overflow)1296 ZTEST(net_socket_udp, test_23_v6_dgram_overflow)
1297 {
1298 int client_sock;
1299 int server_sock;
1300 struct sockaddr_in6 client_addr;
1301 struct sockaddr_in6 server_addr;
1302
1303 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1304 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1305
1306 test_dgram_overflow(client_sock, server_sock,
1307 (struct sockaddr *)&client_addr, sizeof(client_addr),
1308 (struct sockaddr *)&server_addr, sizeof(server_addr),
1309 BUF_AND_SIZE(test_str_all_tx_bufs));
1310 }
1311
test_dgram_connected(int sock_c,int sock_s1,int sock_s2,struct sockaddr * addr_c,socklen_t addrlen_c,struct sockaddr * addr_s1,socklen_t addrlen_s1,struct sockaddr * addr_s2,socklen_t addrlen_s2)1312 static void test_dgram_connected(int sock_c, int sock_s1, int sock_s2,
1313 struct sockaddr *addr_c, socklen_t addrlen_c,
1314 struct sockaddr *addr_s1, socklen_t addrlen_s1,
1315 struct sockaddr *addr_s2, socklen_t addrlen_s2)
1316 {
1317 uint8_t tx_buf = 0xab;
1318 uint8_t rx_buf;
1319 int rv;
1320
1321 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1322 zassert_equal(rv, 0, "client bind failed");
1323
1324 rv = zsock_bind(sock_s1, addr_s1, addrlen_s1);
1325 zassert_equal(rv, 0, "server bind failed");
1326
1327 rv = zsock_bind(sock_s2, addr_s2, addrlen_s2);
1328 zassert_equal(rv, 0, "server bind failed");
1329
1330 rv = zsock_connect(sock_c, addr_s1, addrlen_s1);
1331 zassert_equal(rv, 0, "connect failed");
1332
1333 /* Verify that a datagram can be received from the connected address */
1334 rv = zsock_sendto(sock_s1, &tx_buf, sizeof(tx_buf), 0, addr_c, addrlen_c);
1335 zassert_equal(rv, sizeof(tx_buf), "send failed %d", errno);
1336
1337 /* Give the packet a chance to go through the net stack */
1338 k_msleep(10);
1339
1340 rx_buf = 0;
1341 rv = zsock_recv(sock_c, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
1342 zassert_equal(rv, sizeof(rx_buf), "recv failed");
1343 zassert_equal(rx_buf, tx_buf, "wrong data");
1344
1345 /* Verify that a datagram is not received from other address */
1346 rv = zsock_sendto(sock_s2, &tx_buf, sizeof(tx_buf), 0, addr_c, addrlen_c);
1347 zassert_equal(rv, sizeof(tx_buf), "send failed");
1348
1349 /* Give the packet a chance to go through the net stack */
1350 k_msleep(10);
1351
1352 rv = zsock_recv(sock_c, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
1353 zassert_equal(rv, -1, "recv should've failed");
1354 zassert_equal(errno, EAGAIN, "incorrect errno");
1355
1356 rv = zsock_close(sock_c);
1357 zassert_equal(rv, 0, "close failed");
1358 rv = zsock_close(sock_s1);
1359 zassert_equal(rv, 0, "close failed");
1360 rv = zsock_close(sock_s2);
1361 zassert_equal(rv, 0, "close failed");
1362 }
1363
ZTEST(net_socket_udp,test_24_v4_dgram_connected)1364 ZTEST(net_socket_udp, test_24_v4_dgram_connected)
1365 {
1366 int client_sock;
1367 int server_sock_1;
1368 int server_sock_2;
1369 struct sockaddr_in client_addr;
1370 struct sockaddr_in server_addr_1;
1371 struct sockaddr_in server_addr_2;
1372
1373 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
1374 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock_1, &server_addr_1);
1375 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT + 1, &server_sock_2, &server_addr_2);
1376
1377 test_dgram_connected(client_sock, server_sock_1, server_sock_2,
1378 (struct sockaddr *)&client_addr, sizeof(client_addr),
1379 (struct sockaddr *)&server_addr_1, sizeof(server_addr_1),
1380 (struct sockaddr *)&server_addr_2, sizeof(server_addr_2));
1381 }
1382
ZTEST(net_socket_udp,test_25_v6_dgram_connected)1383 ZTEST(net_socket_udp, test_25_v6_dgram_connected)
1384 {
1385 int client_sock;
1386 int server_sock_1;
1387 int server_sock_2;
1388 struct sockaddr_in6 client_addr;
1389 struct sockaddr_in6 server_addr_1;
1390 struct sockaddr_in6 server_addr_2;
1391
1392 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
1393 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock_1, &server_addr_1);
1394 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT + 1, &server_sock_2, &server_addr_2);
1395
1396 test_dgram_connected(client_sock, server_sock_1, server_sock_2,
1397 (struct sockaddr *)&client_addr, sizeof(client_addr),
1398 (struct sockaddr *)&server_addr_1, sizeof(server_addr_1),
1399 (struct sockaddr *)&server_addr_2, sizeof(server_addr_2));
1400 }
1401
ZTEST_USER(net_socket_udp,test_26_recvmsg_invalid)1402 ZTEST_USER(net_socket_udp, test_26_recvmsg_invalid)
1403 {
1404 struct msghdr msg;
1405 struct sockaddr_in6 server_addr;
1406 struct cmsghdr *cmsg;
1407 struct iovec io_vector[1];
1408 union {
1409 struct cmsghdr hdr;
1410 unsigned char buf[CMSG_SPACE(sizeof(int))];
1411 } cmsgbuf;
1412 int ret;
1413
1414 /* Userspace is needed for this test */
1415 Z_TEST_SKIP_IFNDEF(CONFIG_USERSPACE);
1416
1417 io_vector[0].iov_base = TEST_STR_SMALL;
1418 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1419
1420 ret = zsock_recvmsg(0, NULL, 0);
1421 zassert_true(ret < 0 && errno == EINVAL, "Wrong errno (%d)", errno);
1422
1423 /* Set various pointers to NULL or invalid value which should cause failure */
1424 memset(&msg, 0, sizeof(msg));
1425 msg.msg_controllen = sizeof(cmsgbuf.buf);
1426
1427 ret = zsock_recvmsg(0, &msg, 0);
1428 zassert_true(ret < 0, "recvmsg() succeed");
1429
1430 msg.msg_control = &cmsgbuf.buf;
1431
1432 ret = zsock_recvmsg(0, &msg, 0);
1433 zassert_true(ret < 0 && errno == ENOMEM, "Wrong errno (%d)", errno);
1434
1435 msg.msg_iov = io_vector;
1436 msg.msg_iovlen = 1;
1437 msg.msg_name = (void *)1;
1438 msg.msg_namelen = sizeof(server_addr);
1439
1440 cmsg = CMSG_FIRSTHDR(&msg);
1441 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
1442 cmsg->cmsg_level = SOL_SOCKET;
1443 cmsg->cmsg_type = 1122;
1444 *(int *)CMSG_DATA(cmsg) = 42;
1445
1446 ret = zsock_recvmsg(0, &msg, 0);
1447 zassert_true(ret < 0, "recvmsg() succeed");
1448 }
1449
comm_sendmsg_recvmsg(int client_sock,struct sockaddr * client_addr,socklen_t client_addrlen,const struct msghdr * client_msg,int server_sock,struct sockaddr * server_addr,socklen_t server_addrlen,struct msghdr * msg,void * cmsgbuf,int cmsgbuf_len,bool expect_control_data)1450 static void comm_sendmsg_recvmsg(int client_sock,
1451 struct sockaddr *client_addr,
1452 socklen_t client_addrlen,
1453 const struct msghdr *client_msg,
1454 int server_sock,
1455 struct sockaddr *server_addr,
1456 socklen_t server_addrlen,
1457 struct msghdr *msg,
1458 void *cmsgbuf, int cmsgbuf_len,
1459 bool expect_control_data)
1460 {
1461 #define MAX_BUF_LEN 64
1462 #define SMALL_BUF_LEN (sizeof(TEST_STR_SMALL) - 1 - 2)
1463 char buf[MAX_BUF_LEN];
1464 char buf2[SMALL_BUF_LEN];
1465 struct iovec io_vector[2];
1466 ssize_t sent;
1467 ssize_t recved;
1468 struct sockaddr addr;
1469 socklen_t addrlen = server_addrlen;
1470 int len, i;
1471
1472 zassert_not_null(client_addr, "null client addr");
1473 zassert_not_null(server_addr, "null server addr");
1474
1475 /*
1476 * Test client -> server sending
1477 */
1478
1479 sent = zsock_sendmsg(client_sock, client_msg, 0);
1480 zassert_true(sent > 0, "sendmsg failed, %s (%d)", strerror(errno), -errno);
1481
1482 /* One negative test with invalid msg_iov */
1483 memset(msg, 0, sizeof(*msg));
1484 recved = zsock_recvmsg(server_sock, msg, 0);
1485 zassert_true(recved < 0 && errno == ENOMEM, "Wrong errno (%d)", errno);
1486
1487 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
1488 len += client_msg->msg_iov[i].iov_len;
1489 }
1490
1491 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
1492
1493 /* Test first with one iovec */
1494 io_vector[0].iov_base = buf;
1495 io_vector[0].iov_len = sizeof(buf);
1496
1497 memset(msg, 0, sizeof(*msg));
1498 memset(cmsgbuf, 0, cmsgbuf_len);
1499 msg->msg_control = cmsgbuf;
1500 msg->msg_controllen = cmsgbuf_len;
1501 msg->msg_iov = io_vector;
1502 msg->msg_iovlen = 1;
1503 msg->msg_name = &addr;
1504 msg->msg_namelen = addrlen;
1505
1506 /* Test recvmsg(MSG_PEEK) */
1507 recved = zsock_recvmsg(server_sock, msg, ZSOCK_MSG_PEEK);
1508 zassert_true(recved > 0, "recvmsg fail, %s (%d)", strerror(errno), -errno);
1509 zassert_equal(recved, len, "unexpected received bytes (%d vs %d)",
1510 recved, len);
1511 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
1512 sent, recved);
1513 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
1514 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf),
1515 "recvmsg should not modify buffer length");
1516 zassert_mem_equal(buf, TEST_STR_SMALL, len,
1517 "wrong data (%s)", rx_buf);
1518 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1519
1520 /* Test normal recvmsg() */
1521 clear_buf(rx_buf);
1522 recved = zsock_recvmsg(server_sock, msg, 0);
1523 zassert_true(recved > 0, "recvfrom fail");
1524 zassert_equal(recved, len, "unexpected received bytes");
1525 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
1526 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf),
1527 "recvmsg should not modify buffer length");
1528 zassert_mem_equal(buf, TEST_STR_SMALL, len,
1529 "wrong data (%s)", rx_buf);
1530 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1531
1532 /* Control data should be empty */
1533 if (!expect_control_data) {
1534 zassert_equal(msg->msg_controllen, 0,
1535 "We received control data (%u vs %zu)",
1536 0U, msg->msg_controllen);
1537 }
1538
1539 /* Check the client port */
1540 if (addr.sa_family == AF_INET) {
1541 if (net_sin(client_addr)->sin_port != ANY_PORT) {
1542 zassert_equal(net_sin(client_addr)->sin_port,
1543 net_sin(&addr)->sin_port,
1544 "unexpected client port");
1545 }
1546 }
1547
1548 if (addr.sa_family == AF_INET6) {
1549 if (net_sin6(client_addr)->sin6_port != ANY_PORT) {
1550 zassert_equal(net_sin6(client_addr)->sin6_port,
1551 net_sin6(&addr)->sin6_port,
1552 "unexpected client port");
1553 }
1554 }
1555
1556 /* Then send the message again and verify that we could receive
1557 * the full message in smaller chunks too.
1558 */
1559 sent = zsock_sendmsg(client_sock, client_msg, 0);
1560 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
1561
1562 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
1563 len += client_msg->msg_iov[i].iov_len;
1564 }
1565
1566 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
1567
1568 /* and then test with two iovec */
1569 io_vector[0].iov_base = buf2;
1570 io_vector[0].iov_len = sizeof(buf2);
1571 io_vector[1].iov_base = buf;
1572 io_vector[1].iov_len = sizeof(buf);
1573
1574 memset(msg, 0, sizeof(*msg));
1575 memset(cmsgbuf, 0, cmsgbuf_len);
1576 msg->msg_control = cmsgbuf;
1577 msg->msg_controllen = cmsgbuf_len;
1578 msg->msg_iov = io_vector;
1579 msg->msg_iovlen = 2;
1580 msg->msg_name = &addr;
1581 msg->msg_namelen = addrlen;
1582
1583 /* Test recvmsg(MSG_PEEK) */
1584 recved = zsock_recvmsg(server_sock, msg, ZSOCK_MSG_PEEK);
1585 zassert_true(recved >= 0, "recvfrom fail (errno %d)", errno);
1586 zassert_equal(recved, len,
1587 "unexpected received bytes (%d vs %d)", recved, len);
1588 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
1589 sent, recved);
1590
1591 zassert_equal(msg->msg_iovlen, 2, "recvmsg should not modify msg_iovlen");
1592 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf2),
1593 "recvmsg should not modify buffer length");
1594 zassert_equal(msg->msg_iov[1].iov_len, sizeof(buf),
1595 "recvmsg should not modify buffer length");
1596 zassert_mem_equal(msg->msg_iov[0].iov_base, TEST_STR_SMALL, msg->msg_iov[0].iov_len,
1597 "wrong data in %s", "iov[0]");
1598 zassert_mem_equal(msg->msg_iov[1].iov_base, &TEST_STR_SMALL[msg->msg_iov[0].iov_len],
1599 len - msg->msg_iov[0].iov_len,
1600 "wrong data in %s", "iov[1]");
1601 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1602
1603 /* Test normal recvfrom() */
1604 recved = zsock_recvmsg(server_sock, msg, ZSOCK_MSG_PEEK);
1605 zassert_true(recved >= 0, "recvfrom fail (errno %d)", errno);
1606 zassert_equal(recved, len,
1607 "unexpected received bytes (%d vs %d)", recved, len);
1608 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
1609 sent, recved);
1610
1611 zassert_equal(msg->msg_iovlen, 2, "recvmsg should not modify msg_iovlen");
1612 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf2),
1613 "recvmsg should not modify buffer length");
1614 zassert_equal(msg->msg_iov[1].iov_len, sizeof(buf),
1615 "recvmsg should not modify buffer length");
1616 zassert_mem_equal(msg->msg_iov[0].iov_base, TEST_STR_SMALL, msg->msg_iov[0].iov_len,
1617 "wrong data in %s", "iov[0]");
1618 zassert_mem_equal(msg->msg_iov[1].iov_base, &TEST_STR_SMALL[msg->msg_iov[0].iov_len],
1619 len - msg->msg_iov[0].iov_len,
1620 "wrong data in %s", "iov[1]");
1621 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1622
1623 /* Control data should be empty */
1624 if (!expect_control_data) {
1625 zassert_equal(msg->msg_controllen, 0,
1626 "We received control data (%u vs %zu)",
1627 0U, msg->msg_controllen);
1628 }
1629
1630 /* Then check that the trucation flag is set correctly */
1631 sent = zsock_sendmsg(client_sock, client_msg, 0);
1632 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
1633
1634 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
1635 len += client_msg->msg_iov[i].iov_len;
1636 }
1637
1638 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
1639
1640 /* Test first with one iovec */
1641 io_vector[0].iov_base = buf2;
1642 io_vector[0].iov_len = sizeof(buf2);
1643
1644 memset(msg, 0, sizeof(*msg));
1645 memset(cmsgbuf, 0, cmsgbuf_len);
1646 msg->msg_control = cmsgbuf;
1647 msg->msg_controllen = cmsgbuf_len;
1648 msg->msg_iov = io_vector;
1649 msg->msg_iovlen = 1;
1650 msg->msg_name = &addr;
1651 msg->msg_namelen = addrlen;
1652
1653 /* Test recvmsg */
1654 recved = zsock_recvmsg(server_sock, msg, 0);
1655 zassert_true(recved > 0, "recvmsg fail, %s (%d)", strerror(errno), errno);
1656 zassert_equal(recved, sizeof(buf2),
1657 "unexpected received bytes (%d vs %d)",
1658 recved, sizeof(buf2));
1659 zassert_true(msg->msg_flags & ZSOCK_MSG_TRUNC, "Message not truncated");
1660
1661 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
1662 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf2),
1663 "recvmsg should not modify buffer length");
1664 zassert_mem_equal(buf2, TEST_STR_SMALL, sizeof(buf2),
1665 "wrong data (%s)", buf2);
1666 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1667
1668 /* Control data should be empty */
1669 if (!expect_control_data) {
1670 zassert_equal(msg->msg_controllen, 0,
1671 "We received control data (%u vs %zu)",
1672 0U, msg->msg_controllen);
1673 }
1674 }
1675
ZTEST_USER(net_socket_udp,test_27_recvmsg_user)1676 ZTEST_USER(net_socket_udp, test_27_recvmsg_user)
1677 {
1678 int rv;
1679 int client_sock;
1680 int server_sock;
1681 struct sockaddr_in client_addr;
1682 struct sockaddr_in server_addr;
1683 struct msghdr msg, server_msg;
1684 struct iovec io_vector[1];
1685
1686 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1687 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1688
1689 rv = zsock_bind(server_sock,
1690 (struct sockaddr *)&server_addr,
1691 sizeof(server_addr));
1692 zassert_equal(rv, 0, "server bind failed");
1693
1694 rv = zsock_bind(client_sock,
1695 (struct sockaddr *)&client_addr,
1696 sizeof(client_addr));
1697 zassert_equal(rv, 0, "client bind failed");
1698
1699 io_vector[0].iov_base = TEST_STR_SMALL;
1700 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1701
1702 memset(&msg, 0, sizeof(msg));
1703 msg.msg_iov = io_vector;
1704 msg.msg_iovlen = 1;
1705 msg.msg_name = &server_addr;
1706 msg.msg_namelen = sizeof(server_addr);
1707
1708 comm_sendmsg_recvmsg(client_sock,
1709 (struct sockaddr *)&client_addr,
1710 sizeof(client_addr),
1711 &msg,
1712 server_sock,
1713 (struct sockaddr *)&server_addr,
1714 sizeof(server_addr),
1715 &server_msg, NULL, 0, false);
1716
1717 rv = zsock_close(client_sock);
1718 zassert_equal(rv, 0, "close failed");
1719 rv = zsock_close(server_sock);
1720 zassert_equal(rv, 0, "close failed");
1721 }
1722
run_ancillary_recvmsg_test(int client_sock,struct sockaddr * client_addr,int client_addr_len,int server_sock,struct sockaddr * server_addr,int server_addr_len)1723 static void run_ancillary_recvmsg_test(int client_sock,
1724 struct sockaddr *client_addr,
1725 int client_addr_len,
1726 int server_sock,
1727 struct sockaddr *server_addr,
1728 int server_addr_len)
1729 {
1730 int rv;
1731 int opt;
1732 int ifindex = 0;
1733 socklen_t optlen;
1734 struct sockaddr addr = { 0 };
1735 struct net_if *iface;
1736 struct msghdr msg;
1737 struct msghdr server_msg;
1738 struct iovec io_vector[1];
1739 struct cmsghdr *cmsg, *prevcmsg;
1740 union {
1741 struct cmsghdr hdr;
1742 unsigned char buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
1743 } cmsgbuf;
1744 #define SMALL_BUF_LEN (sizeof(TEST_STR_SMALL) - 1 - 2)
1745 char buf[MAX_BUF_LEN];
1746
1747 Z_TEST_SKIP_IFNDEF(CONFIG_NET_CONTEXT_RECV_PKTINFO);
1748
1749 rv = zsock_bind(server_sock, server_addr, server_addr_len);
1750 zassert_equal(rv, 0, "server bind failed");
1751
1752 rv = zsock_bind(client_sock, client_addr, client_addr_len);
1753 zassert_equal(rv, 0, "client bind failed");
1754
1755 io_vector[0].iov_base = TEST_STR_SMALL;
1756 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1757
1758 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
1759
1760 memset(&msg, 0, sizeof(msg));
1761 msg.msg_iov = io_vector;
1762 msg.msg_iovlen = 1;
1763 msg.msg_name = server_addr;
1764 msg.msg_namelen = server_addr_len;
1765
1766 comm_sendmsg_recvmsg(client_sock,
1767 client_addr,
1768 client_addr_len,
1769 &msg,
1770 server_sock,
1771 server_addr,
1772 server_addr_len,
1773 &server_msg,
1774 &cmsgbuf.buf,
1775 sizeof(cmsgbuf.buf),
1776 true);
1777
1778 for (prevcmsg = NULL, cmsg = CMSG_FIRSTHDR(&server_msg);
1779 cmsg != NULL && prevcmsg != cmsg;
1780 prevcmsg = cmsg, cmsg = CMSG_NXTHDR(&server_msg, cmsg)) {
1781 if (cmsg->cmsg_level == IPPROTO_IP &&
1782 cmsg->cmsg_type == IP_PKTINFO) {
1783 net_sin(&addr)->sin_addr = ((struct in_pktinfo *)CMSG_DATA(cmsg))->ipi_addr;
1784 break;
1785 }
1786 }
1787
1788 /* As we have not set the socket option, the address should not be set */
1789 if (server_addr->sa_family == AF_INET) {
1790 zassert_equal(net_sin(&addr)->sin_addr.s_addr, INADDR_ANY, "Source address set!");
1791 }
1792
1793 if (server_addr->sa_family == AF_INET6) {
1794 zassert_true(net_sin6(&addr)->sin6_addr.s6_addr32[0] == 0 &&
1795 net_sin6(&addr)->sin6_addr.s6_addr32[1] == 0 &&
1796 net_sin6(&addr)->sin6_addr.s6_addr32[2] == 0 &&
1797 net_sin6(&addr)->sin6_addr.s6_addr32[3] == 0,
1798 "Source address set!");
1799 }
1800
1801 opt = 1;
1802 optlen = sizeof(opt);
1803 rv = zsock_setsockopt(server_sock, IPPROTO_IP, IP_PKTINFO, &opt, optlen);
1804 zassert_equal(rv, 0, "setsockopt failed (%d)", -errno);
1805
1806 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
1807
1808 memset(&msg, 0, sizeof(msg));
1809 msg.msg_iov = io_vector;
1810 msg.msg_iovlen = 1;
1811 msg.msg_name = server_addr;
1812 msg.msg_namelen = server_addr_len;
1813
1814 comm_sendmsg_recvmsg(client_sock,
1815 client_addr,
1816 client_addr_len,
1817 &msg,
1818 server_sock,
1819 server_addr,
1820 server_addr_len,
1821 &server_msg,
1822 &cmsgbuf.buf,
1823 sizeof(cmsgbuf.buf),
1824 true);
1825
1826 for (cmsg = CMSG_FIRSTHDR(&server_msg); cmsg != NULL;
1827 cmsg = CMSG_NXTHDR(&server_msg, cmsg)) {
1828 if (cmsg->cmsg_level == IPPROTO_IP &&
1829 cmsg->cmsg_type == IP_PKTINFO) {
1830 net_sin(&addr)->sin_addr =
1831 ((struct in_pktinfo *)CMSG_DATA(cmsg))->ipi_addr;
1832 ifindex = ((struct in_pktinfo *)CMSG_DATA(cmsg))->ipi_ifindex;
1833 break;
1834 }
1835
1836 if (cmsg->cmsg_level == IPPROTO_IPV6 &&
1837 cmsg->cmsg_type == IPV6_RECVPKTINFO) {
1838 net_ipaddr_copy(&net_sin6(&addr)->sin6_addr,
1839 &((struct in6_pktinfo *)CMSG_DATA(cmsg))->ipi6_addr);
1840 ifindex = ((struct in6_pktinfo *)CMSG_DATA(cmsg))->ipi6_ifindex;
1841 break;
1842 }
1843 }
1844
1845 if (server_addr->sa_family == AF_INET) {
1846 zassert_equal(net_sin(&addr)->sin_addr.s_addr,
1847 net_sin(server_addr)->sin_addr.s_addr,
1848 "Source address not set properly!");
1849 }
1850
1851 if (server_addr->sa_family == AF_INET6) {
1852 zassert_mem_equal(&net_sin6(&addr)->sin6_addr,
1853 &net_sin6(server_addr)->sin6_addr,
1854 sizeof(struct in6_addr),
1855 "Source address not set properly!");
1856 }
1857
1858 if (!k_is_user_context()) {
1859 iface = net_if_get_default();
1860 zassert_equal(ifindex, net_if_get_by_iface(iface));
1861 }
1862
1863 /* Make sure that the recvmsg() fails if control area is too small */
1864 rv = zsock_sendto(client_sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
1865 server_addr, server_addr_len);
1866 zassert_equal(rv, STRLEN(TEST_STR_SMALL), "sendto failed (%d)", -errno);
1867
1868 io_vector[0].iov_base = buf;
1869 io_vector[0].iov_len = sizeof(buf);
1870
1871 memset(&msg, 0, sizeof(msg));
1872 msg.msg_control = &cmsgbuf.buf;
1873 msg.msg_controllen = 1; /* making sure the control buf is always too small */
1874 msg.msg_iov = io_vector;
1875 msg.msg_iovlen = 1;
1876
1877 rv = zsock_recvmsg(server_sock, &msg, 0);
1878 zassert_true(rv, "recvmsg succeed (%d)", rv);
1879
1880 zassert_true(msg.msg_flags & ZSOCK_MSG_CTRUNC, "Control message not truncated");
1881
1882 rv = zsock_close(client_sock);
1883 zassert_equal(rv, 0, "close failed");
1884 rv = zsock_close(server_sock);
1885 zassert_equal(rv, 0, "close failed");
1886 }
1887
ZTEST_USER(net_socket_udp,test_28_recvmsg_ancillary_ipv4_pktinfo_data_user)1888 ZTEST_USER(net_socket_udp, test_28_recvmsg_ancillary_ipv4_pktinfo_data_user)
1889 {
1890 struct sockaddr_in client_addr;
1891 struct sockaddr_in server_addr;
1892 int client_sock;
1893 int server_sock;
1894
1895 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1896 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1897
1898 run_ancillary_recvmsg_test(client_sock,
1899 (struct sockaddr *)&client_addr,
1900 sizeof(client_addr),
1901 server_sock,
1902 (struct sockaddr *)&server_addr,
1903 sizeof(server_addr));
1904 }
1905
ZTEST_USER(net_socket_udp,test_29_recvmsg_ancillary_ipv6_pktinfo_data_user)1906 ZTEST_USER(net_socket_udp, test_29_recvmsg_ancillary_ipv6_pktinfo_data_user)
1907 {
1908 struct sockaddr_in6 client_addr;
1909 struct sockaddr_in6 server_addr;
1910 int client_sock;
1911 int server_sock;
1912
1913 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1914 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1915
1916 run_ancillary_recvmsg_test(client_sock,
1917 (struct sockaddr *)&client_addr,
1918 sizeof(client_addr),
1919 server_sock,
1920 (struct sockaddr *)&server_addr,
1921 sizeof(server_addr));
1922 }
1923
ZTEST(net_socket_udp,test_30_setup_eth_for_ipv4)1924 ZTEST(net_socket_udp, test_30_setup_eth_for_ipv4)
1925 {
1926 struct net_if_addr *ifaddr;
1927
1928 net_if_foreach(iface_cb, ð_iface);
1929 zassert_not_null(eth_iface, "No ethernet interface found");
1930
1931 net_if_down(eth_iface);
1932
1933 ifaddr = net_if_ipv4_addr_add(eth_iface, &my_addr2,
1934 NET_ADDR_MANUAL, 0);
1935 if (!ifaddr) {
1936 DBG("Cannot add IPv4 address %s\n",
1937 net_sprint_ipv4_addr(&my_addr2));
1938 zassert_not_null(ifaddr, "addr2");
1939 }
1940
1941 net_if_up(eth_iface);
1942 }
1943
bind_socket(int sock,struct net_if * iface)1944 static int bind_socket(int sock, struct net_if *iface)
1945 {
1946 struct sockaddr_ll addr;
1947
1948 memset(&addr, 0, sizeof(addr));
1949
1950 addr.sll_ifindex = net_if_get_by_iface(iface);
1951 addr.sll_family = AF_PACKET;
1952
1953 return zsock_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
1954 }
1955
test_check_ttl(int sock_c,int sock_s,int sock_p,struct sockaddr * addr_c,socklen_t addrlen_c,struct sockaddr * addr_s,socklen_t addrlen_s,struct sockaddr * addr_sendto,socklen_t addrlen_sendto,sa_family_t family,uint8_t expected_ttl,uint8_t expected_mcast_ttl)1956 static void test_check_ttl(int sock_c, int sock_s, int sock_p,
1957 struct sockaddr *addr_c, socklen_t addrlen_c,
1958 struct sockaddr *addr_s, socklen_t addrlen_s,
1959 struct sockaddr *addr_sendto, socklen_t addrlen_sendto,
1960 sa_family_t family, uint8_t expected_ttl,
1961 uint8_t expected_mcast_ttl)
1962 {
1963 uint8_t tx_buf = 0xab;
1964 uint8_t rx_buf;
1965 int ret, count = 10, opt;
1966 #define IPV4_HDR_SIZE sizeof(struct net_ipv4_hdr)
1967 #define IPV6_HDR_SIZE sizeof(struct net_ipv6_hdr)
1968 #define UDP_HDR_SIZE sizeof(struct net_udp_hdr)
1969 #define V4_HDR_SIZE (IPV4_HDR_SIZE + UDP_HDR_SIZE)
1970 #define V6_HDR_SIZE (IPV6_HDR_SIZE + UDP_HDR_SIZE)
1971 #define MAX_HDR_SIZE (IPV6_HDR_SIZE + UDP_HDR_SIZE)
1972 uint8_t data_to_receive[sizeof(tx_buf) + MAX_HDR_SIZE];
1973 struct sockaddr_ll src;
1974 socklen_t addrlen;
1975 char ifname[CONFIG_NET_INTERFACE_NAME_LEN];
1976 struct ifreq ifreq = { 0 };
1977 struct timeval timeo_optval = {
1978 .tv_sec = 0,
1979 .tv_usec = 100000,
1980 };
1981 #if defined(CONFIG_NET_STATISTICS)
1982 struct net_stats_ip ipv4_stats_before, ipv4_stats_after;
1983 struct net_stats_ip ipv6_stats_before, ipv6_stats_after;
1984 #endif
1985
1986 Z_TEST_SKIP_IFNDEF(CONFIG_NET_INTERFACE_NAME);
1987
1988 ret = zsock_bind(sock_c, addr_c, addrlen_c);
1989 zassert_equal(ret, 0, "client bind failed");
1990
1991 ret = net_if_get_name(lo0, ifname, sizeof(ifname));
1992 zassert_true(ret > 0, "cannot get interface name (%d)", ret);
1993
1994 strncpy(ifreq.ifr_name, ifname, sizeof(ifreq.ifr_name));
1995 ret = zsock_setsockopt(sock_c, SOL_SOCKET, SO_BINDTODEVICE, &ifreq,
1996 sizeof(ifreq));
1997 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", -errno);
1998
1999 ret = zsock_connect(sock_c, addr_s, addrlen_s);
2000 zassert_equal(ret, 0, "connect failed");
2001
2002 ret = zsock_setsockopt(sock_s, SOL_SOCKET, SO_RCVTIMEO,
2003 &timeo_optval, sizeof(timeo_optval));
2004 zassert_equal(ret, 0, "Cannot set receive timeout (%d)", -errno);
2005
2006 while (count > 0) {
2007 ret = zsock_sendto(sock_c, &tx_buf, sizeof(tx_buf), 0,
2008 addr_sendto, addrlen_sendto);
2009 zassert_equal(ret, sizeof(tx_buf), "send failed (%d)", -errno);
2010
2011 ret = zsock_recv(sock_s, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
2012 if (ret > 0) {
2013 zassert_equal(ret, sizeof(rx_buf), "recv failed (%d)", ret);
2014 zassert_equal(rx_buf, tx_buf, "wrong data");
2015 }
2016
2017 ret = zsock_recvfrom(sock_p, data_to_receive, sizeof(data_to_receive), 0,
2018 (struct sockaddr *)&src, &addrlen);
2019 if (ret > 0) {
2020 int hdr_size = family == AF_INET ?
2021 V4_HDR_SIZE : V6_HDR_SIZE;
2022 zassert_equal(ret, sizeof(tx_buf) + hdr_size,
2023 "Cannot receive all data (%d vs %zd) (%d)",
2024 ret, sizeof(tx_buf), -errno);
2025 zassert_mem_equal(&data_to_receive[hdr_size], &tx_buf,
2026 sizeof(tx_buf),
2027 "Sent and received buffers do not match");
2028
2029 if (family == AF_INET) {
2030 struct net_ipv4_hdr *ipv4 =
2031 (struct net_ipv4_hdr *)&data_to_receive[0];
2032
2033 if (expected_ttl > 0) {
2034 zassert_equal(ipv4->ttl, expected_ttl,
2035 "Invalid ttl (%d vs %d)",
2036 ipv4->ttl, expected_ttl);
2037 } else if (expected_mcast_ttl > 0) {
2038 zassert_equal(ipv4->ttl, expected_mcast_ttl,
2039 "Invalid mcast ttl (%d vs %d)",
2040 ipv4->ttl, expected_mcast_ttl);
2041 }
2042 } else if (family == AF_INET6) {
2043 struct net_ipv6_hdr *ipv6 =
2044 (struct net_ipv6_hdr *)&data_to_receive[0];
2045
2046 if (expected_ttl > 0) {
2047 zassert_equal(ipv6->hop_limit, expected_ttl,
2048 "Invalid hop limit (%d vs %d)",
2049 ipv6->hop_limit, expected_ttl);
2050 } else if (expected_mcast_ttl > 0) {
2051 zassert_equal(ipv6->hop_limit, expected_mcast_ttl,
2052 "Invalid mcast hop limit (%d vs %d)",
2053 ipv6->hop_limit, expected_mcast_ttl);
2054 }
2055 } else {
2056 zassert_true(false, "Invalid address family (%d)",
2057 family);
2058 }
2059
2060 break;
2061 }
2062
2063 count--;
2064 }
2065
2066 zassert_true(count > 0, "timeout while waiting data");
2067
2068 if (family == AF_INET) {
2069 /* Set TTL to 0 and make sure the packet is dropped and not
2070 * received
2071 */
2072 int option;
2073
2074 if (expected_ttl > 0) {
2075 option = IP_TTL;
2076 } else {
2077 option = IP_MULTICAST_TTL;
2078 }
2079
2080 opt = 0;
2081 ret = zsock_setsockopt(sock_c, IPPROTO_IP, option, &opt, sizeof(opt));
2082 zassert_equal(ret, 0, "Cannot set %s TTL (%d)",
2083 option == IP_TTL ? "unicast" : "multicast",
2084 -errno);
2085
2086 #if defined(CONFIG_NET_STATISTICS)
2087 /* Get IPv4 stats and verify they are updated for dropped
2088 * packets.
2089 */
2090 net_mgmt(NET_REQUEST_STATS_GET_IPV4, lo0,
2091 &ipv4_stats_before, sizeof(ipv4_stats_before));
2092 #endif
2093 ret = zsock_sendto(sock_c, &tx_buf, sizeof(tx_buf), 0,
2094 addr_sendto, addrlen_sendto);
2095 zassert_equal(ret, sizeof(tx_buf), "send failed (%d)", -errno);
2096
2097 #if defined(CONFIG_NET_STATISTICS)
2098 net_mgmt(NET_REQUEST_STATS_GET_IPV4, lo0,
2099 &ipv4_stats_after, sizeof(ipv4_stats_after));
2100
2101 zassert_equal(ipv4_stats_before.drop + 1,
2102 ipv4_stats_after.drop,
2103 "Dropped statistics not updated (%d vs %d)",
2104 ipv4_stats_before.drop + 1,
2105 ipv4_stats_after.drop);
2106 #endif
2107 ret = zsock_recv(sock_s, &rx_buf, sizeof(rx_buf), 0);
2108 zassert_true(ret < 0 && errno == EAGAIN, "recv succeed (%d)", -errno);
2109 }
2110
2111 if (family == AF_INET6) {
2112 /* Set hoplimit to 0 and make sure the packet is dropped and not
2113 * received.
2114 */
2115 int option;
2116
2117 if (expected_ttl > 0) {
2118 option = IPV6_UNICAST_HOPS;
2119 } else {
2120 option = IPV6_MULTICAST_HOPS;
2121 }
2122
2123 opt = 0;
2124 ret = zsock_setsockopt(sock_c, IPPROTO_IPV6, option,
2125 &opt, sizeof(opt));
2126 zassert_equal(ret, 0, "Cannot set %s hops (%d)",
2127 option == IPV6_UNICAST_HOPS ? "unicast" : "multicast",
2128 -errno);
2129
2130 #if defined(CONFIG_NET_STATISTICS)
2131 /* Get IPv6 stats and verify they are updated for dropped
2132 * packets.
2133 */
2134 net_mgmt(NET_REQUEST_STATS_GET_IPV6, lo0,
2135 &ipv6_stats_before, sizeof(ipv6_stats_before));
2136 #endif
2137 ret = zsock_sendto(sock_c, &tx_buf, sizeof(tx_buf), 0,
2138 addr_sendto, addrlen_sendto);
2139 zassert_equal(ret, sizeof(tx_buf), "send failed (%d)", -errno);
2140
2141 #if defined(CONFIG_NET_STATISTICS)
2142 net_mgmt(NET_REQUEST_STATS_GET_IPV6, lo0,
2143 &ipv6_stats_after, sizeof(ipv6_stats_after));
2144
2145 zassert_equal(ipv6_stats_before.drop + 1,
2146 ipv6_stats_after.drop,
2147 "Dropped statistics not updated (%d vs %d)",
2148 ipv6_stats_before.drop + 1,
2149 ipv6_stats_after.drop);
2150 #endif
2151 ret = zsock_recv(sock_s, &rx_buf, sizeof(rx_buf), 0);
2152 zassert_true(ret < 0 && errno == EAGAIN, "recv succeed (%d)", -errno);
2153
2154 }
2155
2156 ret = zsock_close(sock_c);
2157 zassert_equal(ret, 0, "close failed");
2158 ret = zsock_close(sock_s);
2159 zassert_equal(ret, 0, "close failed");
2160 ret = zsock_close(sock_p);
2161 zassert_equal(ret, 0, "close failed");
2162 }
2163
ZTEST(net_socket_udp,test_31_v4_ttl)2164 ZTEST(net_socket_udp, test_31_v4_ttl)
2165 {
2166 int ret;
2167 int client_sock;
2168 int server_sock;
2169 int packet_sock;
2170 int ttl, verify;
2171 socklen_t optlen;
2172 struct sockaddr_in client_addr;
2173 struct sockaddr_in server_addr;
2174
2175 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2176
2177 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2178 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
2179
2180 packet_sock = zsock_socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
2181 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2182
2183 ret = bind_socket(packet_sock, lo0);
2184 zassert_equal(ret, 0, "packet socket bind failed");
2185
2186 zassert_not_null(lo0->config.ip.ipv4,
2187 "Interface %d (%p) no IPv4 configured",
2188 net_if_get_by_iface(lo0), lo0);
2189
2190 ttl = 16;
2191 net_if_ipv4_set_ttl(lo0, ttl);
2192 verify = net_if_ipv4_get_ttl(lo0);
2193 zassert_equal(verify, ttl, "Different TTLs (%d vs %d)", ttl, verify);
2194
2195 ttl = 128;
2196 ret = zsock_setsockopt(client_sock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
2197 zassert_equal(ret, 0, "Cannot set unicast TTL (%d)", -errno);
2198
2199 optlen = sizeof(verify);
2200 ret = zsock_getsockopt(client_sock, IPPROTO_IP, IP_TTL, &verify, &optlen);
2201 zassert_equal(ret, 0, "Cannot get unicast TTL (%d)", -errno);
2202 zassert_equal(verify, ttl, "Different unicast TTL (%d vs %d)",
2203 ttl, verify);
2204
2205 test_check_ttl(client_sock, server_sock, packet_sock,
2206 (struct sockaddr *)&client_addr, sizeof(client_addr),
2207 (struct sockaddr *)&server_addr, sizeof(server_addr),
2208 (struct sockaddr *)&server_addr, sizeof(server_addr),
2209 AF_INET, ttl, 0);
2210 }
2211
ZTEST(net_socket_udp,test_32_v4_mcast_ttl)2212 ZTEST(net_socket_udp, test_32_v4_mcast_ttl)
2213 {
2214 int ret;
2215 int client_sock;
2216 int server_sock;
2217 int packet_sock;
2218 int mcast_ttl, verify;
2219 socklen_t optlen;
2220 struct sockaddr_in client_addr;
2221 struct sockaddr_in server_addr;
2222 struct sockaddr_in sendto_addr;
2223
2224 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2225
2226 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2227 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
2228
2229 packet_sock = zsock_socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
2230 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2231
2232 ret = bind_socket(packet_sock, lo0);
2233 zassert_equal(ret, 0, "packet socket bind failed");
2234
2235 zassert_not_null(lo0->config.ip.ipv4,
2236 "Interface %d (%p) no IPv4 configured",
2237 net_if_get_by_iface(lo0), lo0);
2238
2239 mcast_ttl = 8;
2240 ret = zsock_setsockopt(client_sock, IPPROTO_IP, IP_MULTICAST_TTL, &mcast_ttl,
2241 sizeof(mcast_ttl));
2242 zassert_equal(ret, 0, "Cannot set multicast ttl (%d)", -errno);
2243
2244 optlen = sizeof(verify);
2245 ret = zsock_getsockopt(client_sock, IPPROTO_IP, IP_MULTICAST_TTL, &verify,
2246 &optlen);
2247 zassert_equal(ret, 0, "Cannot get multicast ttl (%d)", -errno);
2248 zassert_equal(verify, mcast_ttl, "Different multicast TTLs (%d vs %d)",
2249 mcast_ttl, verify);
2250
2251 ret = net_addr_pton(AF_INET, MY_MCAST_IPV4_ADDR, &sendto_addr.sin_addr);
2252 zassert_equal(ret, 0, "Cannot get IPv4 address (%d)", ret);
2253
2254 test_check_ttl(client_sock, server_sock, packet_sock,
2255 (struct sockaddr *)&client_addr, sizeof(client_addr),
2256 (struct sockaddr *)&server_addr, sizeof(server_addr),
2257 (struct sockaddr *)&sendto_addr, sizeof(sendto_addr),
2258 AF_INET, 0, mcast_ttl);
2259 }
2260
ZTEST(net_socket_udp,test_33_v6_mcast_hops)2261 ZTEST(net_socket_udp, test_33_v6_mcast_hops)
2262 {
2263 int ret;
2264 int client_sock;
2265 int server_sock;
2266 int packet_sock;
2267 int mcast_hops, if_mcast_hops;
2268 int verify, opt;
2269 socklen_t optlen;
2270 struct sockaddr_in6 client_addr;
2271 struct sockaddr_in6 server_addr;
2272 struct sockaddr_in6 sendto_addr;
2273
2274 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2275
2276 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2277 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
2278
2279 packet_sock = zsock_socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
2280 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2281
2282 ret = bind_socket(packet_sock, lo0);
2283 zassert_equal(ret, 0, "packet socket bind failed");
2284
2285 zassert_not_null(lo0->config.ip.ipv6,
2286 "Interface %d (%p) no IPv6 configured",
2287 net_if_get_by_iface(lo0), lo0);
2288
2289 /* First make sure setting hop limit to -1 works as expected (route default
2290 * value should be used).
2291 */
2292 if_mcast_hops = net_if_ipv6_get_mcast_hop_limit(lo0);
2293
2294 opt = -1;
2295 ret = zsock_setsockopt(client_sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &opt,
2296 sizeof(opt));
2297 zassert_equal(ret, 0, "Cannot set multicast hop limit (%d)", -errno);
2298
2299 optlen = sizeof(verify);
2300 ret = zsock_getsockopt(client_sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &verify,
2301 &optlen);
2302 zassert_equal(ret, 0, "Cannot get multicast hop limit (%d)", -errno);
2303 zassert_equal(verify, if_mcast_hops, "Different multicast hop limit (%d vs %d)",
2304 if_mcast_hops, verify);
2305
2306 /* Then test the normal case where we set the value */
2307 mcast_hops = 8;
2308 ret = zsock_setsockopt(client_sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcast_hops,
2309 sizeof(mcast_hops));
2310 zassert_equal(ret, 0, "Cannot set multicast hop limit (%d)", -errno);
2311
2312 optlen = sizeof(verify);
2313 ret = zsock_getsockopt(client_sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &verify,
2314 &optlen);
2315 zassert_equal(ret, 0, "Cannot get multicast hop limit (%d)", -errno);
2316 zassert_equal(verify, mcast_hops, "Different multicast hop limit (%d vs %d)",
2317 mcast_hops, verify);
2318
2319 ret = net_addr_pton(AF_INET6, MY_MCAST_IPV6_ADDR, &sendto_addr.sin6_addr);
2320 zassert_equal(ret, 0, "Cannot get IPv6 address (%d)", ret);
2321
2322 test_check_ttl(client_sock, server_sock, packet_sock,
2323 (struct sockaddr *)&client_addr, sizeof(client_addr),
2324 (struct sockaddr *)&server_addr, sizeof(server_addr),
2325 (struct sockaddr *)&sendto_addr, sizeof(sendto_addr),
2326 AF_INET6, 0, mcast_hops);
2327 }
2328
ZTEST(net_socket_udp,test_34_v6_hops)2329 ZTEST(net_socket_udp, test_34_v6_hops)
2330 {
2331 int ret;
2332 int client_sock;
2333 int server_sock;
2334 int packet_sock;
2335 int hops, verify;
2336 socklen_t optlen;
2337 struct sockaddr_in6 client_addr;
2338 struct sockaddr_in6 server_addr;
2339
2340 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2341
2342 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2343 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
2344
2345 packet_sock = zsock_socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
2346 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2347
2348 ret = bind_socket(packet_sock, lo0);
2349 zassert_equal(ret, 0, "packet socket bind failed");
2350
2351 zassert_not_null(lo0->config.ip.ipv6,
2352 "Interface %d (%p) no IPv6 configured",
2353 net_if_get_by_iface(lo0), lo0);
2354
2355 hops = 16;
2356 net_if_ipv6_set_hop_limit(lo0, hops);
2357 verify = net_if_ipv6_get_hop_limit(lo0);
2358 zassert_equal(verify, hops, "Different hop limit (%d vs %d)", hops, verify);
2359
2360 hops = 8;
2361 ret = zsock_setsockopt(client_sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &hops,
2362 sizeof(hops));
2363 zassert_equal(ret, 0, "Cannot set unicast hops (%d)", -errno);
2364
2365 optlen = sizeof(verify);
2366 ret = zsock_getsockopt(client_sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &verify,
2367 &optlen);
2368 zassert_equal(ret, 0, "Cannot get unicast hops (%d)", -errno);
2369 zassert_equal(verify, hops, "Different unicast hops (%d vs %d)",
2370 hops, verify);
2371
2372 test_check_ttl(client_sock, server_sock, packet_sock,
2373 (struct sockaddr *)&client_addr, sizeof(client_addr),
2374 (struct sockaddr *)&server_addr, sizeof(server_addr),
2375 (struct sockaddr *)&server_addr, sizeof(server_addr),
2376 AF_INET6, hops, 0);
2377 }
2378
ZTEST_USER(net_socket_udp,test_35_recvmsg_msg_controllen_update)2379 ZTEST_USER(net_socket_udp, test_35_recvmsg_msg_controllen_update)
2380 {
2381 int rv;
2382 int client_sock;
2383 int server_sock;
2384 struct sockaddr_in client_addr;
2385 struct sockaddr_in server_addr;
2386 struct msghdr msg, server_msg;
2387 struct iovec io_vector[1];
2388 union {
2389 struct cmsghdr hdr;
2390 unsigned char buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
2391 } cmsgbuf;
2392
2393 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
2394 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
2395
2396 rv = zsock_bind(server_sock,
2397 (struct sockaddr *)&server_addr,
2398 sizeof(server_addr));
2399 zassert_equal(rv, 0, "server bind failed");
2400
2401 rv = zsock_bind(client_sock,
2402 (struct sockaddr *)&client_addr,
2403 sizeof(client_addr));
2404 zassert_equal(rv, 0, "client bind failed");
2405
2406 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
2407
2408 io_vector[0].iov_base = TEST_STR_SMALL;
2409 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
2410
2411 memset(&msg, 0, sizeof(msg));
2412 msg.msg_iov = io_vector;
2413 msg.msg_iovlen = 1;
2414 msg.msg_name = &server_addr;
2415 msg.msg_namelen = sizeof(server_addr);
2416
2417 comm_sendmsg_recvmsg(client_sock,
2418 (struct sockaddr *)&client_addr,
2419 sizeof(client_addr),
2420 &msg,
2421 server_sock,
2422 (struct sockaddr *)&server_addr,
2423 sizeof(server_addr),
2424 &server_msg,
2425 &cmsgbuf.buf,
2426 sizeof(cmsgbuf.buf),
2427 false);
2428
2429 rv = zsock_close(client_sock);
2430 zassert_equal(rv, 0, "close failed");
2431 rv = zsock_close(server_sock);
2432 zassert_equal(rv, 0, "close failed");
2433 }
2434
ZTEST(net_socket_udp,test_36_v6_address_removal)2435 ZTEST(net_socket_udp, test_36_v6_address_removal)
2436 {
2437 int ret;
2438 bool status;
2439 int client_sock;
2440 struct sockaddr_in6 client_addr;
2441 struct net_if_addr *ifaddr;
2442 struct net_if *iface;
2443
2444 if (!IS_ENABLED(CONFIG_NET_IPV6_PE)) {
2445 return;
2446 }
2447
2448 ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
2449 zassert_equal(ifaddr->atomic_ref, 1, "Ref count is wrong (%ld vs %ld)",
2450 ifaddr->atomic_ref, 1);
2451
2452 prepare_sock_udp_v6(MY_IPV6_ADDR_ETH, CLIENT_PORT, &client_sock, &client_addr);
2453
2454 ret = zsock_bind(client_sock,
2455 (struct sockaddr *)&client_addr,
2456 sizeof(client_addr));
2457 zassert_equal(ret, 0, "client bind failed");
2458
2459 status = net_if_ipv6_addr_rm(eth_iface, &my_addr1);
2460 zassert_false(status, "Address could be removed");
2461
2462 ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
2463 zassert_not_null(ifaddr, "Address %s not found",
2464 net_sprint_ipv6_addr(&my_addr1));
2465
2466 ret = zsock_close(client_sock);
2467 zassert_equal(ret, 0, "close failed");
2468
2469 ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
2470 zassert_equal(iface, eth_iface, "Invalid interface %p vs %p",
2471 iface, eth_iface);
2472 zassert_is_null(ifaddr, "Address %s found",
2473 net_sprint_ipv6_addr(&my_addr1));
2474 }
2475
check_ipv6_address_preferences(struct net_if * iface,uint16_t preference,const struct in6_addr * addr,const struct in6_addr * dest)2476 static void check_ipv6_address_preferences(struct net_if *iface,
2477 uint16_t preference,
2478 const struct in6_addr *addr,
2479 const struct in6_addr *dest)
2480 {
2481 const struct in6_addr *selected;
2482 size_t optlen;
2483 int optval;
2484 int sock;
2485 int ret;
2486
2487 sock = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2488 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2489
2490 optval = preference;
2491 ret = zsock_setsockopt(sock, IPPROTO_IPV6, IPV6_ADDR_PREFERENCES,
2492 &optval, sizeof(optval));
2493 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2494
2495 optval = 0; optlen = 0U;
2496 ret = zsock_getsockopt(sock, IPPROTO_IPV6, IPV6_ADDR_PREFERENCES,
2497 &optval, &optlen);
2498 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2499 zassert_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2500 optlen, sizeof(optval));
2501 zassert_equal(optval, preference,
2502 "getsockopt address preferences");
2503
2504 selected = net_if_ipv6_select_src_addr_hint(iface,
2505 dest,
2506 preference);
2507 ret = net_ipv6_addr_cmp(addr, selected);
2508 zassert_true(ret, "Wrong address %s selected, expected %s",
2509 net_sprint_ipv6_addr(selected),
2510 net_sprint_ipv6_addr(addr));
2511
2512 ret = zsock_close(sock);
2513 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2514 }
2515
ZTEST(net_socket_udp,test_37_ipv6_src_addr_select)2516 ZTEST(net_socket_udp, test_37_ipv6_src_addr_select)
2517 {
2518 struct net_if_addr *ifaddr;
2519 const struct in6_addr dest = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
2520 0, 0, 0, 0, 0, 0, 0, 0x2 } } };
2521
2522 net_if_foreach(iface_cb, ð_iface);
2523 zassert_not_null(eth_iface, "No ethernet interface found");
2524
2525 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr1,
2526 NET_ADDR_AUTOCONF, 0);
2527 if (!ifaddr) {
2528 DBG("Cannot add IPv6 address %s\n",
2529 net_sprint_ipv6_addr(&my_addr1));
2530 zassert_not_null(ifaddr, "addr1");
2531 }
2532
2533 ifaddr->is_temporary = false;
2534
2535 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr3,
2536 NET_ADDR_AUTOCONF, 0);
2537 if (!ifaddr) {
2538 DBG("Cannot add IPv6 address %s\n",
2539 net_sprint_ipv6_addr(&my_addr3));
2540 zassert_not_null(ifaddr, "addr1");
2541 }
2542
2543 ifaddr->is_temporary = true;
2544
2545 net_if_up(eth_iface);
2546
2547 check_ipv6_address_preferences(NULL, IPV6_PREFER_SRC_PUBLIC,
2548 &my_addr1, &dest);
2549 check_ipv6_address_preferences(NULL, IPV6_PREFER_SRC_TMP,
2550 &my_addr3, &dest);
2551 }
2552
ZTEST(net_socket_udp,test_38_ipv6_multicast_ifindex)2553 ZTEST(net_socket_udp, test_38_ipv6_multicast_ifindex)
2554 {
2555 struct sockaddr_in6 saddr6 = {
2556 .sin6_family = AF_INET6,
2557 .sin6_port = htons(SERVER_PORT),
2558 .sin6_addr = my_mcast_addr1,
2559 };
2560 struct net_if_mcast_addr *ifmaddr;
2561 struct net_if_addr *ifaddr;
2562 int server_sock;
2563 size_t addrlen;
2564 size_t optlen;
2565 int ifindex;
2566 int optval;
2567 int sock;
2568 int ret;
2569 int err;
2570
2571 net_if_foreach(iface_cb, ð_iface);
2572 zassert_not_null(eth_iface, "No ethernet interface found");
2573
2574 ifmaddr = net_if_ipv6_maddr_add(eth_iface, &my_mcast_addr1);
2575 if (!ifmaddr) {
2576 DBG("Cannot add IPv6 multicast address %s\n",
2577 net_sprint_ipv6_addr(&my_mcast_addr1));
2578 zassert_not_null(ifmaddr, "mcast_addr1");
2579 }
2580
2581 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr3,
2582 NET_ADDR_AUTOCONF, 0);
2583 if (!ifaddr) {
2584 DBG("Cannot add IPv6 address %s\n",
2585 net_sprint_ipv6_addr(&my_addr3));
2586 zassert_not_null(ifaddr, "addr1");
2587 }
2588
2589 net_if_up(eth_iface);
2590
2591 /* Check that we get the default interface */
2592 sock = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2593 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2594
2595 optval = 0; optlen = 0U;
2596 ret = zsock_getsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2597 &optval, &optlen);
2598 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2599 zexpect_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2600 optlen, sizeof(optval));
2601 ifindex = net_if_get_by_iface(net_if_get_default());
2602 zexpect_equal(optval, ifindex,
2603 "getsockopt multicast ifindex (expected %d got %d)",
2604 ifindex, optval);
2605
2606 ret = zsock_close(sock);
2607 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2608
2609 /* Check failure for IPv4 socket */
2610 sock = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2611 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2612
2613 optval = 0; optlen = 0U;
2614 ret = zsock_getsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2615 &optval, &optlen);
2616 err = -errno;
2617 zexpect_equal(ret, -1, "setsockopt failed (%d)", errno);
2618 zexpect_equal(err, -EAFNOSUPPORT, "setsockopt failed (%d)", errno);
2619 zexpect_equal(optlen, 0U, "setsockopt optlen (%d)", optlen);
2620
2621 ret = zsock_close(sock);
2622 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2623
2624 /* Check that we can set the interface */
2625 sock = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2626 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2627
2628 /* Clear any existing interface value by setting it to 0 */
2629 optval = 0; optlen = sizeof(int);
2630 ret = zsock_setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2631 &optval, optlen);
2632 err = -errno;
2633 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2634 zexpect_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2635 optlen, sizeof(optval));
2636
2637 /* Set the output multicast packet interface to the default interface */
2638 optval = net_if_get_by_iface(net_if_get_default()); optlen = sizeof(int);
2639 ret = zsock_setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2640 &optval, optlen);
2641 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2642 zexpect_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2643 optlen, sizeof(optval));
2644
2645 optval = 0; optlen = 0U;
2646 ret = zsock_getsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
2647 &optval, &optlen);
2648 err = -errno;
2649 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2650 zexpect_equal(optlen, sizeof(int), "setsockopt optlen (%d)", optlen);
2651 zexpect_equal(optval, net_if_get_by_iface(net_if_get_default()),
2652 "getsockopt multicast ifindex (expected %d got %d)",
2653 net_if_get_by_iface(net_if_get_default()), optval);
2654
2655 server_sock = prepare_listen_sock_udp_v6(&saddr6);
2656 zassert_not_equal(server_sock, -1, "Cannot create server socket (%d)", -errno);
2657
2658 test_started = true;
2659 loopback_enable_address_swap(false);
2660
2661 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2662 (struct sockaddr *)&saddr6, sizeof(saddr6));
2663 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2664 "invalid send len (was %d expected %d) (%d)",
2665 ret, STRLEN(TEST_STR_SMALL), -errno);
2666
2667 /* Test that the sent data is received from default interface and
2668 * not the Ethernet one.
2669 */
2670 addrlen = sizeof(saddr6);
2671 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2672 0, (struct sockaddr *)&saddr6, &addrlen);
2673 zexpect_true(ret >= 0, "recvfrom fail");
2674 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2675 "unexpected received bytes");
2676 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2677 "wrong data");
2678
2679 ret = zsock_close(sock);
2680 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2681
2682 ret = zsock_close(server_sock);
2683 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2684
2685 test_started = false;
2686 loopback_enable_address_swap(true);
2687 }
2688
ZTEST(net_socket_udp,test_39_ipv4_multicast_ifindex)2689 ZTEST(net_socket_udp, test_39_ipv4_multicast_ifindex)
2690 {
2691 struct sockaddr_in saddr4 = {
2692 .sin_family = AF_INET,
2693 .sin_port = htons(SERVER_PORT),
2694 .sin_addr = my_mcast_addr2,
2695 };
2696 struct sockaddr_in dst_addr = {
2697 .sin_family = AF_INET,
2698 .sin_port = htons(SERVER_PORT),
2699 .sin_addr = my_mcast_addr2,
2700 };
2701 struct net_if_mcast_addr *ifmaddr;
2702 struct net_if_addr *ifaddr;
2703 struct in_addr addr = { 0 };
2704 struct ip_mreqn mreqn;
2705 struct ip_mreq mreq;
2706 struct net_if *iface;
2707 int server_sock;
2708 size_t addrlen;
2709 size_t optlen;
2710 int ifindex;
2711 int sock;
2712 int ret;
2713 int err;
2714
2715 net_if_foreach(iface_cb, ð_iface);
2716 zassert_not_null(eth_iface, "No ethernet interface found");
2717
2718 ifmaddr = net_if_ipv4_maddr_add(eth_iface, &my_mcast_addr2);
2719 if (!ifmaddr) {
2720 DBG("Cannot add IPv4 multicast address %s\n",
2721 net_sprint_ipv4_addr(&my_mcast_addr2));
2722 zassert_not_null(ifmaddr, "mcast_addr2");
2723 }
2724
2725 ifaddr = net_if_ipv4_addr_add(eth_iface, &my_addr2,
2726 NET_ADDR_MANUAL, 0);
2727 if (!ifaddr) {
2728 DBG("Cannot add IPv4 address %s\n",
2729 net_sprint_ipv4_addr(&my_addr2));
2730 zassert_not_null(ifaddr, "addr2");
2731 }
2732
2733 net_if_up(eth_iface);
2734
2735 /* Check that we get the default interface */
2736 sock = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2737 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2738
2739 optlen = sizeof(addr);
2740 ret = zsock_getsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2741 &addr, &optlen);
2742 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2743 zexpect_equal(optlen, sizeof(addr), "invalid optlen %d vs %d",
2744 optlen, sizeof(addr));
2745 ifindex = net_if_get_by_iface(net_if_get_default());
2746 ret = net_if_ipv4_addr_lookup_by_index(&addr);
2747 zexpect_equal(ret, ifindex,
2748 "getsockopt multicast ifindex (expected %d got %d)",
2749 ifindex, ret);
2750
2751 ret = zsock_close(sock);
2752 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2753
2754 /* Check failure for IPv6 socket */
2755 sock = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
2756 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2757
2758 optlen = 0U;
2759 ret = zsock_getsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2760 &addr, &optlen);
2761 err = -errno;
2762 zexpect_equal(ret, -1, "setsockopt failed (%d)", errno);
2763 zexpect_equal(err, -EAFNOSUPPORT, "setsockopt failed (%d)", errno);
2764 zexpect_equal(optlen, 0U, "setsockopt optlen (%d)", optlen);
2765
2766 ret = zsock_close(sock);
2767 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2768
2769 /* Check that we can set the interface */
2770 sock = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
2771 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2772
2773 /* Clear any existing interface value by setting it to 0 */
2774 optlen = sizeof(mreqn);
2775 mreqn.imr_ifindex = 0;
2776 mreqn.imr_address.s_addr = 0;
2777
2778 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2779 &mreqn, optlen);
2780 err = -errno;
2781 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2782
2783 /* Verify that we get the empty value */
2784 optlen = sizeof(addr);
2785 ret = zsock_getsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2786 &addr, &optlen);
2787 err = -errno;
2788 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2789 zexpect_equal(optlen, sizeof(addr), "setsockopt optlen (%d)", optlen);
2790
2791 /* Set the output multicast packet interface to the default interface */
2792 optlen = sizeof(mreqn);
2793 mreqn.imr_ifindex = net_if_get_by_iface(net_if_get_default());
2794 mreqn.imr_address.s_addr = 0;
2795
2796 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2797 &mreqn, optlen);
2798 err = -errno;
2799 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2800
2801 /* Verify that we get the default interface */
2802 optlen = sizeof(addr);
2803 memset(&addr, 0, sizeof(addr));
2804 ret = zsock_getsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2805 &addr, &optlen);
2806 err = -errno;
2807 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2808 zexpect_equal(optlen, sizeof(addr), "setsockopt optlen (%d)", optlen);
2809
2810 ifaddr = net_if_ipv4_addr_lookup(&addr, &iface);
2811 zexpect_not_null(ifaddr, "Address %s not found",
2812 net_sprint_ipv4_addr(&addr));
2813 zexpect_equal(net_if_get_by_iface(iface),
2814 net_if_get_by_iface(net_if_get_default()),
2815 "Invalid interface %d vs %d",
2816 net_if_get_by_iface(iface),
2817 net_if_get_by_iface(net_if_get_default()));
2818
2819 /* Now send a packet and verify that it is sent via the default
2820 * interface instead of the Ethernet interface.
2821 */
2822 server_sock = prepare_listen_sock_udp_v4(&saddr4);
2823 zassert_not_equal(server_sock, -1, "Cannot create server socket (%d)", -errno);
2824
2825 test_started = true;
2826 loopback_enable_address_swap(false);
2827
2828 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2829 (struct sockaddr *)&dst_addr, sizeof(dst_addr));
2830 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2831 "invalid send len (was %d expected %d) (%d)",
2832 ret, STRLEN(TEST_STR_SMALL), -errno);
2833
2834 /* Test that the sent data is received from Ethernet interface. */
2835 addrlen = sizeof(saddr4);
2836 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2837 0, (struct sockaddr *)&saddr4, &addrlen);
2838 zexpect_true(ret >= 0, "recvfrom fail");
2839 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2840 "unexpected received bytes");
2841 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2842 "wrong data");
2843
2844 /* Clear the old interface value by setting it to 0 */
2845 optlen = sizeof(mreqn);
2846 mreqn.imr_ifindex = 0;
2847 mreqn.imr_address.s_addr = 0;
2848
2849 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2850 &mreqn, optlen);
2851 err = -errno;
2852 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2853
2854 /* Then do it the other way around, set the address but leave the
2855 * interface number unassigned.
2856 */
2857 optlen = sizeof(mreqn);
2858 mreqn.imr_ifindex = 0;
2859
2860 /* Get the address of default interface and set it as a target
2861 * interface.
2862 */
2863 ifaddr = net_if_ipv4_addr_get_first_by_index(net_if_get_by_iface(net_if_get_default()));
2864 zexpect_not_null(ifaddr, "No address found for interface %d",
2865 net_if_get_by_iface(net_if_get_default()));
2866 mreqn.imr_address.s_addr = ifaddr->address.in_addr.s_addr;
2867
2868 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2869 &mreqn, optlen);
2870 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2871
2872 /* Verify that we get the default interface address */
2873 optlen = sizeof(struct in_addr);
2874 ret = zsock_getsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2875 &addr, &optlen);
2876 err = -errno;
2877 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2878 zexpect_equal(optlen, sizeof(struct in_addr), "setsockopt optlen (%d)", optlen);
2879 ret = net_if_ipv4_addr_lookup_by_index(&addr);
2880 zexpect_equal(ret, net_if_get_by_iface(net_if_get_default()),
2881 "getsockopt multicast ifindex (expected %d got %d)",
2882 net_if_get_by_iface(net_if_get_default()), ret);
2883 zexpect_equal(ifaddr->address.in_addr.s_addr,
2884 addr.s_addr,
2885 "getsockopt iface address mismatch (expected %s got %s)",
2886 net_sprint_ipv4_addr(&ifaddr->address.in_addr),
2887 net_sprint_ipv4_addr(&addr));
2888
2889 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2890 (struct sockaddr *)&dst_addr, sizeof(dst_addr));
2891 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2892 "invalid send len (was %d expected %d) (%d)",
2893 ret, STRLEN(TEST_STR_SMALL), -errno);
2894
2895 /* Test that the sent data is received from default interface. */
2896 addrlen = sizeof(saddr4);
2897 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2898 0, (struct sockaddr *)&saddr4, &addrlen);
2899 zexpect_true(ret >= 0, "recvfrom fail");
2900 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2901 "unexpected received bytes");
2902 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2903 "wrong data");
2904
2905 /* Then use mreq structure to set the interface */
2906 optlen = sizeof(mreq);
2907 ifaddr = net_if_ipv4_addr_get_first_by_index(net_if_get_by_iface(net_if_get_default()));
2908 zexpect_not_null(ifaddr, "No address found for interface %d",
2909 net_if_get_by_iface(net_if_get_default()));
2910 mreq.imr_interface.s_addr = ifaddr->address.in_addr.s_addr;
2911
2912 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
2913 &mreq, optlen);
2914 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2915
2916 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2917 (struct sockaddr *)&dst_addr, sizeof(dst_addr));
2918 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2919 "invalid send len (was %d expected %d) (%d)",
2920 ret, STRLEN(TEST_STR_SMALL), -errno);
2921
2922 /* Test that the sent data is received from default interface. */
2923 addrlen = sizeof(saddr4);
2924 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2925 0, (struct sockaddr *)&saddr4, &addrlen);
2926 zexpect_true(ret >= 0, "recvfrom fail");
2927 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2928 "unexpected received bytes");
2929 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2930 "wrong data");
2931
2932 ret = zsock_close(sock);
2933 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2934
2935 ret = zsock_close(server_sock);
2936 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2937
2938 test_started = false;
2939 loopback_enable_address_swap(true);
2940 }
2941
2942 #if defined(CONFIG_NET_CONTEXT_CLAMP_PORT_RANGE)
2943
2944 #define PORT_RANGE(lower, upper) \
2945 (uint32_t)(((uint16_t)(upper) << 16) | (uint16_t)(lower))
2946
check_port_range(struct sockaddr * my_addr,size_t my_addr_len,struct sockaddr * local_addr,size_t local_addr_len)2947 static void check_port_range(struct sockaddr *my_addr,
2948 size_t my_addr_len,
2949 struct sockaddr *local_addr,
2950 size_t local_addr_len)
2951 {
2952 sa_family_t family = AF_UNSPEC;
2953 uint32_t optval;
2954 size_t addr_len;
2955 size_t optlen;
2956 int sock;
2957 int ret, err;
2958
2959 addr_len = local_addr_len;
2960
2961 if (my_addr->sa_family == AF_INET) {
2962 family = AF_INET;
2963 } else if (my_addr->sa_family == AF_INET6) {
2964 family = AF_INET6;
2965 } else {
2966 zassert_true(false, "Invalid address family %d",
2967 my_addr->sa_family);
2968 }
2969
2970 sock = zsock_socket(family, SOCK_DGRAM, IPPROTO_UDP);
2971 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2972
2973 optval = PORT_RANGE(1024, 1500);
2974 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
2975 &optval, sizeof(optval));
2976 err = -errno;
2977 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2978
2979 optval = 0; optlen = 0U;
2980 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
2981 &optval, optlen);
2982 err = -errno;
2983 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
2984
2985 optval = 0; optlen = sizeof(uint64_t);
2986 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
2987 &optval, optlen);
2988 err = -errno;
2989 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
2990
2991 optval = PORT_RANGE(0, 0);
2992 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
2993 &optval, sizeof(optval));
2994 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2995
2996 /* Linux allows setting the invalid port range but that is not
2997 * then taken into use when we bind the socket.
2998 */
2999 optval = PORT_RANGE(1024, 0);
3000 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3001 &optval, sizeof(optval));
3002 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
3003
3004 optval = PORT_RANGE(0, 1024);
3005 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3006 &optval, sizeof(optval));
3007 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
3008
3009 /* Then set a valid range and verify that bound socket is using it */
3010 optval = PORT_RANGE(10000, 10010);
3011 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3012 &optval, sizeof(optval));
3013 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
3014
3015 optval = 0; optlen = sizeof(optval);
3016 ret = zsock_getsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3017 &optval, &optlen);
3018 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
3019 zexpect_equal(optval, PORT_RANGE(10000, 10010), "Invalid port range");
3020
3021 ret = zsock_bind(sock, my_addr, my_addr_len);
3022 err = -errno;
3023 zexpect_equal(ret, 0, "bind failed (%d)", err);
3024
3025 ret = zsock_getsockname(sock, local_addr, &addr_len);
3026 err = -errno;
3027 zexpect_equal(ret, 0, "getsockname failed (%d)", err);
3028
3029 /* The port should be in the range */
3030 zexpect_true(ntohs(net_sin(local_addr)->sin_port) >= 10000 &&
3031 ntohs(net_sin(local_addr)->sin_port) <= 10010,
3032 "Invalid port %d", ntohs(net_sin(local_addr)->sin_port));
3033
3034 (void)zsock_close(sock);
3035
3036 /* Try setting invalid range and verify that we do not net a port from that
3037 * range.
3038 */
3039 sock = zsock_socket(family, SOCK_DGRAM, IPPROTO_UDP);
3040 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
3041
3042 optval = PORT_RANGE(1001, 1000);
3043 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3044 &optval, sizeof(optval));
3045 err = -errno;
3046 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
3047 zexpect_equal(err, -EINVAL, "Invalid errno (%d)", -err);
3048
3049 /* Port range cannot be just one port */
3050 optval = PORT_RANGE(1001, 1001);
3051 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3052 &optval, sizeof(optval));
3053 err = -errno;
3054 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
3055 zexpect_equal(err, -EINVAL, "Invalid errno (%d)", -err);
3056
3057 optval = PORT_RANGE(0, 1000);
3058 ret = zsock_setsockopt(sock, IPPROTO_IP, IP_LOCAL_PORT_RANGE,
3059 &optval, sizeof(optval));
3060 err = -errno;
3061 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
3062
3063 ret = zsock_bind(sock, my_addr, my_addr_len);
3064 err = -errno;
3065 zexpect_equal(ret, 0, "bind failed (%d)", err);
3066
3067 addr_len = local_addr_len;
3068 ret = zsock_getsockname(sock, local_addr, &addr_len);
3069 err = -errno;
3070 zexpect_equal(ret, 0, "getsockname failed (%d)", err);
3071
3072 /* The port should not be in the range */
3073 zexpect_false(ntohs(net_sin(local_addr)->sin_port) >= 1000 &&
3074 ntohs(net_sin(local_addr)->sin_port) <= 1001,
3075 "Invalid port %d", ntohs(net_sin(local_addr)->sin_port));
3076
3077 (void)zsock_close(sock);
3078 }
3079 #endif
3080
ZTEST(net_socket_udp,test_40_clamp_udp_tcp_port_range)3081 ZTEST(net_socket_udp, test_40_clamp_udp_tcp_port_range)
3082 {
3083 #if defined(CONFIG_NET_CONTEXT_CLAMP_PORT_RANGE)
3084 struct sockaddr_in my_addr4 = {
3085 .sin_family = AF_INET,
3086 .sin_port = 0,
3087 .sin_addr = { { { 192, 0, 2, 2 } } },
3088 };
3089 struct sockaddr_in6 my_addr6 = {
3090 .sin6_family = AF_INET6,
3091 .sin6_port = 0,
3092 .sin6_addr = in6addr_loopback,
3093 };
3094 struct sockaddr_in local_addr4;
3095 struct sockaddr_in6 local_addr6;
3096
3097 /* First try with a IPv4 socket */
3098 check_port_range((struct sockaddr *)&my_addr4, sizeof(my_addr4),
3099 (struct sockaddr *)&local_addr4, sizeof(local_addr4));
3100
3101 /* Finally try with a IPv6 socket */
3102 check_port_range((struct sockaddr *)&my_addr6, sizeof(my_addr6),
3103 (struct sockaddr *)&local_addr6, sizeof(local_addr6));
3104 #else
3105 ztest_test_skip();
3106 #endif
3107 }
3108
after(void * arg)3109 static void after(void *arg)
3110 {
3111 ARG_UNUSED(arg);
3112
3113 for (int i = 0; i < CONFIG_ZVFS_OPEN_MAX; ++i) {
3114 (void)zsock_close(i);
3115 }
3116 }
3117
3118 ZTEST_SUITE(net_socket_udp, NULL, NULL, NULL, after, NULL);
3119
