1 /*
2 * Copyright (c) 2017 Linaro Limited
3 * Copyright (c) 2021 Nordic Semiconductor
4 * Copyright 2025 NXP
5 *
6 * SPDX-License-Identifier: Apache-2.0
7 */
8
9 #include <zephyr/logging/log.h>
10 LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
11
12 #include <stdio.h>
13 #include <zephyr/sys/sem.h>
14 #include <zephyr/ztest_assert.h>
15
16 #include <zephyr/net/socket.h>
17 #include <zephyr/net/ethernet.h>
18 #include <zephyr/net/net_mgmt.h>
19 #include <zephyr/net/net_event.h>
20
21 #include "ipv6.h"
22 #include "net_private.h"
23 #include "../../socket_helpers.h"
24
25 #if defined(CONFIG_NET_SOCKETS_LOG_LEVEL_DBG)
26 #define DBG(fmt, ...) printk(fmt, ##__VA_ARGS__)
27 #else
28 #define DBG(fmt, ...)
29 #endif
30
31 #define BUF_AND_SIZE(buf) buf, sizeof(buf) - 1
32 #define STRLEN(buf) (sizeof(buf) - 1)
33
34 #define TEST_STR_SMALL "test"
35 /* More than 256 bytes, to use >1 net_buf. */
36 #define TEST_STR2 \
37 "The Zephyr Project, a Linux Foundation hosted Collaboration " \
38 "Project, is an open source collaborative effort uniting leaders " \
39 "from across the industry to build a best-in-breed small, scalable, " \
40 "real-time operating system (RTOS) optimized for resource-" \
41 "constrained devices, across multiple architectures."
42 /* More than available TX buffers */
43 static const char test_str_all_tx_bufs[] =
44 #include <string_all_tx_bufs.inc>
45 "!"
46 ;
47
48 #define MY_IPV4_ADDR "127.0.0.1"
49 #define MY_IPV4_MAPPED_ADDR "::ffff:127.0.0.1"
50 #define MY_IPV6_ADDR "::1"
51 #define MY_MCAST_IPV4_ADDR "224.0.0.1"
52 #define MY_MCAST_IPV6_ADDR "ff01::1"
53 #define ANY_IPV6_ADDR "::"
54
55 #define ANY_PORT 0
56 #define SERVER_PORT 4242
57 #define CLIENT_PORT 9898
58
59 static ZTEST_BMEM char rx_buf[NET_ETH_MTU + 1];
60
61 /* Common routine to communicate packets over pair of sockets. */
comm_sendto_recvfrom(int client_sock,struct net_sockaddr * client_addr,net_socklen_t client_addrlen,int server_sock,struct net_sockaddr * server_addr,net_socklen_t server_addrlen)62 static void comm_sendto_recvfrom(int client_sock,
63 struct net_sockaddr *client_addr,
64 net_socklen_t client_addrlen,
65 int server_sock,
66 struct net_sockaddr *server_addr,
67 net_socklen_t server_addrlen)
68 {
69 int avail;
70 ssize_t sent = 0;
71 ssize_t recved = 0;
72 struct net_sockaddr addr;
73 net_socklen_t addrlen;
74 struct net_sockaddr addr2;
75 net_socklen_t addrlen2;
76
77 zassert_not_null(client_addr, "null client addr");
78 zassert_not_null(server_addr, "null server addr");
79
80 /*
81 * Test client -> server sending
82 */
83
84 sent = zsock_sendto(client_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL),
85 0, server_addr, server_addrlen);
86 zassert_equal(sent, strlen(TEST_STR_SMALL), "sendto failed");
87
88 k_msleep(100);
89
90 avail = 42;
91 zassert_ok(zsock_ioctl(server_sock, ZFD_IOCTL_FIONREAD, &avail));
92 zassert_equal(avail, strlen(TEST_STR_SMALL));
93
94 /* Test recvfrom(MSG_PEEK) */
95 addrlen = sizeof(addr);
96 clear_buf(rx_buf);
97 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
98 ZSOCK_MSG_PEEK, &addr, &addrlen);
99 zassert_true(recved >= 0, "recvfrom fail");
100 zassert_equal(recved, strlen(TEST_STR_SMALL),
101 "unexpected received bytes");
102 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
103 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
104
105 /* Test normal recvfrom() */
106 addrlen = sizeof(addr);
107 clear_buf(rx_buf);
108 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
109 0, &addr, &addrlen);
110 zassert_true(recved >= 0, "recvfrom fail");
111 zassert_equal(recved, strlen(TEST_STR_SMALL),
112 "unexpected received bytes");
113 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
114 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
115
116 /* Check the client port */
117 if (net_sin(client_addr)->sin_port != ANY_PORT) {
118 zassert_equal(net_sin(client_addr)->sin_port,
119 net_sin(&addr)->sin_port,
120 "unexpected client port");
121 }
122
123 /*
124 * Test server -> client sending
125 */
126
127 sent = zsock_sendto(server_sock, TEST_STR2, sizeof(TEST_STR2) - 1,
128 0, &addr, addrlen);
129 zassert_equal(sent, STRLEN(TEST_STR2), "sendto failed");
130
131 /* Test normal recvfrom() */
132 addrlen2 = sizeof(addr);
133 clear_buf(rx_buf);
134 recved = zsock_recvfrom(client_sock, rx_buf, sizeof(rx_buf),
135 0, &addr2, &addrlen2);
136 zassert_true(recved >= 0, "recvfrom fail");
137 zassert_equal(recved, STRLEN(TEST_STR2),
138 "unexpected received bytes");
139 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR2), "wrong data");
140 zassert_equal(addrlen2, server_addrlen, "unexpected addrlen");
141
142 /* Check the server port */
143 zassert_equal(net_sin(server_addr)->sin_port,
144 net_sin(&addr2)->sin_port,
145 "unexpected server port");
146
147 /* Test that unleft leftover data from datagram is discarded. */
148
149 /* Send 2 datagrams */
150 sent = zsock_sendto(server_sock, TEST_STR2, sizeof(TEST_STR2) - 1,
151 0, &addr, addrlen);
152 zassert_equal(sent, STRLEN(TEST_STR2), "sendto failed");
153 sent = zsock_sendto(server_sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
154 0, &addr, addrlen);
155 zassert_equal(sent, STRLEN(TEST_STR_SMALL), "sendto failed");
156
157 /* Receive just beginning of 1st datagram */
158 addrlen2 = sizeof(addr);
159 clear_buf(rx_buf);
160 recved = zsock_recvfrom(client_sock, rx_buf, 16, 0, &addr2, &addrlen2);
161 zassert_true(recved == 16, "recvfrom fail");
162 zassert_mem_equal(rx_buf, TEST_STR2, 16, "wrong data");
163
164 /* Make sure that now we receive 2nd datagram */
165 addrlen2 = sizeof(addr);
166 clear_buf(rx_buf);
167 recved = zsock_recvfrom(client_sock, rx_buf, 16, 0, &addr2, &addrlen2);
168 zassert_true(recved == STRLEN(TEST_STR_SMALL), "recvfrom fail");
169 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
170 }
171
ZTEST(net_socket_udp,test_v4_sendto_recvfrom)172 ZTEST(net_socket_udp, test_v4_sendto_recvfrom)
173 {
174 int rv;
175 int client_sock;
176 int server_sock;
177 struct net_sockaddr_in client_addr;
178 struct net_sockaddr_in server_addr;
179
180 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
181 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
182
183 rv = zsock_bind(server_sock,
184 (struct net_sockaddr *)&server_addr,
185 sizeof(server_addr));
186 zassert_equal(rv, 0, "bind failed");
187
188 comm_sendto_recvfrom(client_sock,
189 (struct net_sockaddr *)&client_addr,
190 sizeof(client_addr),
191 server_sock,
192 (struct net_sockaddr *)&server_addr,
193 sizeof(server_addr));
194
195 rv = zsock_close(client_sock);
196 zassert_equal(rv, 0, "close failed");
197 rv = zsock_close(server_sock);
198 zassert_equal(rv, 0, "close failed");
199 }
200
ZTEST(net_socket_udp,test_v6_sendto_recvfrom)201 ZTEST(net_socket_udp, test_v6_sendto_recvfrom)
202 {
203 int rv;
204 int client_sock;
205 int server_sock;
206 struct net_sockaddr_in6 client_addr;
207 struct net_sockaddr_in6 server_addr;
208
209 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
210 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
211
212 rv = zsock_bind(server_sock,
213 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
214 zassert_equal(rv, 0, "bind failed");
215
216 comm_sendto_recvfrom(client_sock,
217 (struct net_sockaddr *)&client_addr,
218 sizeof(client_addr),
219 server_sock,
220 (struct net_sockaddr *)&server_addr,
221 sizeof(server_addr));
222
223 rv = zsock_close(client_sock);
224 zassert_equal(rv, 0, "close failed");
225 rv = zsock_close(server_sock);
226 zassert_equal(rv, 0, "close failed");
227 }
228
ZTEST(net_socket_udp,test_v4_bind_sendto)229 ZTEST(net_socket_udp, test_v4_bind_sendto)
230 {
231 int rv;
232 int client_sock;
233 int server_sock;
234 struct net_sockaddr_in client_addr;
235 struct net_sockaddr_in server_addr;
236
237 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
238 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
239
240 rv = zsock_bind(client_sock,
241 (struct net_sockaddr *)&client_addr, sizeof(client_addr));
242 zassert_equal(rv, 0, "bind failed");
243
244 rv = zsock_bind(server_sock,
245 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
246 zassert_equal(rv, 0, "bind failed");
247
248 comm_sendto_recvfrom(client_sock,
249 (struct net_sockaddr *)&client_addr,
250 sizeof(client_addr),
251 server_sock,
252 (struct net_sockaddr *)&server_addr,
253 sizeof(server_addr));
254
255 rv = zsock_close(client_sock);
256 zassert_equal(rv, 0, "close failed");
257 rv = zsock_close(server_sock);
258 zassert_equal(rv, 0, "close failed");
259 }
260
ZTEST(net_socket_udp,test_v6_bind_sendto)261 ZTEST(net_socket_udp, test_v6_bind_sendto)
262 {
263 int rv;
264 int client_sock;
265 int server_sock;
266 struct net_sockaddr_in6 client_addr;
267 struct net_sockaddr_in6 server_addr;
268
269 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
270 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
271
272 rv = zsock_bind(client_sock,
273 (struct net_sockaddr *)&client_addr, sizeof(client_addr));
274 zassert_equal(rv, 0, "bind failed");
275
276 rv = zsock_bind(server_sock,
277 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
278 zassert_equal(rv, 0, "bind failed");
279
280 comm_sendto_recvfrom(client_sock,
281 (struct net_sockaddr *)&client_addr,
282 sizeof(client_addr),
283 server_sock,
284 (struct net_sockaddr *)&server_addr,
285 sizeof(server_addr));
286
287 rv = zsock_close(client_sock);
288 zassert_equal(rv, 0, "close failed");
289 rv = zsock_close(server_sock);
290 zassert_equal(rv, 0, "close failed");
291 }
292
ZTEST(net_socket_udp,test_send_recv_2_sock)293 ZTEST(net_socket_udp, test_send_recv_2_sock)
294 {
295 int sock1, sock2;
296 struct net_sockaddr_in bind_addr, conn_addr;
297 char buf[10];
298 int len, rv;
299
300 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr);
301 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock2, &conn_addr);
302
303 rv = zsock_bind(sock1, (struct net_sockaddr *)&bind_addr, sizeof(bind_addr));
304 zassert_equal(rv, 0, "bind failed");
305
306 rv = zsock_connect(sock2, (struct net_sockaddr *)&conn_addr, sizeof(conn_addr));
307 zassert_equal(rv, 0, "connect failed");
308
309 len = zsock_send(sock2, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0);
310 zassert_equal(len, STRLEN(TEST_STR_SMALL), "invalid send len");
311
312 clear_buf(buf);
313 len = zsock_recv(sock1, buf, sizeof(buf), ZSOCK_MSG_PEEK);
314 zassert_equal(len, STRLEN(TEST_STR_SMALL), "Invalid recv len");
315 zassert_mem_equal(buf, BUF_AND_SIZE(TEST_STR_SMALL), "Wrong data");
316
317 clear_buf(buf);
318 len = zsock_recv(sock1, buf, sizeof(buf), 0);
319 zassert_equal(len, STRLEN(TEST_STR_SMALL), "Invalid recv len");
320 zassert_mem_equal(buf, BUF_AND_SIZE(TEST_STR_SMALL), "Wrong data");
321
322 rv = zsock_close(sock1);
323 zassert_equal(rv, 0, "close failed");
324 rv = zsock_close(sock2);
325 zassert_equal(rv, 0, "close failed");
326 }
327
ZTEST(net_socket_udp,test_so_priority)328 ZTEST(net_socket_udp, test_so_priority)
329 {
330 struct net_sockaddr_in bind_addr4;
331 struct net_sockaddr_in6 bind_addr6;
332 int sock1, sock2, rv;
333 uint8_t optval;
334
335 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
336 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
337
338 rv = zsock_bind(sock1, (struct net_sockaddr *)&bind_addr4, sizeof(bind_addr4));
339 zassert_equal(rv, 0, "bind failed");
340
341 rv = zsock_bind(sock2, (struct net_sockaddr *)&bind_addr6, sizeof(bind_addr6));
342 zassert_equal(rv, 0, "bind failed");
343
344 optval = 2;
345 rv = zsock_setsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_PRIORITY, &optval,
346 sizeof(optval));
347 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
348
349 optval = 6;
350 rv = zsock_setsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_PRIORITY, &optval,
351 sizeof(optval));
352 zassert_equal(rv, 0, "setsockopt failed");
353
354 rv = zsock_close(sock1);
355 zassert_equal(rv, 0, "close failed");
356 rv = zsock_close(sock2);
357 zassert_equal(rv, 0, "close failed");
358 }
359
comm_sendmsg_recvfrom(int client_sock,struct net_sockaddr * client_addr,net_socklen_t client_addrlen,const struct net_msghdr * client_msg,int server_sock,struct net_sockaddr * server_addr,net_socklen_t server_addrlen)360 static void comm_sendmsg_recvfrom(int client_sock,
361 struct net_sockaddr *client_addr,
362 net_socklen_t client_addrlen,
363 const struct net_msghdr *client_msg,
364 int server_sock,
365 struct net_sockaddr *server_addr,
366 net_socklen_t server_addrlen)
367 {
368 ssize_t sent;
369 ssize_t recved;
370 struct net_sockaddr addr;
371 net_socklen_t addrlen;
372 int len, i;
373
374 zassert_not_null(client_addr, "null client addr");
375 zassert_not_null(server_addr, "null server addr");
376
377 /*
378 * Test client -> server sending
379 */
380
381 sent = zsock_sendmsg(client_sock, client_msg, 0);
382 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
383
384 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
385 len += client_msg->msg_iov[i].iov_len;
386 }
387
388 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
389
390 /* Test recvfrom(MSG_PEEK) */
391 addrlen = sizeof(addr);
392 clear_buf(rx_buf);
393 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
394 ZSOCK_MSG_PEEK, &addr, &addrlen);
395 zassert_true(recved >= 0, "recvfrom fail");
396 zassert_equal(recved, strlen(TEST_STR_SMALL),
397 "unexpected received bytes");
398 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
399 sent, recved);
400
401 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL),
402 "wrong data (%s)", rx_buf);
403 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
404
405 /* Test normal recvfrom() */
406 addrlen = sizeof(addr);
407 clear_buf(rx_buf);
408 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
409 0, &addr, &addrlen);
410 zassert_true(recved >= 0, "recvfrom fail");
411 zassert_equal(recved, strlen(TEST_STR_SMALL),
412 "unexpected received bytes");
413 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
414 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
415
416 /* Check the client port */
417 if (net_sin(client_addr)->sin_port != ANY_PORT) {
418 zassert_equal(net_sin(client_addr)->sin_port,
419 net_sin(&addr)->sin_port,
420 "unexpected client port");
421 }
422 }
423
ZTEST_USER(net_socket_udp,test_v4_sendmsg_recvfrom)424 ZTEST_USER(net_socket_udp, test_v4_sendmsg_recvfrom)
425 {
426 int rv;
427 int client_sock;
428 int server_sock;
429 struct net_sockaddr_in client_addr;
430 struct net_sockaddr_in server_addr;
431 struct net_msghdr msg;
432 struct net_cmsghdr *cmsg;
433 struct net_iovec io_vector[1];
434 union {
435 struct net_cmsghdr hdr;
436 unsigned char buf[NET_CMSG_SPACE(sizeof(int))];
437 } cmsgbuf;
438
439 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
440 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
441
442 rv = zsock_bind(server_sock,
443 (struct net_sockaddr *)&server_addr,
444 sizeof(server_addr));
445 zassert_equal(rv, 0, "server bind failed");
446
447 rv = zsock_bind(client_sock,
448 (struct net_sockaddr *)&client_addr,
449 sizeof(client_addr));
450 zassert_equal(rv, 0, "client bind failed");
451
452 io_vector[0].iov_base = TEST_STR_SMALL;
453 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
454
455 memset(&msg, 0, sizeof(msg));
456 msg.msg_control = &cmsgbuf.buf;
457 msg.msg_controllen = sizeof(cmsgbuf.buf);
458 msg.msg_iov = io_vector;
459 msg.msg_iovlen = 1;
460 msg.msg_name = &server_addr;
461 msg.msg_namelen = sizeof(server_addr);
462
463 cmsg = NET_CMSG_FIRSTHDR(&msg);
464 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
465 cmsg->cmsg_level = ZSOCK_SOL_SOCKET;
466 cmsg->cmsg_type = 1122;
467 *(int *)NET_CMSG_DATA(cmsg) = 42;
468
469 comm_sendmsg_recvfrom(client_sock,
470 (struct net_sockaddr *)&client_addr,
471 sizeof(client_addr),
472 &msg,
473 server_sock,
474 (struct net_sockaddr *)&server_addr,
475 sizeof(server_addr));
476
477 rv = zsock_close(client_sock);
478 zassert_equal(rv, 0, "close failed");
479 rv = zsock_close(server_sock);
480 zassert_equal(rv, 0, "close failed");
481 }
482
ZTEST_USER(net_socket_udp,test_v4_sendmsg_recvfrom_no_aux_data)483 ZTEST_USER(net_socket_udp, test_v4_sendmsg_recvfrom_no_aux_data)
484 {
485 int rv;
486 int client_sock;
487 int server_sock;
488 struct net_sockaddr_in client_addr;
489 struct net_sockaddr_in server_addr;
490 struct net_msghdr msg;
491 struct net_iovec io_vector[1];
492
493 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
494 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
495
496 rv = zsock_bind(server_sock,
497 (struct net_sockaddr *)&server_addr,
498 sizeof(server_addr));
499 zassert_equal(rv, 0, "server bind failed");
500
501 rv = zsock_bind(client_sock,
502 (struct net_sockaddr *)&client_addr,
503 sizeof(client_addr));
504 zassert_equal(rv, 0, "client bind failed");
505
506 io_vector[0].iov_base = TEST_STR_SMALL;
507 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
508
509 memset(&msg, 0, sizeof(msg));
510 msg.msg_iov = io_vector;
511 msg.msg_iovlen = 1;
512 msg.msg_name = &server_addr;
513 msg.msg_namelen = sizeof(server_addr);
514
515 comm_sendmsg_recvfrom(client_sock,
516 (struct net_sockaddr *)&client_addr,
517 sizeof(client_addr),
518 &msg,
519 server_sock,
520 (struct net_sockaddr *)&server_addr,
521 sizeof(server_addr));
522
523 rv = zsock_close(client_sock);
524 zassert_equal(rv, 0, "close failed");
525 rv = zsock_close(server_sock);
526 zassert_equal(rv, 0, "close failed");
527 }
528
ZTEST_USER(net_socket_udp,test_v6_sendmsg_recvfrom)529 ZTEST_USER(net_socket_udp, test_v6_sendmsg_recvfrom)
530 {
531 int rv;
532 int client_sock;
533 int server_sock;
534 struct net_sockaddr_in6 client_addr;
535 struct net_sockaddr_in6 server_addr;
536 struct net_msghdr msg;
537 struct net_cmsghdr *cmsg;
538 struct net_iovec io_vector[1];
539 union {
540 struct net_cmsghdr hdr;
541 unsigned char buf[NET_CMSG_SPACE(sizeof(int))];
542 } cmsgbuf;
543
544 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
545 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
546
547 rv = zsock_bind(server_sock,
548 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
549 zassert_equal(rv, 0, "server bind failed");
550
551 rv = zsock_bind(client_sock,
552 (struct net_sockaddr *)&client_addr,
553 sizeof(client_addr));
554 zassert_equal(rv, 0, "client bind failed");
555
556 io_vector[0].iov_base = TEST_STR_SMALL;
557 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
558
559 memset(&msg, 0, sizeof(msg));
560 msg.msg_control = &cmsgbuf.buf;
561 msg.msg_controllen = sizeof(cmsgbuf.buf);
562 msg.msg_iov = io_vector;
563 msg.msg_iovlen = 1;
564 msg.msg_name = &server_addr;
565 msg.msg_namelen = sizeof(server_addr);
566
567 cmsg = NET_CMSG_FIRSTHDR(&msg);
568 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
569 cmsg->cmsg_level = ZSOCK_SOL_SOCKET;
570 cmsg->cmsg_type = 1122;
571 *(int *)NET_CMSG_DATA(cmsg) = 42;
572
573 comm_sendmsg_recvfrom(client_sock,
574 (struct net_sockaddr *)&client_addr,
575 sizeof(client_addr),
576 &msg,
577 server_sock,
578 (struct net_sockaddr *)&server_addr,
579 sizeof(server_addr));
580
581 rv = zsock_close(client_sock);
582 zassert_equal(rv, 0, "close failed");
583 rv = zsock_close(server_sock);
584 zassert_equal(rv, 0, "close failed");
585 }
586
ZTEST_USER(net_socket_udp,test_v4_sendmsg_recvfrom_connected)587 ZTEST_USER(net_socket_udp, test_v4_sendmsg_recvfrom_connected)
588 {
589 int rv;
590 int client_sock;
591 int server_sock;
592 struct net_sockaddr_in client_addr;
593 struct net_sockaddr_in server_addr;
594 struct net_msghdr msg;
595 struct net_cmsghdr *cmsg;
596 struct net_iovec io_vector[1];
597 union {
598 struct net_cmsghdr hdr;
599 unsigned char buf[NET_CMSG_SPACE(sizeof(int))];
600 } cmsgbuf;
601
602 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
603 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
604
605 rv = zsock_bind(server_sock,
606 (struct net_sockaddr *)&server_addr,
607 sizeof(server_addr));
608 zassert_equal(rv, 0, "server bind failed");
609
610 rv = zsock_bind(client_sock,
611 (struct net_sockaddr *)&client_addr,
612 sizeof(client_addr));
613 zassert_equal(rv, 0, "client bind failed");
614
615 rv = zsock_connect(client_sock, (struct net_sockaddr *)&server_addr,
616 sizeof(server_addr));
617 zassert_equal(rv, 0, "connect failed");
618
619 io_vector[0].iov_base = TEST_STR_SMALL;
620 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
621
622 memset(&msg, 0, sizeof(msg));
623 msg.msg_control = &cmsgbuf.buf;
624 msg.msg_controllen = sizeof(cmsgbuf.buf);
625 msg.msg_iov = io_vector;
626 msg.msg_iovlen = 1;
627
628 cmsg = NET_CMSG_FIRSTHDR(&msg);
629 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
630 cmsg->cmsg_level = ZSOCK_SOL_SOCKET;
631 cmsg->cmsg_type = 1122;
632 *(int *)NET_CMSG_DATA(cmsg) = 42;
633
634 comm_sendmsg_recvfrom(client_sock,
635 (struct net_sockaddr *)&client_addr,
636 sizeof(client_addr),
637 &msg,
638 server_sock,
639 (struct net_sockaddr *)&server_addr,
640 sizeof(server_addr));
641
642 rv = zsock_close(client_sock);
643 zassert_equal(rv, 0, "close failed");
644 rv = zsock_close(server_sock);
645 zassert_equal(rv, 0, "close failed");
646 }
647
ZTEST_USER(net_socket_udp,test_v6_sendmsg_recvfrom_connected)648 ZTEST_USER(net_socket_udp, test_v6_sendmsg_recvfrom_connected)
649 {
650 int rv;
651 int client_sock;
652 int server_sock;
653 struct net_sockaddr_in6 client_addr;
654 struct net_sockaddr_in6 server_addr;
655 struct net_msghdr msg;
656 struct net_cmsghdr *cmsg;
657 struct net_iovec io_vector[1];
658 union {
659 struct net_cmsghdr hdr;
660 unsigned char buf[NET_CMSG_SPACE(sizeof(int))];
661 } cmsgbuf;
662
663 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
664 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
665
666 rv = zsock_bind(server_sock,
667 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
668 zassert_equal(rv, 0, "server bind failed");
669
670 rv = zsock_bind(client_sock,
671 (struct net_sockaddr *)&client_addr,
672 sizeof(client_addr));
673 zassert_equal(rv, 0, "client bind failed");
674
675 rv = zsock_connect(client_sock, (struct net_sockaddr *)&server_addr,
676 sizeof(server_addr));
677 zassert_equal(rv, 0, "connect failed");
678
679 io_vector[0].iov_base = TEST_STR_SMALL;
680 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
681
682 memset(&msg, 0, sizeof(msg));
683 msg.msg_control = &cmsgbuf.buf;
684 msg.msg_controllen = sizeof(cmsgbuf.buf);
685 msg.msg_iov = io_vector;
686 msg.msg_iovlen = 1;
687
688 cmsg = NET_CMSG_FIRSTHDR(&msg);
689 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
690 cmsg->cmsg_level = ZSOCK_SOL_SOCKET;
691 cmsg->cmsg_type = 1122;
692 *(int *)NET_CMSG_DATA(cmsg) = 42;
693
694 comm_sendmsg_recvfrom(client_sock,
695 (struct net_sockaddr *)&client_addr,
696 sizeof(client_addr),
697 &msg,
698 server_sock,
699 (struct net_sockaddr *)&server_addr,
700 sizeof(server_addr));
701
702 rv = zsock_close(client_sock);
703 zassert_equal(rv, 0, "close failed");
704 rv = zsock_close(server_sock);
705 zassert_equal(rv, 0, "close failed");
706 }
707
ZTEST(net_socket_udp,test_so_type)708 ZTEST(net_socket_udp, test_so_type)
709 {
710 struct net_sockaddr_in bind_addr4;
711 struct net_sockaddr_in6 bind_addr6;
712 int sock1, sock2, rv;
713 int optval;
714 net_socklen_t optsize = sizeof(optval);
715
716 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
717 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
718
719 rv = zsock_getsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_TYPE, &optval, &optsize);
720 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
721 zassert_equal(optval, NET_SOCK_DGRAM, "getsockopt got invalid type");
722 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
723
724 rv = zsock_getsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_TYPE, &optval, &optsize);
725 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
726 zassert_equal(optval, NET_SOCK_DGRAM, "getsockopt got invalid type");
727 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
728
729 rv = zsock_close(sock1);
730 zassert_equal(rv, 0, "close failed");
731 rv = zsock_close(sock2);
732 zassert_equal(rv, 0, "close failed");
733 }
734
ZTEST(net_socket_udp,test_so_txtime)735 ZTEST(net_socket_udp, test_so_txtime)
736 {
737 struct net_sockaddr_in bind_addr4;
738 struct net_sockaddr_in6 bind_addr6;
739 int sock1, sock2, rv;
740 net_socklen_t optlen;
741 int optval;
742
743 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
744 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
745
746 rv = zsock_bind(sock1, (struct net_sockaddr *)&bind_addr4, sizeof(bind_addr4));
747 zassert_equal(rv, 0, "bind failed");
748
749 rv = zsock_bind(sock2, (struct net_sockaddr *)&bind_addr6, sizeof(bind_addr6));
750 zassert_equal(rv, 0, "bind failed");
751
752 optval = true;
753 rv = zsock_setsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_TXTIME, &optval,
754 sizeof(optval));
755 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
756
757 optval = false;
758 rv = zsock_setsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_TXTIME, &optval,
759 sizeof(optval));
760 zassert_equal(rv, 0, "setsockopt failed");
761
762 optlen = sizeof(optval);
763 rv = zsock_getsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_TXTIME, &optval, &optlen);
764 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
765 zassert_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
766 optlen, sizeof(optval));
767 zassert_equal(optval, true, "getsockopt txtime");
768
769 optlen = sizeof(optval);
770 rv = zsock_getsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_TXTIME, &optval, &optlen);
771 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
772 zassert_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
773 optlen, sizeof(optval));
774 zassert_equal(optval, false, "getsockopt txtime");
775
776 rv = zsock_close(sock1);
777 zassert_equal(rv, 0, "close failed");
778 rv = zsock_close(sock2);
779 zassert_equal(rv, 0, "close failed");
780 }
781
ZTEST(net_socket_udp,test_so_rcvtimeo)782 ZTEST(net_socket_udp, test_so_rcvtimeo)
783 {
784 struct net_sockaddr_in bind_addr4;
785 struct net_sockaddr_in6 bind_addr6;
786 int sock1, sock2, rv;
787 ssize_t recved = 0;
788 struct net_sockaddr addr;
789 net_socklen_t addrlen;
790 uint32_t start_time, time_diff;
791
792 struct timeval optval = {
793 .tv_sec = 0,
794 .tv_usec = 300000,
795 };
796
797 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
798 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
799
800 rv = zsock_bind(sock1, (struct net_sockaddr *)&bind_addr4, sizeof(bind_addr4));
801 zassert_equal(rv, 0, "bind failed");
802
803 rv = zsock_bind(sock2, (struct net_sockaddr *)&bind_addr6, sizeof(bind_addr6));
804 zassert_equal(rv, 0, "bind failed");
805
806 rv = zsock_setsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_RCVTIMEO, &optval,
807 sizeof(optval));
808 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
809
810 optval.tv_usec = 400000;
811 rv = zsock_setsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_RCVTIMEO, &optval,
812 sizeof(optval));
813 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
814
815 addrlen = sizeof(addr);
816 clear_buf(rx_buf);
817 start_time = k_uptime_get_32();
818 recved = zsock_recvfrom(sock1, rx_buf, sizeof(rx_buf),
819 0, &addr, &addrlen);
820 time_diff = k_uptime_get_32() - start_time;
821
822 zassert_equal(recved, -1, "Unexpected return code");
823 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
824 zassert_true(time_diff >= 300, "Expected timeout after 300ms but "
825 "was %dms", time_diff);
826
827 start_time = k_uptime_get_32();
828 recved = zsock_recvfrom(sock2, rx_buf, sizeof(rx_buf),
829 0, &addr, &addrlen);
830 time_diff = k_uptime_get_32() - start_time;
831
832 zassert_equal(recved, -1, "Unexpected return code");
833 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
834 zassert_true(time_diff >= 400, "Expected timeout after 400ms but "
835 "was %dms", time_diff);
836
837 rv = zsock_close(sock1);
838 zassert_equal(rv, 0, "close failed");
839 rv = zsock_close(sock2);
840 zassert_equal(rv, 0, "close failed");
841 }
842
ZTEST(net_socket_udp,test_so_sndtimeo)843 ZTEST(net_socket_udp, test_so_sndtimeo)
844 {
845 struct net_sockaddr_in bind_addr4;
846 struct net_sockaddr_in6 bind_addr6;
847 int sock1, sock2, rv;
848
849 struct timeval optval = {
850 .tv_sec = 2,
851 .tv_usec = 500000,
852 };
853
854 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
855 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
856
857 rv = zsock_bind(sock1, (struct net_sockaddr *)&bind_addr4, sizeof(bind_addr4));
858 zassert_equal(rv, 0, "bind failed");
859
860 rv = zsock_bind(sock2, (struct net_sockaddr *)&bind_addr6, sizeof(bind_addr6));
861 zassert_equal(rv, 0, "bind failed");
862
863 rv = zsock_setsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_SNDTIMEO, &optval,
864 sizeof(optval));
865 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
866
867 optval.tv_usec = 0;
868 rv = zsock_setsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_SNDTIMEO, &optval,
869 sizeof(optval));
870 zassert_equal(rv, 0, "setsockopt failed");
871
872 rv = zsock_close(sock1);
873 zassert_equal(rv, 0, "close failed");
874 rv = zsock_close(sock2);
875 zassert_equal(rv, 0, "close failed");
876 }
877
ZTEST(net_socket_udp,test_so_protocol)878 ZTEST(net_socket_udp, test_so_protocol)
879 {
880 struct net_sockaddr_in bind_addr4;
881 struct net_sockaddr_in6 bind_addr6;
882 int sock1, sock2, rv;
883 int optval;
884 net_socklen_t optsize = sizeof(optval);
885
886 prepare_sock_udp_v4(MY_IPV4_ADDR, 55555, &sock1, &bind_addr4);
887 prepare_sock_udp_v6(MY_IPV6_ADDR, 55555, &sock2, &bind_addr6);
888
889 rv = zsock_getsockopt(sock1, ZSOCK_SOL_SOCKET, ZSOCK_SO_PROTOCOL, &optval, &optsize);
890 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
891 zassert_equal(optval, NET_IPPROTO_UDP, "getsockopt got invalid protocol");
892 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
893
894 rv = zsock_getsockopt(sock2, ZSOCK_SOL_SOCKET, ZSOCK_SO_PROTOCOL, &optval, &optsize);
895 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
896 zassert_equal(optval, NET_IPPROTO_UDP, "getsockopt got invalid protocol");
897 zassert_equal(optsize, sizeof(optval), "getsockopt got invalid size");
898
899 rv = zsock_close(sock1);
900 zassert_equal(rv, 0, "close failed");
901 rv = zsock_close(sock2);
902 zassert_equal(rv, 0, "close failed");
903 }
904
comm_sendmsg_with_txtime(int client_sock,struct net_sockaddr * client_addr,net_socklen_t client_addrlen,const struct net_msghdr * client_msg)905 static void comm_sendmsg_with_txtime(int client_sock,
906 struct net_sockaddr *client_addr,
907 net_socklen_t client_addrlen,
908 const struct net_msghdr *client_msg)
909 {
910 ssize_t sent;
911 int len, i;
912
913 zassert_not_null(client_addr, "null client addr");
914
915 /*
916 * Test client -> server sending
917 */
918
919 sent = zsock_sendmsg(client_sock, client_msg, 0);
920 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
921
922 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
923 len += client_msg->msg_iov[i].iov_len;
924 }
925
926 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
927 }
928
929 /* In order to verify that the network device driver is able to receive
930 * the TXTIME option, create a separate network device and catch the packets
931 * we are sending.
932 */
933 struct eth_fake_context {
934 struct net_if *iface;
935 uint8_t mac_address[6];
936 };
937
938 static struct eth_fake_context eth_fake_data;
939 static ZTEST_BMEM struct net_sockaddr_in6 udp_server_addr;
940
941 /* The semaphore is there to wait the data to be received. */
942 static ZTEST_BMEM struct sys_sem wait_data;
943
944 static struct net_if *eth_iface;
945 static struct net_if *lo0;
946 static ZTEST_BMEM bool test_started;
947 static ZTEST_BMEM bool test_failed;
948 static struct net_in6_addr my_addr1 = { { { 0x20, 0x01, 0x0d, 0xb8, 1, 0, 0, 0,
949 0, 0, 0, 0, 0, 0, 0, 0x1 } } };
950 static struct net_in_addr my_addr2 = { { { 192, 0, 2, 2 } } };
951 static struct net_in6_addr my_addr3 = { { { 0x20, 0x01, 0x0d, 0xb8, 1, 0, 0, 0,
952 0, 0, 0, 0, 0, 0, 0, 0x3 } } };
953 static struct net_in6_addr my_mcast_addr1 = { { { 0xff, 0x01, 0, 0, 0, 0, 0, 0,
954 0, 0, 0, 0, 0, 0, 0, 0x1 } } };
955 static struct net_in_addr my_mcast_addr2 = { { { 224, 0, 0, 2 } } };
956 static struct net_linkaddr server_link_addr = {
957 .addr = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 },
958 .len = NET_ETH_ADDR_LEN,
959 };
960 #define MY_IPV6_ADDR_ETH "2001:db8:100::1"
961 #define PEER_IPV6_ADDR_ETH "2001:db8:100::2"
962 #define TEST_TXTIME INT64_MAX
963 #define WAIT_TIME K_MSEC(250)
964 #define WAIT_TIME_LONG K_MSEC(1000)
965
eth_fake_iface_init(struct net_if * iface)966 static void eth_fake_iface_init(struct net_if *iface)
967 {
968 const struct device *dev = net_if_get_device(iface);
969 struct eth_fake_context *ctx = dev->data;
970
971 ctx->iface = iface;
972
973 net_if_set_link_addr(iface, ctx->mac_address,
974 sizeof(ctx->mac_address),
975 NET_LINK_ETHERNET);
976
977 ethernet_init(iface);
978 }
979
eth_fake_send(const struct device * dev,struct net_pkt * pkt)980 static int eth_fake_send(const struct device *dev, struct net_pkt *pkt)
981 {
982 net_time_t txtime;
983
984 ARG_UNUSED(dev);
985 ARG_UNUSED(pkt);
986
987 if (!test_started) {
988 return 0;
989 }
990
991 txtime = net_pkt_timestamp_ns(pkt);
992 if (txtime != TEST_TXTIME) {
993 test_failed = true;
994 } else {
995 test_failed = false;
996 }
997
998 (void)sys_sem_give(&wait_data);
999
1000 return 0;
1001 }
1002
1003 static struct ethernet_api eth_fake_api_funcs = {
1004 .iface_api.init = eth_fake_iface_init,
1005 .send = eth_fake_send,
1006 };
1007
1008 ETH_NET_DEVICE_INIT(eth_fake, "eth_fake", NULL, NULL, ð_fake_data, NULL,
1009 CONFIG_ETH_INIT_PRIORITY, ð_fake_api_funcs, NET_ETH_MTU);
1010
iface_cb(struct net_if * iface,void * user_data)1011 static void iface_cb(struct net_if *iface, void *user_data)
1012 {
1013 struct net_if **my_iface = user_data;
1014
1015 if (net_if_l2(iface) == &NET_L2_GET_NAME(ETHERNET)) {
1016 if (PART_OF_ARRAY(NET_IF_GET_NAME(eth_fake, 0), iface)) {
1017 *my_iface = iface;
1018 }
1019 }
1020
1021 if (net_if_l2(iface) == &NET_L2_GET_NAME(DUMMY)) {
1022 lo0 = iface;
1023 net_if_set_default(iface);
1024 }
1025 }
1026
ZTEST_USER(net_socket_udp,test_v6_sendmsg_with_txtime)1027 ZTEST_USER(net_socket_udp, test_v6_sendmsg_with_txtime)
1028 {
1029 int rv;
1030 int client_sock;
1031 int optval;
1032 net_time_t txtime;
1033 struct net_sockaddr_in6 client_addr;
1034 struct net_msghdr msg;
1035 struct net_cmsghdr *cmsg;
1036 struct net_iovec io_vector[1];
1037 union {
1038 struct net_cmsghdr hdr;
1039 unsigned char buf[NET_CMSG_SPACE(sizeof(uint64_t))];
1040 } cmsgbuf;
1041
1042 /* Just flush the semaphore */
1043 (void)sys_sem_take(&wait_data, K_NO_WAIT);
1044
1045 prepare_sock_udp_v6(MY_IPV6_ADDR_ETH, ANY_PORT, &client_sock, &client_addr);
1046
1047 rv = zsock_bind(client_sock,
1048 (struct net_sockaddr *)&client_addr,
1049 sizeof(client_addr));
1050 zassert_equal(rv, 0, "client bind failed");
1051
1052 io_vector[0].iov_base = TEST_STR_SMALL;
1053 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1054
1055 memset(&msg, 0, sizeof(msg));
1056 msg.msg_control = &cmsgbuf.buf;
1057 msg.msg_controllen = sizeof(cmsgbuf.buf);
1058 msg.msg_iov = io_vector;
1059 msg.msg_iovlen = 1;
1060 msg.msg_name = &udp_server_addr;
1061 msg.msg_namelen = sizeof(udp_server_addr);
1062
1063 txtime = TEST_TXTIME;
1064
1065 cmsg = NET_CMSG_FIRSTHDR(&msg);
1066 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(txtime));
1067 cmsg->cmsg_level = ZSOCK_SOL_SOCKET;
1068 cmsg->cmsg_type = ZSOCK_SCM_TXTIME;
1069 *(net_time_t *)NET_CMSG_DATA(cmsg) = txtime;
1070
1071 optval = true;
1072 rv = zsock_setsockopt(client_sock, ZSOCK_SOL_SOCKET, ZSOCK_SO_TXTIME, &optval,
1073 sizeof(optval));
1074
1075 test_started = true;
1076
1077 comm_sendmsg_with_txtime(client_sock,
1078 (struct net_sockaddr *)&client_addr,
1079 sizeof(client_addr),
1080 &msg);
1081
1082 rv = zsock_close(client_sock);
1083 zassert_equal(rv, 0, "close failed");
1084
1085 if (sys_sem_take(&wait_data, WAIT_TIME) != 0) {
1086 zassert_true(false, "Timeout DNS query not received");
1087 }
1088
1089 zassert_false(test_failed, "Invalid txtime received");
1090
1091 test_started = false;
1092 }
1093
test_msg_trunc(int sock_c,int sock_s,struct net_sockaddr * addr_c,net_socklen_t addrlen_c,struct net_sockaddr * addr_s,net_socklen_t addrlen_s)1094 void test_msg_trunc(int sock_c, int sock_s, struct net_sockaddr *addr_c,
1095 net_socklen_t addrlen_c, struct net_sockaddr *addr_s,
1096 net_socklen_t addrlen_s)
1097 {
1098 int rv;
1099 uint8_t str_buf[sizeof(TEST_STR_SMALL) - 1];
1100
1101 rv = zsock_bind(sock_s, addr_s, addrlen_s);
1102 zassert_equal(rv, 0, "server bind failed");
1103
1104 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1105 zassert_equal(rv, 0, "client bind failed");
1106
1107 rv = zsock_connect(sock_c, addr_s, addrlen_s);
1108 zassert_equal(rv, 0, "connect failed");
1109
1110 /* MSG_TRUNC */
1111
1112 rv = zsock_send(sock_c, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0);
1113 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "send failed");
1114
1115 memset(str_buf, 0, sizeof(str_buf));
1116 rv = zsock_recv(sock_s, str_buf, 2, ZSOCK_MSG_TRUNC);
1117 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "MSG_TRUNC flag failed");
1118 zassert_mem_equal(str_buf, TEST_STR_SMALL, 2, "invalid rx data");
1119 zassert_equal(str_buf[2], 0, "received more than requested");
1120
1121 /* The remaining data should've been discarded */
1122 rv = zsock_recv(sock_s, str_buf, sizeof(str_buf), ZSOCK_MSG_DONTWAIT);
1123 zassert_equal(rv, -1, "consecutive recv should've failed");
1124 zassert_equal(errno, EAGAIN, "incorrect errno value");
1125
1126 /* MSG_TRUNC & MSG_PEEK combo */
1127
1128 rv = zsock_send(sock_c, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0);
1129 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "send failed");
1130
1131 memset(str_buf, 0, sizeof(str_buf));
1132 rv = zsock_recv(sock_s, str_buf, 2, ZSOCK_MSG_TRUNC | ZSOCK_MSG_PEEK);
1133 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1, "MSG_TRUNC flag failed");
1134
1135 /* The packet should still be available due to MSG_PEEK */
1136 rv = zsock_recv(sock_s, str_buf, sizeof(str_buf), ZSOCK_MSG_TRUNC);
1137 zassert_equal(rv, sizeof(TEST_STR_SMALL) - 1,
1138 "recv after MSG_PEEK failed");
1139 zassert_mem_equal(str_buf, BUF_AND_SIZE(TEST_STR_SMALL),
1140 "invalid rx data");
1141
1142 rv = zsock_close(sock_c);
1143 zassert_equal(rv, 0, "close failed");
1144 rv = zsock_close(sock_s);
1145 zassert_equal(rv, 0, "close failed");
1146 }
1147
ZTEST(net_socket_udp,test_v4_msg_trunc)1148 ZTEST(net_socket_udp, test_v4_msg_trunc)
1149 {
1150 int client_sock;
1151 int server_sock;
1152 struct net_sockaddr_in client_addr;
1153 struct net_sockaddr_in server_addr;
1154
1155 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1156 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1157
1158 test_msg_trunc(client_sock, server_sock,
1159 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1160 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
1161 }
1162
ZTEST(net_socket_udp,test_v6_msg_trunc)1163 ZTEST(net_socket_udp, test_v6_msg_trunc)
1164 {
1165 int client_sock;
1166 int server_sock;
1167 struct net_sockaddr_in6 client_addr;
1168 struct net_sockaddr_in6 server_addr;
1169
1170 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1171 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1172
1173 test_msg_trunc(client_sock, server_sock,
1174 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1175 (struct net_sockaddr *)&server_addr, sizeof(server_addr));
1176 }
1177
test_dgram_overflow(int sock_c,int sock_s,struct net_sockaddr * addr_c,net_socklen_t addrlen_c,struct net_sockaddr * addr_s,net_socklen_t addrlen_s,const void * buf,size_t buf_size)1178 static void test_dgram_overflow(int sock_c, int sock_s,
1179 struct net_sockaddr *addr_c, net_socklen_t addrlen_c,
1180 struct net_sockaddr *addr_s, net_socklen_t addrlen_s,
1181 const void *buf, size_t buf_size)
1182 {
1183 int rv;
1184
1185 rv = zsock_bind(sock_s, addr_s, addrlen_s);
1186 zassert_equal(rv, 0, "server bind failed");
1187
1188 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1189 zassert_equal(rv, 0, "client bind failed");
1190
1191 rv = zsock_connect(sock_c, addr_s, addrlen_s);
1192 zassert_equal(rv, 0, "connect failed");
1193
1194 rv = zsock_send(sock_c, buf, buf_size, 0);
1195 zassert_equal(rv, -1, "send succeeded");
1196 zassert_equal(errno, ENOMEM, "incorrect errno value");
1197
1198 rv = zsock_close(sock_c);
1199 zassert_equal(rv, 0, "close failed");
1200 rv = zsock_close(sock_s);
1201 zassert_equal(rv, 0, "close failed");
1202 }
1203
test_dgram_fragmented(int sock_c,int sock_s,struct net_sockaddr * addr_c,net_socklen_t addrlen_c,struct net_sockaddr * addr_s,net_socklen_t addrlen_s,const void * buf,size_t buf_size)1204 static void test_dgram_fragmented(int sock_c, int sock_s,
1205 struct net_sockaddr *addr_c, net_socklen_t addrlen_c,
1206 struct net_sockaddr *addr_s, net_socklen_t addrlen_s,
1207 const void *buf, size_t buf_size)
1208 {
1209 int rv;
1210
1211 rv = zsock_bind(sock_s, addr_s, addrlen_s);
1212 zassert_equal(rv, 0, "server bind failed");
1213
1214 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1215 zassert_equal(rv, 0, "client bind failed");
1216
1217 rv = zsock_connect(sock_c, addr_s, addrlen_s);
1218 zassert_equal(rv, 0, "connect failed");
1219
1220 rv = zsock_send(sock_c, buf, buf_size, 0);
1221 zassert_equal(rv, buf_size, "send failed");
1222
1223 memset(rx_buf, 0, sizeof(rx_buf));
1224 rv = zsock_recv(sock_s, rx_buf, sizeof(rx_buf), 0);
1225 zassert_equal(rv, buf_size, "recv failed");
1226 zassert_mem_equal(rx_buf, buf, buf_size, "wrong data");
1227
1228 rv = zsock_close(sock_c);
1229 zassert_equal(rv, 0, "close failed");
1230 rv = zsock_close(sock_s);
1231 zassert_equal(rv, 0, "close failed");
1232 }
1233
ZTEST(net_socket_udp,test_v4_dgram_overflow)1234 ZTEST(net_socket_udp, test_v4_dgram_overflow)
1235 {
1236 int client_sock;
1237 int server_sock;
1238 struct net_sockaddr_in client_addr;
1239 struct net_sockaddr_in server_addr;
1240
1241 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1242 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1243
1244 test_dgram_overflow(client_sock, server_sock,
1245 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1246 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
1247 test_str_all_tx_bufs, NET_ETH_MTU + 1);
1248 }
1249
ZTEST(net_socket_udp,test_v6_dgram_fragmented_or_overflow)1250 ZTEST(net_socket_udp, test_v6_dgram_fragmented_or_overflow)
1251 {
1252 int client_sock;
1253 int server_sock;
1254 struct net_sockaddr_in6 client_addr;
1255 struct net_sockaddr_in6 server_addr;
1256
1257 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1258 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1259
1260 if (IS_ENABLED(CONFIG_NET_IPV6_FRAGMENT)) {
1261 test_dgram_fragmented(client_sock, server_sock,
1262 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1263 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
1264 test_str_all_tx_bufs, NET_ETH_MTU + 1);
1265 } else {
1266 test_dgram_overflow(client_sock, server_sock,
1267 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1268 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
1269 test_str_all_tx_bufs, NET_ETH_MTU + 1);
1270 }
1271 }
1272
ZTEST(net_socket_udp,test_v6_dgram_overflow)1273 ZTEST(net_socket_udp, test_v6_dgram_overflow)
1274 {
1275 int client_sock;
1276 int server_sock;
1277 struct net_sockaddr_in6 client_addr;
1278 struct net_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 test_dgram_overflow(client_sock, server_sock,
1284 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1285 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
1286 BUF_AND_SIZE(test_str_all_tx_bufs));
1287 }
1288
test_dgram_connected(int sock_c,int sock_s1,int sock_s2,struct net_sockaddr * addr_c,net_socklen_t addrlen_c,struct net_sockaddr * addr_s1,net_socklen_t addrlen_s1,struct net_sockaddr * addr_s2,net_socklen_t addrlen_s2)1289 static void test_dgram_connected(int sock_c, int sock_s1, int sock_s2,
1290 struct net_sockaddr *addr_c, net_socklen_t addrlen_c,
1291 struct net_sockaddr *addr_s1, net_socklen_t addrlen_s1,
1292 struct net_sockaddr *addr_s2, net_socklen_t addrlen_s2)
1293 {
1294 uint8_t tx_buf = 0xab;
1295 uint8_t rx_buf;
1296 int rv;
1297
1298 rv = zsock_bind(sock_c, addr_c, addrlen_c);
1299 zassert_equal(rv, 0, "client bind failed");
1300
1301 rv = zsock_bind(sock_s1, addr_s1, addrlen_s1);
1302 zassert_equal(rv, 0, "server bind failed");
1303
1304 rv = zsock_bind(sock_s2, addr_s2, addrlen_s2);
1305 zassert_equal(rv, 0, "server bind failed");
1306
1307 rv = zsock_connect(sock_c, addr_s1, addrlen_s1);
1308 zassert_equal(rv, 0, "connect failed");
1309
1310 /* Verify that a datagram can be received from the connected address */
1311 rv = zsock_sendto(sock_s1, &tx_buf, sizeof(tx_buf), 0, addr_c, addrlen_c);
1312 zassert_equal(rv, sizeof(tx_buf), "send failed %d", errno);
1313
1314 /* Give the packet a chance to go through the net stack */
1315 k_msleep(10);
1316
1317 rx_buf = 0;
1318 rv = zsock_recv(sock_c, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
1319 zassert_equal(rv, sizeof(rx_buf), "recv failed");
1320 zassert_equal(rx_buf, tx_buf, "wrong data");
1321
1322 /* Verify that a datagram is not received from other address */
1323 rv = zsock_sendto(sock_s2, &tx_buf, sizeof(tx_buf), 0, addr_c, addrlen_c);
1324 zassert_equal(rv, sizeof(tx_buf), "send failed");
1325
1326 /* Give the packet a chance to go through the net stack */
1327 k_msleep(10);
1328
1329 rv = zsock_recv(sock_c, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
1330 zassert_equal(rv, -1, "recv should've failed");
1331 zassert_equal(errno, EAGAIN, "incorrect errno");
1332
1333 rv = zsock_close(sock_c);
1334 zassert_equal(rv, 0, "close failed");
1335 rv = zsock_close(sock_s1);
1336 zassert_equal(rv, 0, "close failed");
1337 rv = zsock_close(sock_s2);
1338 zassert_equal(rv, 0, "close failed");
1339 }
1340
ZTEST(net_socket_udp,test_v4_dgram_connected)1341 ZTEST(net_socket_udp, test_v4_dgram_connected)
1342 {
1343 int client_sock;
1344 int server_sock_1;
1345 int server_sock_2;
1346 struct net_sockaddr_in client_addr;
1347 struct net_sockaddr_in server_addr_1;
1348 struct net_sockaddr_in server_addr_2;
1349
1350 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
1351 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock_1, &server_addr_1);
1352 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT + 1, &server_sock_2, &server_addr_2);
1353
1354 test_dgram_connected(client_sock, server_sock_1, server_sock_2,
1355 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1356 (struct net_sockaddr *)&server_addr_1, sizeof(server_addr_1),
1357 (struct net_sockaddr *)&server_addr_2, sizeof(server_addr_2));
1358 }
1359
ZTEST(net_socket_udp,test_v6_dgram_connected)1360 ZTEST(net_socket_udp, test_v6_dgram_connected)
1361 {
1362 int client_sock;
1363 int server_sock_1;
1364 int server_sock_2;
1365 struct net_sockaddr_in6 client_addr;
1366 struct net_sockaddr_in6 server_addr_1;
1367 struct net_sockaddr_in6 server_addr_2;
1368
1369 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
1370 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock_1, &server_addr_1);
1371 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT + 1, &server_sock_2, &server_addr_2);
1372
1373 test_dgram_connected(client_sock, server_sock_1, server_sock_2,
1374 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
1375 (struct net_sockaddr *)&server_addr_1, sizeof(server_addr_1),
1376 (struct net_sockaddr *)&server_addr_2, sizeof(server_addr_2));
1377 }
1378
ZTEST_USER(net_socket_udp,test_recvmsg_invalid)1379 ZTEST_USER(net_socket_udp, test_recvmsg_invalid)
1380 {
1381 struct net_msghdr msg;
1382 struct net_sockaddr_in6 server_addr;
1383 struct net_cmsghdr *cmsg;
1384 struct net_iovec io_vector[1];
1385 union {
1386 struct net_cmsghdr hdr;
1387 unsigned char buf[NET_CMSG_SPACE(sizeof(int))];
1388 } cmsgbuf;
1389 int ret;
1390
1391 /* Userspace is needed for this test */
1392 Z_TEST_SKIP_IFNDEF(CONFIG_USERSPACE);
1393
1394 io_vector[0].iov_base = TEST_STR_SMALL;
1395 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1396
1397 ret = zsock_recvmsg(0, NULL, 0);
1398 zassert_true(ret < 0 && errno == EINVAL, "Wrong errno (%d)", errno);
1399
1400 /* Set various pointers to NULL or invalid value which should cause failure */
1401 memset(&msg, 0, sizeof(msg));
1402 msg.msg_controllen = sizeof(cmsgbuf.buf);
1403
1404 ret = zsock_recvmsg(0, &msg, 0);
1405 zassert_true(ret < 0, "recvmsg() succeed");
1406
1407 msg.msg_control = &cmsgbuf.buf;
1408
1409 ret = zsock_recvmsg(0, &msg, 0);
1410 zassert_true(ret < 0 && errno == ENOMEM, "Wrong errno (%d)", errno);
1411
1412 msg.msg_iov = io_vector;
1413 msg.msg_iovlen = 1;
1414 msg.msg_name = (void *)1;
1415 msg.msg_namelen = sizeof(server_addr);
1416
1417 cmsg = NET_CMSG_FIRSTHDR(&msg);
1418 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
1419 cmsg->cmsg_level = ZSOCK_SOL_SOCKET;
1420 cmsg->cmsg_type = 1122;
1421 *(int *)NET_CMSG_DATA(cmsg) = 42;
1422
1423 ret = zsock_recvmsg(0, &msg, 0);
1424 zassert_true(ret < 0, "recvmsg() succeed");
1425 }
1426
comm_sendmsg_recvmsg(int client_sock,struct net_sockaddr * client_addr,net_socklen_t client_addrlen,const struct net_msghdr * client_msg,int server_sock,struct net_sockaddr * server_addr,net_socklen_t server_addrlen,struct net_msghdr * msg,void * cmsgbuf,int cmsgbuf_len,bool expect_control_data)1427 static void comm_sendmsg_recvmsg(int client_sock,
1428 struct net_sockaddr *client_addr,
1429 net_socklen_t client_addrlen,
1430 const struct net_msghdr *client_msg,
1431 int server_sock,
1432 struct net_sockaddr *server_addr,
1433 net_socklen_t server_addrlen,
1434 struct net_msghdr *msg,
1435 void *cmsgbuf, int cmsgbuf_len,
1436 bool expect_control_data)
1437 {
1438 #define MAX_BUF_LEN 64
1439 #define SMALL_BUF_LEN (sizeof(TEST_STR_SMALL) - 1 - 2)
1440 char buf[MAX_BUF_LEN];
1441 char buf2[SMALL_BUF_LEN];
1442 struct net_iovec io_vector[2];
1443 ssize_t sent;
1444 ssize_t recved;
1445 struct net_sockaddr addr;
1446 net_socklen_t addrlen = server_addrlen;
1447 int len, i;
1448
1449 zassert_not_null(client_addr, "null client addr");
1450 zassert_not_null(server_addr, "null server addr");
1451
1452 /*
1453 * Test client -> server sending
1454 */
1455
1456 sent = zsock_sendmsg(client_sock, client_msg, 0);
1457 zassert_true(sent > 0, "sendmsg failed, %s (%d)", strerror(errno), -errno);
1458
1459 /* One negative test with invalid msg_iov */
1460 memset(msg, 0, sizeof(*msg));
1461 recved = zsock_recvmsg(server_sock, msg, 0);
1462 zassert_true(recved < 0 && errno == ENOMEM, "Wrong errno (%d)", errno);
1463
1464 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
1465 len += client_msg->msg_iov[i].iov_len;
1466 }
1467
1468 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
1469
1470 /* Test first with one iovec */
1471 io_vector[0].iov_base = buf;
1472 io_vector[0].iov_len = sizeof(buf);
1473
1474 memset(msg, 0, sizeof(*msg));
1475 if (cmsgbuf != NULL) {
1476 memset(cmsgbuf, 0, cmsgbuf_len);
1477 }
1478 msg->msg_control = cmsgbuf;
1479 msg->msg_controllen = cmsgbuf_len;
1480 msg->msg_iov = io_vector;
1481 msg->msg_iovlen = 1;
1482 msg->msg_name = &addr;
1483 msg->msg_namelen = addrlen;
1484
1485 /* Test recvmsg(MSG_PEEK) */
1486 recved = zsock_recvmsg(server_sock, msg, ZSOCK_MSG_PEEK);
1487 zassert_true(recved > 0, "recvmsg fail, %s (%d)", strerror(errno), -errno);
1488 zassert_equal(recved, len, "unexpected received bytes (%d vs %d)",
1489 recved, len);
1490 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
1491 sent, recved);
1492 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
1493 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf),
1494 "recvmsg should not modify buffer length");
1495 zassert_mem_equal(buf, TEST_STR_SMALL, len,
1496 "wrong data (%s)", rx_buf);
1497 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1498
1499 /* Test normal recvmsg() */
1500 clear_buf(rx_buf);
1501 recved = zsock_recvmsg(server_sock, msg, 0);
1502 zassert_true(recved > 0, "recvfrom fail");
1503 zassert_equal(recved, len, "unexpected received bytes");
1504 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
1505 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf),
1506 "recvmsg should not modify buffer length");
1507 zassert_mem_equal(buf, TEST_STR_SMALL, len,
1508 "wrong data (%s)", rx_buf);
1509 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1510
1511 /* Control data should be empty */
1512 if (!expect_control_data) {
1513 zassert_equal(msg->msg_controllen, 0,
1514 "We received control data (%u vs %zu)",
1515 0U, msg->msg_controllen);
1516 }
1517
1518 /* Check the client port */
1519 if (addr.sa_family == NET_AF_INET) {
1520 if (net_sin(client_addr)->sin_port != ANY_PORT) {
1521 zassert_equal(net_sin(client_addr)->sin_port,
1522 net_sin(&addr)->sin_port,
1523 "unexpected client port");
1524 }
1525 }
1526
1527 if (addr.sa_family == NET_AF_INET6) {
1528 if (net_sin6(client_addr)->sin6_port != ANY_PORT) {
1529 zassert_equal(net_sin6(client_addr)->sin6_port,
1530 net_sin6(&addr)->sin6_port,
1531 "unexpected client port");
1532 }
1533 }
1534
1535 /* Then send the message again and verify that we could receive
1536 * the full message in smaller chunks too.
1537 */
1538 sent = zsock_sendmsg(client_sock, client_msg, 0);
1539 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
1540
1541 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
1542 len += client_msg->msg_iov[i].iov_len;
1543 }
1544
1545 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
1546
1547 /* and then test with two iovec */
1548 io_vector[0].iov_base = buf2;
1549 io_vector[0].iov_len = sizeof(buf2);
1550 io_vector[1].iov_base = buf;
1551 io_vector[1].iov_len = sizeof(buf);
1552
1553 memset(msg, 0, sizeof(*msg));
1554 if (cmsgbuf != NULL) {
1555 memset(cmsgbuf, 0, cmsgbuf_len);
1556 }
1557 msg->msg_control = cmsgbuf;
1558 msg->msg_controllen = cmsgbuf_len;
1559 msg->msg_iov = io_vector;
1560 msg->msg_iovlen = 2;
1561 msg->msg_name = &addr;
1562 msg->msg_namelen = addrlen;
1563
1564 /* Test recvmsg(MSG_PEEK) */
1565 recved = zsock_recvmsg(server_sock, msg, ZSOCK_MSG_PEEK);
1566 zassert_true(recved >= 0, "recvfrom fail (errno %d)", errno);
1567 zassert_equal(recved, len,
1568 "unexpected received bytes (%d vs %d)", recved, len);
1569 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
1570 sent, recved);
1571
1572 zassert_equal(msg->msg_iovlen, 2, "recvmsg should not modify msg_iovlen");
1573 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf2),
1574 "recvmsg should not modify buffer length");
1575 zassert_equal(msg->msg_iov[1].iov_len, sizeof(buf),
1576 "recvmsg should not modify buffer length");
1577 zassert_mem_equal(msg->msg_iov[0].iov_base, TEST_STR_SMALL, msg->msg_iov[0].iov_len,
1578 "wrong data in %s", "iov[0]");
1579 zassert_mem_equal(msg->msg_iov[1].iov_base, &TEST_STR_SMALL[msg->msg_iov[0].iov_len],
1580 len - msg->msg_iov[0].iov_len,
1581 "wrong data in %s", "iov[1]");
1582 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1583
1584 /* Test normal recvfrom() */
1585 recved = zsock_recvmsg(server_sock, msg, ZSOCK_MSG_PEEK);
1586 zassert_true(recved >= 0, "recvfrom fail (errno %d)", errno);
1587 zassert_equal(recved, len,
1588 "unexpected received bytes (%d vs %d)", recved, len);
1589 zassert_equal(sent, recved, "sent(%d)/received(%d) mismatch",
1590 sent, recved);
1591
1592 zassert_equal(msg->msg_iovlen, 2, "recvmsg should not modify msg_iovlen");
1593 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf2),
1594 "recvmsg should not modify buffer length");
1595 zassert_equal(msg->msg_iov[1].iov_len, sizeof(buf),
1596 "recvmsg should not modify buffer length");
1597 zassert_mem_equal(msg->msg_iov[0].iov_base, TEST_STR_SMALL, msg->msg_iov[0].iov_len,
1598 "wrong data in %s", "iov[0]");
1599 zassert_mem_equal(msg->msg_iov[1].iov_base, &TEST_STR_SMALL[msg->msg_iov[0].iov_len],
1600 len - msg->msg_iov[0].iov_len,
1601 "wrong data in %s", "iov[1]");
1602 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1603
1604 /* Control data should be empty */
1605 if (!expect_control_data) {
1606 zassert_equal(msg->msg_controllen, 0,
1607 "We received control data (%u vs %zu)",
1608 0U, msg->msg_controllen);
1609 }
1610
1611 /* Then check that the trucation flag is set correctly */
1612 sent = zsock_sendmsg(client_sock, client_msg, 0);
1613 zassert_true(sent > 0, "sendmsg failed (%d)", -errno);
1614
1615 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
1616 len += client_msg->msg_iov[i].iov_len;
1617 }
1618
1619 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
1620
1621 /* Test first with one iovec */
1622 io_vector[0].iov_base = buf2;
1623 io_vector[0].iov_len = sizeof(buf2);
1624
1625 memset(msg, 0, sizeof(*msg));
1626 if (cmsgbuf != NULL) {
1627 memset(cmsgbuf, 0, cmsgbuf_len);
1628 }
1629 msg->msg_control = cmsgbuf;
1630 msg->msg_controllen = cmsgbuf_len;
1631 msg->msg_iov = io_vector;
1632 msg->msg_iovlen = 1;
1633 msg->msg_name = &addr;
1634 msg->msg_namelen = addrlen;
1635
1636 /* Test recvmsg */
1637 recved = zsock_recvmsg(server_sock, msg, 0);
1638 zassert_true(recved > 0, "recvmsg fail, %s (%d)", strerror(errno), errno);
1639 zassert_equal(recved, sizeof(buf2),
1640 "unexpected received bytes (%d vs %d)",
1641 recved, sizeof(buf2));
1642 zassert_true(msg->msg_flags & ZSOCK_MSG_TRUNC, "Message not truncated");
1643
1644 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
1645 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf2),
1646 "recvmsg should not modify buffer length");
1647 zassert_mem_equal(buf2, TEST_STR_SMALL, sizeof(buf2),
1648 "wrong data (%s)", buf2);
1649 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
1650
1651 /* Control data should be empty */
1652 if (!expect_control_data) {
1653 zassert_equal(msg->msg_controllen, 0,
1654 "We received control data (%u vs %zu)",
1655 0U, msg->msg_controllen);
1656 }
1657 }
1658
ZTEST_USER(net_socket_udp,test_recvmsg_user)1659 ZTEST_USER(net_socket_udp, test_recvmsg_user)
1660 {
1661 int rv;
1662 int client_sock;
1663 int server_sock;
1664 struct net_sockaddr_in client_addr;
1665 struct net_sockaddr_in server_addr;
1666 struct net_msghdr msg, server_msg;
1667 struct net_iovec io_vector[1];
1668
1669 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1670 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1671
1672 rv = zsock_bind(server_sock,
1673 (struct net_sockaddr *)&server_addr,
1674 sizeof(server_addr));
1675 zassert_equal(rv, 0, "server bind failed");
1676
1677 rv = zsock_bind(client_sock,
1678 (struct net_sockaddr *)&client_addr,
1679 sizeof(client_addr));
1680 zassert_equal(rv, 0, "client bind failed");
1681
1682 io_vector[0].iov_base = TEST_STR_SMALL;
1683 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1684
1685 memset(&msg, 0, sizeof(msg));
1686 msg.msg_iov = io_vector;
1687 msg.msg_iovlen = 1;
1688 msg.msg_name = &server_addr;
1689 msg.msg_namelen = sizeof(server_addr);
1690
1691 comm_sendmsg_recvmsg(client_sock,
1692 (struct net_sockaddr *)&client_addr,
1693 sizeof(client_addr),
1694 &msg,
1695 server_sock,
1696 (struct net_sockaddr *)&server_addr,
1697 sizeof(server_addr),
1698 &server_msg, NULL, 0, false);
1699
1700 rv = zsock_close(client_sock);
1701 zassert_equal(rv, 0, "close failed");
1702 rv = zsock_close(server_sock);
1703 zassert_equal(rv, 0, "close failed");
1704 }
1705
run_ancillary_recvmsg_test(int client_sock,struct net_sockaddr * client_addr,int client_addr_len,int server_sock,struct net_sockaddr * server_addr,int server_addr_len)1706 static void run_ancillary_recvmsg_test(int client_sock,
1707 struct net_sockaddr *client_addr,
1708 int client_addr_len,
1709 int server_sock,
1710 struct net_sockaddr *server_addr,
1711 int server_addr_len)
1712 {
1713 int rv;
1714 int opt;
1715 int ifindex = 0;
1716 net_socklen_t optlen;
1717 struct net_sockaddr addr = { 0 };
1718 struct net_if *iface;
1719 struct net_msghdr msg;
1720 struct net_msghdr server_msg;
1721 struct net_iovec io_vector[1];
1722 struct net_cmsghdr *cmsg, *prevcmsg;
1723 union {
1724 struct net_cmsghdr hdr;
1725 unsigned char buf[NET_CMSG_SPACE(sizeof(struct net_in6_pktinfo))];
1726 } cmsgbuf;
1727 #define SMALL_BUF_LEN (sizeof(TEST_STR_SMALL) - 1 - 2)
1728 char buf[MAX_BUF_LEN];
1729
1730 Z_TEST_SKIP_IFNDEF(CONFIG_NET_CONTEXT_RECV_PKTINFO);
1731
1732 rv = zsock_bind(server_sock, server_addr, server_addr_len);
1733 zassert_equal(rv, 0, "server bind failed");
1734
1735 rv = zsock_bind(client_sock, client_addr, client_addr_len);
1736 zassert_equal(rv, 0, "client bind failed");
1737
1738 io_vector[0].iov_base = TEST_STR_SMALL;
1739 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
1740
1741 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
1742
1743 memset(&msg, 0, sizeof(msg));
1744 msg.msg_iov = io_vector;
1745 msg.msg_iovlen = 1;
1746 msg.msg_name = server_addr;
1747 msg.msg_namelen = server_addr_len;
1748
1749 comm_sendmsg_recvmsg(client_sock,
1750 client_addr,
1751 client_addr_len,
1752 &msg,
1753 server_sock,
1754 server_addr,
1755 server_addr_len,
1756 &server_msg,
1757 &cmsgbuf.buf,
1758 sizeof(cmsgbuf.buf),
1759 true);
1760
1761 for (prevcmsg = NULL, cmsg = NET_CMSG_FIRSTHDR(&server_msg);
1762 cmsg != NULL && prevcmsg != cmsg;
1763 prevcmsg = cmsg, cmsg = NET_CMSG_NXTHDR(&server_msg, cmsg)) {
1764 if (cmsg->cmsg_level == NET_IPPROTO_IP &&
1765 cmsg->cmsg_type == ZSOCK_IP_PKTINFO) {
1766 net_sin(&addr)->sin_addr =
1767 ((struct net_in_pktinfo *)NET_CMSG_DATA(cmsg))->ipi_addr;
1768 break;
1769 }
1770 }
1771
1772 /* As we have not set the socket option, the address should not be set */
1773 if (server_addr->sa_family == NET_AF_INET) {
1774 zassert_equal(net_sin(&addr)->sin_addr.s_addr, NET_INADDR_ANY,
1775 "Source address set!");
1776 }
1777
1778 if (server_addr->sa_family == NET_AF_INET6) {
1779 zassert_true(net_sin6(&addr)->sin6_addr.s6_addr32[0] == 0 &&
1780 net_sin6(&addr)->sin6_addr.s6_addr32[1] == 0 &&
1781 net_sin6(&addr)->sin6_addr.s6_addr32[2] == 0 &&
1782 net_sin6(&addr)->sin6_addr.s6_addr32[3] == 0,
1783 "Source address set!");
1784 }
1785
1786 opt = 1;
1787 optlen = sizeof(opt);
1788 if (server_addr->sa_family == NET_AF_INET) {
1789 rv = zsock_setsockopt(server_sock, NET_IPPROTO_IP,
1790 ZSOCK_IP_PKTINFO, &opt, optlen);
1791 } else {
1792 rv = zsock_setsockopt(server_sock, NET_IPPROTO_IPV6,
1793 ZSOCK_IPV6_RECVPKTINFO, &opt, optlen);
1794 }
1795 zassert_equal(rv, 0, "setsockopt failed (%d)", -errno);
1796
1797 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
1798
1799 memset(&msg, 0, sizeof(msg));
1800 msg.msg_iov = io_vector;
1801 msg.msg_iovlen = 1;
1802 msg.msg_name = server_addr;
1803 msg.msg_namelen = server_addr_len;
1804
1805 comm_sendmsg_recvmsg(client_sock,
1806 client_addr,
1807 client_addr_len,
1808 &msg,
1809 server_sock,
1810 server_addr,
1811 server_addr_len,
1812 &server_msg,
1813 &cmsgbuf.buf,
1814 sizeof(cmsgbuf.buf),
1815 true);
1816
1817 for (cmsg = NET_CMSG_FIRSTHDR(&server_msg); cmsg != NULL;
1818 cmsg = NET_CMSG_NXTHDR(&server_msg, cmsg)) {
1819 if (cmsg->cmsg_level == NET_IPPROTO_IP &&
1820 cmsg->cmsg_type == ZSOCK_IP_PKTINFO) {
1821 net_sin(&addr)->sin_addr =
1822 ((struct net_in_pktinfo *)NET_CMSG_DATA(cmsg))->ipi_addr;
1823 ifindex = ((struct net_in_pktinfo *)NET_CMSG_DATA(cmsg))->ipi_ifindex;
1824 break;
1825 }
1826
1827 if (cmsg->cmsg_level == NET_IPPROTO_IPV6 &&
1828 cmsg->cmsg_type == ZSOCK_IPV6_PKTINFO) {
1829 net_ipaddr_copy(&net_sin6(&addr)->sin6_addr,
1830 &((struct net_in6_pktinfo *)NET_CMSG_DATA(cmsg))->ipi6_addr);
1831 ifindex = ((struct net_in6_pktinfo *)NET_CMSG_DATA(cmsg))->ipi6_ifindex;
1832 break;
1833 }
1834 }
1835
1836 if (server_addr->sa_family == NET_AF_INET) {
1837 zassert_equal(net_sin(&addr)->sin_addr.s_addr,
1838 net_sin(server_addr)->sin_addr.s_addr,
1839 "Source address not set properly!");
1840 }
1841
1842 if (server_addr->sa_family == NET_AF_INET6) {
1843 zassert_mem_equal(&net_sin6(&addr)->sin6_addr,
1844 &net_sin6(server_addr)->sin6_addr,
1845 sizeof(struct net_in6_addr),
1846 "Source address not set properly!");
1847 }
1848
1849 if (!k_is_user_context()) {
1850 iface = net_if_get_default();
1851 zassert_equal(ifindex, net_if_get_by_iface(iface));
1852 }
1853
1854 /* Make sure that the recvmsg() fails if control area is too small */
1855 rv = zsock_sendto(client_sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
1856 server_addr, server_addr_len);
1857 zassert_equal(rv, STRLEN(TEST_STR_SMALL), "sendto failed (%d)", -errno);
1858
1859 io_vector[0].iov_base = buf;
1860 io_vector[0].iov_len = sizeof(buf);
1861
1862 memset(&msg, 0, sizeof(msg));
1863 msg.msg_control = &cmsgbuf.buf;
1864 msg.msg_controllen = 1; /* making sure the control buf is always too small */
1865 msg.msg_iov = io_vector;
1866 msg.msg_iovlen = 1;
1867
1868 rv = zsock_recvmsg(server_sock, &msg, 0);
1869 zassert_true(rv, "recvmsg succeed (%d)", rv);
1870
1871 zassert_true(msg.msg_flags & ZSOCK_MSG_CTRUNC, "Control message not truncated");
1872
1873 rv = zsock_close(client_sock);
1874 zassert_equal(rv, 0, "close failed");
1875 rv = zsock_close(server_sock);
1876 zassert_equal(rv, 0, "close failed");
1877 }
1878
ZTEST_USER(net_socket_udp,test_recvmsg_ancillary_ipv4_pktinfo_data_user)1879 ZTEST_USER(net_socket_udp, test_recvmsg_ancillary_ipv4_pktinfo_data_user)
1880 {
1881 struct net_sockaddr_in client_addr;
1882 struct net_sockaddr_in server_addr;
1883 int client_sock;
1884 int server_sock;
1885
1886 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
1887 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
1888
1889 run_ancillary_recvmsg_test(client_sock,
1890 (struct net_sockaddr *)&client_addr,
1891 sizeof(client_addr),
1892 server_sock,
1893 (struct net_sockaddr *)&server_addr,
1894 sizeof(server_addr));
1895 }
1896
ZTEST_USER(net_socket_udp,test_recvmsg_ancillary_ipv6_pktinfo_data_user)1897 ZTEST_USER(net_socket_udp, test_recvmsg_ancillary_ipv6_pktinfo_data_user)
1898 {
1899 struct net_sockaddr_in6 client_addr;
1900 struct net_sockaddr_in6 server_addr;
1901 int client_sock;
1902 int server_sock;
1903
1904 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
1905 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
1906
1907 run_ancillary_recvmsg_test(client_sock,
1908 (struct net_sockaddr *)&client_addr,
1909 sizeof(client_addr),
1910 server_sock,
1911 (struct net_sockaddr *)&server_addr,
1912 sizeof(server_addr));
1913 }
1914
bind_socket(int sock,struct net_if * iface)1915 static int bind_socket(int sock, struct net_if *iface)
1916 {
1917 struct net_sockaddr_ll addr;
1918
1919 memset(&addr, 0, sizeof(addr));
1920
1921 addr.sll_ifindex = net_if_get_by_iface(iface);
1922 addr.sll_family = NET_AF_PACKET;
1923
1924 return zsock_bind(sock, (struct net_sockaddr *)&addr, sizeof(addr));
1925 }
1926
test_check_ttl(int sock_c,int sock_s,int sock_p,struct net_sockaddr * addr_c,net_socklen_t addrlen_c,struct net_sockaddr * addr_s,net_socklen_t addrlen_s,struct net_sockaddr * addr_sendto,net_socklen_t addrlen_sendto,net_sa_family_t family,uint8_t expected_ttl,uint8_t expected_mcast_ttl)1927 static void test_check_ttl(int sock_c, int sock_s, int sock_p,
1928 struct net_sockaddr *addr_c, net_socklen_t addrlen_c,
1929 struct net_sockaddr *addr_s, net_socklen_t addrlen_s,
1930 struct net_sockaddr *addr_sendto, net_socklen_t addrlen_sendto,
1931 net_sa_family_t family, uint8_t expected_ttl,
1932 uint8_t expected_mcast_ttl)
1933 {
1934 uint8_t tx_buf = 0xab;
1935 uint8_t rx_buf;
1936 int ret, count = 10, opt;
1937 #define IPV4_HDR_SIZE sizeof(struct net_ipv4_hdr)
1938 #define IPV6_HDR_SIZE sizeof(struct net_ipv6_hdr)
1939 #define UDP_HDR_SIZE sizeof(struct net_udp_hdr)
1940 #define V4_HDR_SIZE (IPV4_HDR_SIZE + UDP_HDR_SIZE)
1941 #define V6_HDR_SIZE (IPV6_HDR_SIZE + UDP_HDR_SIZE)
1942 #define MAX_HDR_SIZE (IPV6_HDR_SIZE + UDP_HDR_SIZE)
1943 uint8_t data_to_receive[sizeof(tx_buf) + MAX_HDR_SIZE];
1944 struct net_sockaddr_ll src;
1945 net_socklen_t addrlen;
1946 char ifname[CONFIG_NET_INTERFACE_NAME_LEN];
1947 struct net_ifreq ifreq = { 0 };
1948 struct timeval timeo_optval = {
1949 .tv_sec = 0,
1950 .tv_usec = 100000,
1951 };
1952 #if defined(CONFIG_NET_STATISTICS)
1953 struct net_stats_ip ipv4_stats_before, ipv4_stats_after;
1954 struct net_stats_ip ipv6_stats_before, ipv6_stats_after;
1955 #endif
1956
1957 Z_TEST_SKIP_IFNDEF(CONFIG_NET_INTERFACE_NAME);
1958
1959 ret = zsock_bind(sock_c, addr_c, addrlen_c);
1960 zassert_equal(ret, 0, "client bind failed");
1961
1962 ret = net_if_get_name(lo0, ifname, sizeof(ifname));
1963 zassert_true(ret > 0, "cannot get interface name (%d)", ret);
1964
1965 strncpy(ifreq.ifr_name, ifname, sizeof(ifreq.ifr_name));
1966 ret = zsock_setsockopt(sock_c, ZSOCK_SOL_SOCKET, ZSOCK_SO_BINDTODEVICE, &ifreq,
1967 sizeof(ifreq));
1968 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", -errno);
1969
1970 ret = zsock_connect(sock_c, addr_s, addrlen_s);
1971 zassert_equal(ret, 0, "connect failed");
1972
1973 ret = zsock_setsockopt(sock_s, ZSOCK_SOL_SOCKET, ZSOCK_SO_RCVTIMEO,
1974 &timeo_optval, sizeof(timeo_optval));
1975 zassert_equal(ret, 0, "Cannot set receive timeout (%d)", -errno);
1976
1977 while (count > 0) {
1978 ret = zsock_sendto(sock_c, &tx_buf, sizeof(tx_buf), 0,
1979 addr_sendto, addrlen_sendto);
1980 zassert_equal(ret, sizeof(tx_buf), "send failed (%d)", -errno);
1981
1982 ret = zsock_recv(sock_s, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
1983 if (ret > 0) {
1984 zassert_equal(ret, sizeof(rx_buf), "recv failed (%d)", ret);
1985 zassert_equal(rx_buf, tx_buf, "wrong data");
1986 }
1987
1988 ret = zsock_recvfrom(sock_p, data_to_receive, sizeof(data_to_receive), 0,
1989 (struct net_sockaddr *)&src, &addrlen);
1990 if (ret > 0) {
1991 int hdr_size = family == NET_AF_INET ?
1992 V4_HDR_SIZE : V6_HDR_SIZE;
1993 zassert_equal(ret, sizeof(tx_buf) + hdr_size,
1994 "Cannot receive all data (%d vs %zd) (%d)",
1995 ret, sizeof(tx_buf), -errno);
1996 zassert_mem_equal(&data_to_receive[hdr_size], &tx_buf,
1997 sizeof(tx_buf),
1998 "Sent and received buffers do not match");
1999
2000 if (family == NET_AF_INET) {
2001 struct net_ipv4_hdr *ipv4 =
2002 (struct net_ipv4_hdr *)&data_to_receive[0];
2003
2004 if (expected_ttl > 0) {
2005 zassert_equal(ipv4->ttl, expected_ttl,
2006 "Invalid ttl (%d vs %d)",
2007 ipv4->ttl, expected_ttl);
2008 } else if (expected_mcast_ttl > 0) {
2009 zassert_equal(ipv4->ttl, expected_mcast_ttl,
2010 "Invalid mcast ttl (%d vs %d)",
2011 ipv4->ttl, expected_mcast_ttl);
2012 }
2013 } else if (family == NET_AF_INET6) {
2014 struct net_ipv6_hdr *ipv6 =
2015 (struct net_ipv6_hdr *)&data_to_receive[0];
2016
2017 if (expected_ttl > 0) {
2018 zassert_equal(ipv6->hop_limit, expected_ttl,
2019 "Invalid hop limit (%d vs %d)",
2020 ipv6->hop_limit, expected_ttl);
2021 } else if (expected_mcast_ttl > 0) {
2022 zassert_equal(ipv6->hop_limit, expected_mcast_ttl,
2023 "Invalid mcast hop limit (%d vs %d)",
2024 ipv6->hop_limit, expected_mcast_ttl);
2025 }
2026 } else {
2027 zassert_true(false, "Invalid address family (%d)",
2028 family);
2029 }
2030
2031 break;
2032 }
2033
2034 count--;
2035 }
2036
2037 zassert_true(count > 0, "timeout while waiting data");
2038
2039 if (family == NET_AF_INET) {
2040 /* Set TTL to 0 and make sure the packet is dropped and not
2041 * received
2042 */
2043 int option;
2044
2045 if (expected_ttl > 0) {
2046 option = ZSOCK_IP_TTL;
2047 } else {
2048 option = ZSOCK_IP_MULTICAST_TTL;
2049 }
2050
2051 opt = 0;
2052 ret = zsock_setsockopt(sock_c, NET_IPPROTO_IP, option, &opt, sizeof(opt));
2053 zassert_equal(ret, 0, "Cannot set %s TTL (%d)",
2054 option == ZSOCK_IP_TTL ? "unicast" : "multicast",
2055 -errno);
2056
2057 #if defined(CONFIG_NET_STATISTICS)
2058 /* Get IPv4 stats and verify they are updated for dropped
2059 * packets.
2060 */
2061 net_mgmt(NET_REQUEST_STATS_GET_IPV4, lo0,
2062 &ipv4_stats_before, sizeof(ipv4_stats_before));
2063 #endif
2064 ret = zsock_sendto(sock_c, &tx_buf, sizeof(tx_buf), 0,
2065 addr_sendto, addrlen_sendto);
2066 zassert_equal(ret, sizeof(tx_buf), "send failed (%d)", -errno);
2067
2068 #if defined(CONFIG_NET_STATISTICS)
2069 net_mgmt(NET_REQUEST_STATS_GET_IPV4, lo0,
2070 &ipv4_stats_after, sizeof(ipv4_stats_after));
2071
2072 zassert_equal(ipv4_stats_before.drop + 1,
2073 ipv4_stats_after.drop,
2074 "Dropped statistics not updated (%d vs %d)",
2075 ipv4_stats_before.drop + 1,
2076 ipv4_stats_after.drop);
2077 #endif
2078 ret = zsock_recv(sock_s, &rx_buf, sizeof(rx_buf), 0);
2079 zassert_true(ret < 0 && errno == EAGAIN, "recv succeed (%d)", -errno);
2080 }
2081
2082 if (family == NET_AF_INET6) {
2083 /* Set hoplimit to 0 and make sure the packet is dropped and not
2084 * received.
2085 */
2086 int option;
2087
2088 if (expected_ttl > 0) {
2089 option = ZSOCK_IPV6_UNICAST_HOPS;
2090 } else {
2091 option = ZSOCK_IPV6_MULTICAST_HOPS;
2092 }
2093
2094 opt = 0;
2095 ret = zsock_setsockopt(sock_c, NET_IPPROTO_IPV6, option,
2096 &opt, sizeof(opt));
2097 zassert_equal(ret, 0, "Cannot set %s hops (%d)",
2098 option == ZSOCK_IPV6_UNICAST_HOPS ? "unicast" : "multicast",
2099 -errno);
2100
2101 #if defined(CONFIG_NET_STATISTICS)
2102 /* Get IPv6 stats and verify they are updated for dropped
2103 * packets.
2104 */
2105 net_mgmt(NET_REQUEST_STATS_GET_IPV6, lo0,
2106 &ipv6_stats_before, sizeof(ipv6_stats_before));
2107 #endif
2108 ret = zsock_sendto(sock_c, &tx_buf, sizeof(tx_buf), 0,
2109 addr_sendto, addrlen_sendto);
2110 zassert_equal(ret, sizeof(tx_buf), "send failed (%d)", -errno);
2111
2112 #if defined(CONFIG_NET_STATISTICS)
2113 net_mgmt(NET_REQUEST_STATS_GET_IPV6, lo0,
2114 &ipv6_stats_after, sizeof(ipv6_stats_after));
2115
2116 zassert_equal(ipv6_stats_before.drop + 1,
2117 ipv6_stats_after.drop,
2118 "Dropped statistics not updated (%d vs %d)",
2119 ipv6_stats_before.drop + 1,
2120 ipv6_stats_after.drop);
2121 #endif
2122 ret = zsock_recv(sock_s, &rx_buf, sizeof(rx_buf), 0);
2123 zassert_true(ret < 0 && errno == EAGAIN, "recv succeed (%d)", -errno);
2124
2125 }
2126
2127 ret = zsock_close(sock_c);
2128 zassert_equal(ret, 0, "close failed");
2129 ret = zsock_close(sock_s);
2130 zassert_equal(ret, 0, "close failed");
2131 ret = zsock_close(sock_p);
2132 zassert_equal(ret, 0, "close failed");
2133 }
2134
ZTEST(net_socket_udp,test_v4_ttl)2135 ZTEST(net_socket_udp, test_v4_ttl)
2136 {
2137 int ret;
2138 int client_sock;
2139 int server_sock;
2140 int packet_sock;
2141 int ttl, verify;
2142 net_socklen_t optlen;
2143 struct net_sockaddr_in client_addr;
2144 struct net_sockaddr_in server_addr;
2145
2146 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2147
2148 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2149 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
2150
2151 packet_sock = zsock_socket(NET_AF_PACKET, NET_SOCK_RAW, net_htons(ETH_P_ALL));
2152 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2153
2154 ret = bind_socket(packet_sock, lo0);
2155 zassert_equal(ret, 0, "packet socket bind failed");
2156
2157 zassert_not_null(lo0->config.ip.ipv4,
2158 "Interface %d (%p) no IPv4 configured",
2159 net_if_get_by_iface(lo0), lo0);
2160
2161 ttl = 16;
2162 net_if_ipv4_set_ttl(lo0, ttl);
2163 verify = net_if_ipv4_get_ttl(lo0);
2164 zassert_equal(verify, ttl, "Different TTLs (%d vs %d)", ttl, verify);
2165
2166 ttl = 128;
2167 ret = zsock_setsockopt(client_sock, NET_IPPROTO_IP, ZSOCK_IP_TTL, &ttl, sizeof(ttl));
2168 zassert_equal(ret, 0, "Cannot set unicast TTL (%d)", -errno);
2169
2170 optlen = sizeof(verify);
2171 ret = zsock_getsockopt(client_sock, NET_IPPROTO_IP, ZSOCK_IP_TTL, &verify, &optlen);
2172 zassert_equal(ret, 0, "Cannot get unicast TTL (%d)", -errno);
2173 zassert_equal(verify, ttl, "Different unicast TTL (%d vs %d)",
2174 ttl, verify);
2175
2176 test_check_ttl(client_sock, server_sock, packet_sock,
2177 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
2178 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
2179 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
2180 NET_AF_INET, ttl, 0);
2181 }
2182
ZTEST(net_socket_udp,test_v4_mcast_ttl)2183 ZTEST(net_socket_udp, test_v4_mcast_ttl)
2184 {
2185 int ret;
2186 int client_sock;
2187 int server_sock;
2188 int packet_sock;
2189 int mcast_ttl, verify;
2190 net_socklen_t optlen;
2191 struct net_sockaddr_in client_addr;
2192 struct net_sockaddr_in server_addr;
2193 struct net_sockaddr_in sendto_addr;
2194
2195 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2196
2197 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2198 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
2199
2200 packet_sock = zsock_socket(NET_AF_PACKET, NET_SOCK_RAW, net_htons(ETH_P_ALL));
2201 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2202
2203 ret = bind_socket(packet_sock, lo0);
2204 zassert_equal(ret, 0, "packet socket bind failed");
2205
2206 zassert_not_null(lo0->config.ip.ipv4,
2207 "Interface %d (%p) no IPv4 configured",
2208 net_if_get_by_iface(lo0), lo0);
2209
2210 mcast_ttl = 8;
2211 ret = zsock_setsockopt(client_sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_TTL, &mcast_ttl,
2212 sizeof(mcast_ttl));
2213 zassert_equal(ret, 0, "Cannot set multicast ttl (%d)", -errno);
2214
2215 optlen = sizeof(verify);
2216 ret = zsock_getsockopt(client_sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_TTL, &verify,
2217 &optlen);
2218 zassert_equal(ret, 0, "Cannot get multicast ttl (%d)", -errno);
2219 zassert_equal(verify, mcast_ttl, "Different multicast TTLs (%d vs %d)",
2220 mcast_ttl, verify);
2221
2222 ret = net_addr_pton(NET_AF_INET, MY_MCAST_IPV4_ADDR, &sendto_addr.sin_addr);
2223 zassert_equal(ret, 0, "Cannot get IPv4 address (%d)", ret);
2224
2225 test_check_ttl(client_sock, server_sock, packet_sock,
2226 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
2227 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
2228 (struct net_sockaddr *)&sendto_addr, sizeof(sendto_addr),
2229 NET_AF_INET, 0, mcast_ttl);
2230 }
2231
ZTEST(net_socket_udp,test_v6_mcast_hops)2232 ZTEST(net_socket_udp, test_v6_mcast_hops)
2233 {
2234 int ret;
2235 int client_sock;
2236 int server_sock;
2237 int packet_sock;
2238 int mcast_hops, if_mcast_hops;
2239 int verify, opt;
2240 net_socklen_t optlen;
2241 struct net_sockaddr_in6 client_addr;
2242 struct net_sockaddr_in6 server_addr;
2243 struct net_sockaddr_in6 sendto_addr;
2244
2245 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2246
2247 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2248 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
2249
2250 packet_sock = zsock_socket(NET_AF_PACKET, NET_SOCK_RAW, net_htons(ETH_P_ALL));
2251 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2252
2253 ret = bind_socket(packet_sock, lo0);
2254 zassert_equal(ret, 0, "packet socket bind failed");
2255
2256 zassert_not_null(lo0->config.ip.ipv6,
2257 "Interface %d (%p) no IPv6 configured",
2258 net_if_get_by_iface(lo0), lo0);
2259
2260 /* First make sure setting hop limit to -1 works as expected (route default
2261 * value should be used).
2262 */
2263 if_mcast_hops = net_if_ipv6_get_mcast_hop_limit(lo0);
2264
2265 opt = -1;
2266 ret = zsock_setsockopt(client_sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_HOPS, &opt,
2267 sizeof(opt));
2268 zassert_equal(ret, 0, "Cannot set multicast hop limit (%d)", -errno);
2269
2270 optlen = sizeof(verify);
2271 ret = zsock_getsockopt(client_sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_HOPS, &verify,
2272 &optlen);
2273 zassert_equal(ret, 0, "Cannot get multicast hop limit (%d)", -errno);
2274 zassert_equal(verify, if_mcast_hops, "Different multicast hop limit (%d vs %d)",
2275 if_mcast_hops, verify);
2276
2277 /* Then test the normal case where we set the value */
2278 mcast_hops = 8;
2279 ret = zsock_setsockopt(client_sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_HOPS,
2280 &mcast_hops, sizeof(mcast_hops));
2281 zassert_equal(ret, 0, "Cannot set multicast hop limit (%d)", -errno);
2282
2283 optlen = sizeof(verify);
2284 ret = zsock_getsockopt(client_sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_HOPS, &verify,
2285 &optlen);
2286 zassert_equal(ret, 0, "Cannot get multicast hop limit (%d)", -errno);
2287 zassert_equal(verify, mcast_hops, "Different multicast hop limit (%d vs %d)",
2288 mcast_hops, verify);
2289
2290 ret = net_addr_pton(NET_AF_INET6, MY_MCAST_IPV6_ADDR, &sendto_addr.sin6_addr);
2291 zassert_equal(ret, 0, "Cannot get IPv6 address (%d)", ret);
2292
2293 test_check_ttl(client_sock, server_sock, packet_sock,
2294 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
2295 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
2296 (struct net_sockaddr *)&sendto_addr, sizeof(sendto_addr),
2297 NET_AF_INET6, 0, mcast_hops);
2298 }
2299
ZTEST(net_socket_udp,test_v6_hops)2300 ZTEST(net_socket_udp, test_v6_hops)
2301 {
2302 int ret;
2303 int client_sock;
2304 int server_sock;
2305 int packet_sock;
2306 int hops, verify;
2307 net_socklen_t optlen;
2308 struct net_sockaddr_in6 client_addr;
2309 struct net_sockaddr_in6 server_addr;
2310
2311 Z_TEST_SKIP_IFNDEF(CONFIG_NET_SOCKETS_PACKET);
2312
2313 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
2314 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
2315
2316 packet_sock = zsock_socket(NET_AF_PACKET, NET_SOCK_RAW, net_htons(ETH_P_ALL));
2317 zassert_true(packet_sock >= 0, "Cannot create packet socket (%d)", -errno);
2318
2319 ret = bind_socket(packet_sock, lo0);
2320 zassert_equal(ret, 0, "packet socket bind failed");
2321
2322 zassert_not_null(lo0->config.ip.ipv6,
2323 "Interface %d (%p) no IPv6 configured",
2324 net_if_get_by_iface(lo0), lo0);
2325
2326 hops = 16;
2327 net_if_ipv6_set_hop_limit(lo0, hops);
2328 verify = net_if_ipv6_get_hop_limit(lo0);
2329 zassert_equal(verify, hops, "Different hop limit (%d vs %d)", hops, verify);
2330
2331 hops = 8;
2332 ret = zsock_setsockopt(client_sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_UNICAST_HOPS, &hops,
2333 sizeof(hops));
2334 zassert_equal(ret, 0, "Cannot set unicast hops (%d)", -errno);
2335
2336 optlen = sizeof(verify);
2337 ret = zsock_getsockopt(client_sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_UNICAST_HOPS, &verify,
2338 &optlen);
2339 zassert_equal(ret, 0, "Cannot get unicast hops (%d)", -errno);
2340 zassert_equal(verify, hops, "Different unicast hops (%d vs %d)",
2341 hops, verify);
2342
2343 test_check_ttl(client_sock, server_sock, packet_sock,
2344 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
2345 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
2346 (struct net_sockaddr *)&server_addr, sizeof(server_addr),
2347 NET_AF_INET6, hops, 0);
2348 }
2349
ZTEST_USER(net_socket_udp,test_recvmsg_msg_controllen_update)2350 ZTEST_USER(net_socket_udp, test_recvmsg_msg_controllen_update)
2351 {
2352 int rv;
2353 int client_sock;
2354 int server_sock;
2355 struct net_sockaddr_in client_addr;
2356 struct net_sockaddr_in server_addr;
2357 struct net_msghdr msg, server_msg;
2358 struct net_iovec io_vector[1];
2359 union {
2360 struct net_cmsghdr hdr;
2361 unsigned char buf[NET_CMSG_SPACE(sizeof(struct net_in6_pktinfo))];
2362 } cmsgbuf;
2363
2364 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
2365 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
2366
2367 rv = zsock_bind(server_sock,
2368 (struct net_sockaddr *)&server_addr,
2369 sizeof(server_addr));
2370 zassert_equal(rv, 0, "server bind failed");
2371
2372 rv = zsock_bind(client_sock,
2373 (struct net_sockaddr *)&client_addr,
2374 sizeof(client_addr));
2375 zassert_equal(rv, 0, "client bind failed");
2376
2377 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
2378
2379 io_vector[0].iov_base = TEST_STR_SMALL;
2380 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
2381
2382 memset(&msg, 0, sizeof(msg));
2383 msg.msg_iov = io_vector;
2384 msg.msg_iovlen = 1;
2385 msg.msg_name = &server_addr;
2386 msg.msg_namelen = sizeof(server_addr);
2387
2388 comm_sendmsg_recvmsg(client_sock,
2389 (struct net_sockaddr *)&client_addr,
2390 sizeof(client_addr),
2391 &msg,
2392 server_sock,
2393 (struct net_sockaddr *)&server_addr,
2394 sizeof(server_addr),
2395 &server_msg,
2396 &cmsgbuf.buf,
2397 sizeof(cmsgbuf.buf),
2398 false);
2399
2400 rv = zsock_close(client_sock);
2401 zassert_equal(rv, 0, "close failed");
2402 rv = zsock_close(server_sock);
2403 zassert_equal(rv, 0, "close failed");
2404 }
2405
ZTEST(net_socket_udp,test_v6_address_removal)2406 ZTEST(net_socket_udp, test_v6_address_removal)
2407 {
2408 int ret;
2409 bool status;
2410 int client_sock;
2411 struct net_sockaddr_in6 client_addr;
2412 struct net_if_addr *ifaddr;
2413 struct net_if *iface;
2414
2415 if (!IS_ENABLED(CONFIG_NET_IPV6_PE)) {
2416 return;
2417 }
2418
2419 ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
2420 zassert_equal(ifaddr->atomic_ref, 1, "Ref count is wrong (%ld vs %d)",
2421 ifaddr->atomic_ref, 1);
2422
2423 prepare_sock_udp_v6(MY_IPV6_ADDR_ETH, CLIENT_PORT, &client_sock, &client_addr);
2424
2425 ret = zsock_bind(client_sock,
2426 (struct net_sockaddr *)&client_addr,
2427 sizeof(client_addr));
2428 zassert_equal(ret, 0, "client bind failed");
2429
2430 status = net_if_ipv6_addr_rm(eth_iface, &my_addr1);
2431 zassert_false(status, "Address could be removed");
2432
2433 ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
2434 zassert_not_null(ifaddr, "Address %s not found",
2435 net_sprint_ipv6_addr(&my_addr1));
2436
2437 ret = zsock_close(client_sock);
2438 zassert_equal(ret, 0, "close failed");
2439
2440 ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
2441 zassert_equal(iface, eth_iface, "Invalid interface %p vs %p",
2442 iface, eth_iface);
2443 zassert_is_null(ifaddr, "Address %s found",
2444 net_sprint_ipv6_addr(&my_addr1));
2445 }
2446
check_ipv6_address_preferences(struct net_if * iface,uint16_t preference,const struct net_in6_addr * addr,const struct net_in6_addr * dest)2447 static void check_ipv6_address_preferences(struct net_if *iface,
2448 uint16_t preference,
2449 const struct net_in6_addr *addr,
2450 const struct net_in6_addr *dest)
2451 {
2452 const struct net_in6_addr *selected;
2453 net_socklen_t optlen;
2454 int optval;
2455 int sock;
2456 int ret;
2457
2458 sock = zsock_socket(NET_AF_INET6, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2459 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2460
2461 optval = preference;
2462 ret = zsock_setsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_ADDR_PREFERENCES,
2463 &optval, sizeof(optval));
2464 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2465
2466 optval = 0; optlen = 0U;
2467 ret = zsock_getsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_ADDR_PREFERENCES,
2468 &optval, &optlen);
2469 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2470 zassert_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2471 optlen, sizeof(optval));
2472 zassert_equal(optval, preference,
2473 "getsockopt address preferences");
2474
2475 selected = net_if_ipv6_select_src_addr_hint(iface,
2476 dest,
2477 preference);
2478 ret = net_ipv6_addr_cmp(addr, selected);
2479 zassert_true(ret, "Wrong address %s selected, expected %s",
2480 net_sprint_ipv6_addr(selected),
2481 net_sprint_ipv6_addr(addr));
2482
2483 ret = zsock_close(sock);
2484 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2485 }
2486
ZTEST(net_socket_udp,test_ipv6_src_addr_select)2487 ZTEST(net_socket_udp, test_ipv6_src_addr_select)
2488 {
2489 struct net_if_addr *ifaddr;
2490 const struct net_in6_addr dest = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
2491 0, 0, 0, 0, 0, 0, 0, 0x2 } } };
2492
2493 net_if_foreach(iface_cb, ð_iface);
2494 zassert_not_null(eth_iface, "No ethernet interface found");
2495
2496 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr1,
2497 NET_ADDR_AUTOCONF, 0);
2498 if (!ifaddr) {
2499 DBG("Cannot add IPv6 address %s\n",
2500 net_sprint_ipv6_addr(&my_addr1));
2501 zassert_not_null(ifaddr, "addr1");
2502 }
2503
2504 ifaddr->is_temporary = false;
2505
2506 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr3,
2507 NET_ADDR_AUTOCONF, 0);
2508 if (!ifaddr) {
2509 DBG("Cannot add IPv6 address %s\n",
2510 net_sprint_ipv6_addr(&my_addr3));
2511 zassert_not_null(ifaddr, "addr1");
2512 }
2513
2514 ifaddr->is_temporary = true;
2515
2516 net_if_up(eth_iface);
2517
2518 check_ipv6_address_preferences(NULL, ZSOCK_IPV6_PREFER_SRC_PUBLIC,
2519 &my_addr1, &dest);
2520 check_ipv6_address_preferences(NULL, ZSOCK_IPV6_PREFER_SRC_TMP,
2521 &my_addr3, &dest);
2522 }
2523
ZTEST(net_socket_udp,test_ipv6_multicast_ifindex)2524 ZTEST(net_socket_udp, test_ipv6_multicast_ifindex)
2525 {
2526 struct net_sockaddr_in6 saddr6 = {
2527 .sin6_family = NET_AF_INET6,
2528 .sin6_port = net_htons(SERVER_PORT),
2529 .sin6_addr = my_mcast_addr1,
2530 };
2531 struct net_if_mcast_addr *ifmaddr;
2532 struct net_if_addr *ifaddr;
2533 int server_sock;
2534 net_socklen_t addrlen;
2535 net_socklen_t optlen;
2536 int ifindex;
2537 int optval;
2538 int sock;
2539 int ret;
2540 int err;
2541
2542 net_if_foreach(iface_cb, ð_iface);
2543 zassert_not_null(eth_iface, "No ethernet interface found");
2544
2545 ifmaddr = net_if_ipv6_maddr_add(eth_iface, &my_mcast_addr1);
2546 if (!ifmaddr) {
2547 DBG("Cannot add IPv6 multicast address %s\n",
2548 net_sprint_ipv6_addr(&my_mcast_addr1));
2549 zassert_not_null(ifmaddr, "mcast_addr1");
2550 }
2551
2552 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr3,
2553 NET_ADDR_AUTOCONF, 0);
2554 if (!ifaddr) {
2555 DBG("Cannot add IPv6 address %s\n",
2556 net_sprint_ipv6_addr(&my_addr3));
2557 zassert_not_null(ifaddr, "addr1");
2558 }
2559
2560 net_if_up(eth_iface);
2561
2562 /* Check that we get the default interface */
2563 sock = zsock_socket(NET_AF_INET6, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2564 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2565
2566 optval = 0; optlen = 0U;
2567 ret = zsock_getsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_IF,
2568 &optval, &optlen);
2569 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2570 zexpect_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2571 optlen, sizeof(optval));
2572 ifindex = net_if_get_by_iface(net_if_get_default());
2573 zexpect_equal(optval, ifindex,
2574 "getsockopt multicast ifindex (expected %d got %d)",
2575 ifindex, optval);
2576
2577 ret = zsock_close(sock);
2578 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2579
2580 /* Check failure for IPv4 socket */
2581 sock = zsock_socket(NET_AF_INET, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2582 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2583
2584 optval = 0; optlen = 0U;
2585 ret = zsock_getsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_IF,
2586 &optval, &optlen);
2587 err = -errno;
2588 zexpect_equal(ret, -1, "setsockopt failed (%d)", errno);
2589 zexpect_equal(err, -EAFNOSUPPORT, "setsockopt failed (%d)", errno);
2590 zexpect_equal(optlen, 0U, "setsockopt optlen (%d)", optlen);
2591
2592 ret = zsock_close(sock);
2593 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2594
2595 /* Check that we can set the interface */
2596 sock = zsock_socket(NET_AF_INET6, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2597 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2598
2599 /* Clear any existing interface value by setting it to 0 */
2600 optval = 0; optlen = sizeof(int);
2601 ret = zsock_setsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_IF,
2602 &optval, optlen);
2603 err = -errno;
2604 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2605 zexpect_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2606 optlen, sizeof(optval));
2607
2608 /* Set the output multicast packet interface to the default interface */
2609 optval = net_if_get_by_iface(net_if_get_default()); optlen = sizeof(int);
2610 ret = zsock_setsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_IF,
2611 &optval, optlen);
2612 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2613 zexpect_equal(optlen, sizeof(optval), "invalid optlen %d vs %d",
2614 optlen, sizeof(optval));
2615
2616 optval = 0; optlen = 0U;
2617 ret = zsock_getsockopt(sock, NET_IPPROTO_IPV6, ZSOCK_IPV6_MULTICAST_IF,
2618 &optval, &optlen);
2619 err = -errno;
2620 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2621 zexpect_equal(optlen, sizeof(int), "setsockopt optlen (%d)", optlen);
2622 zexpect_equal(optval, net_if_get_by_iface(net_if_get_default()),
2623 "getsockopt multicast ifindex (expected %d got %d)",
2624 net_if_get_by_iface(net_if_get_default()), optval);
2625
2626 server_sock = prepare_listen_sock_udp_v6(&saddr6);
2627 zassert_not_equal(server_sock, -1, "Cannot create server socket (%d)", -errno);
2628
2629 test_started = true;
2630 loopback_enable_address_swap(false);
2631
2632 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2633 (struct net_sockaddr *)&saddr6, sizeof(saddr6));
2634 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2635 "invalid send len (was %d expected %d) (%d)",
2636 ret, STRLEN(TEST_STR_SMALL), -errno);
2637
2638 /* Test that the sent data is received from default interface and
2639 * not the Ethernet one.
2640 */
2641 addrlen = sizeof(saddr6);
2642 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2643 0, (struct net_sockaddr *)&saddr6, &addrlen);
2644 zexpect_true(ret >= 0, "recvfrom fail");
2645 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2646 "unexpected received bytes");
2647 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2648 "wrong data");
2649
2650 ret = zsock_close(sock);
2651 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2652
2653 ret = zsock_close(server_sock);
2654 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2655
2656 test_started = false;
2657 loopback_enable_address_swap(true);
2658 }
2659
ZTEST(net_socket_udp,test_ipv4_multicast_ifindex)2660 ZTEST(net_socket_udp, test_ipv4_multicast_ifindex)
2661 {
2662 struct net_sockaddr_in saddr4 = {
2663 .sin_family = NET_AF_INET,
2664 .sin_port = net_htons(SERVER_PORT),
2665 .sin_addr = my_mcast_addr2,
2666 };
2667 struct net_sockaddr_in dst_addr = {
2668 .sin_family = NET_AF_INET,
2669 .sin_port = net_htons(SERVER_PORT),
2670 .sin_addr = my_mcast_addr2,
2671 };
2672 struct net_if_mcast_addr *ifmaddr;
2673 struct net_if_addr *ifaddr;
2674 struct net_in_addr addr = { 0 };
2675 struct net_ip_mreqn mreqn;
2676 struct net_ip_mreq mreq;
2677 struct net_if *iface;
2678 int server_sock;
2679 net_socklen_t addrlen;
2680 net_socklen_t optlen;
2681 int ifindex;
2682 int sock;
2683 int ret;
2684 int err;
2685
2686 net_if_foreach(iface_cb, ð_iface);
2687 zassert_not_null(eth_iface, "No ethernet interface found");
2688
2689 ifmaddr = net_if_ipv4_maddr_add(eth_iface, &my_mcast_addr2);
2690 if (!ifmaddr) {
2691 DBG("Cannot add IPv4 multicast address %s\n",
2692 net_sprint_ipv4_addr(&my_mcast_addr2));
2693 zassert_not_null(ifmaddr, "mcast_addr2");
2694 }
2695
2696 ifaddr = net_if_ipv4_addr_add(eth_iface, &my_addr2,
2697 NET_ADDR_MANUAL, 0);
2698 if (!ifaddr) {
2699 DBG("Cannot add IPv4 address %s\n",
2700 net_sprint_ipv4_addr(&my_addr2));
2701 zassert_not_null(ifaddr, "addr2");
2702 }
2703
2704 net_if_up(eth_iface);
2705
2706 /* Check that we get the default interface */
2707 sock = zsock_socket(NET_AF_INET, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2708 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2709
2710 optlen = sizeof(addr);
2711 ret = zsock_getsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2712 &addr, &optlen);
2713 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2714 zexpect_equal(optlen, sizeof(addr), "invalid optlen %d vs %d",
2715 optlen, sizeof(addr));
2716 ifindex = net_if_get_by_iface(net_if_get_default());
2717 ret = net_if_ipv4_addr_lookup_by_index(&addr);
2718 zexpect_equal(ret, ifindex,
2719 "getsockopt multicast ifindex (expected %d got %d)",
2720 ifindex, ret);
2721
2722 ret = zsock_close(sock);
2723 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2724
2725 /* Check failure for IPv6 socket */
2726 sock = zsock_socket(NET_AF_INET6, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2727 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2728
2729 optlen = 0U;
2730 ret = zsock_getsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2731 &addr, &optlen);
2732 err = -errno;
2733 zexpect_equal(ret, -1, "setsockopt failed (%d)", errno);
2734 zexpect_equal(err, -EAFNOSUPPORT, "setsockopt failed (%d)", errno);
2735 zexpect_equal(optlen, 0U, "setsockopt optlen (%d)", optlen);
2736
2737 ret = zsock_close(sock);
2738 zassert_equal(sock, 0, "Cannot close socket (%d)", -errno);
2739
2740 /* Check that we can set the interface */
2741 sock = zsock_socket(NET_AF_INET, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2742 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2743
2744 /* Clear any existing interface value by setting it to 0 */
2745 optlen = sizeof(mreqn);
2746 mreqn.imr_ifindex = 0;
2747 mreqn.imr_address.s_addr = 0;
2748
2749 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2750 &mreqn, optlen);
2751 err = -errno;
2752 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2753
2754 /* Verify that we get the empty value */
2755 optlen = sizeof(addr);
2756 ret = zsock_getsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2757 &addr, &optlen);
2758 err = -errno;
2759 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2760 zexpect_equal(optlen, sizeof(addr), "setsockopt optlen (%d)", optlen);
2761
2762 /* Set the output multicast packet interface to the default interface */
2763 optlen = sizeof(mreqn);
2764 mreqn.imr_ifindex = net_if_get_by_iface(net_if_get_default());
2765 mreqn.imr_address.s_addr = 0;
2766
2767 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2768 &mreqn, optlen);
2769 err = -errno;
2770 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2771
2772 /* Verify that we get the default interface */
2773 optlen = sizeof(addr);
2774 memset(&addr, 0, sizeof(addr));
2775 ret = zsock_getsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2776 &addr, &optlen);
2777 err = -errno;
2778 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2779 zexpect_equal(optlen, sizeof(addr), "setsockopt optlen (%d)", optlen);
2780
2781 ifaddr = net_if_ipv4_addr_lookup(&addr, &iface);
2782 zexpect_not_null(ifaddr, "Address %s not found",
2783 net_sprint_ipv4_addr(&addr));
2784 zexpect_equal(net_if_get_by_iface(iface),
2785 net_if_get_by_iface(net_if_get_default()),
2786 "Invalid interface %d vs %d",
2787 net_if_get_by_iface(iface),
2788 net_if_get_by_iface(net_if_get_default()));
2789
2790 /* Now send a packet and verify that it is sent via the default
2791 * interface instead of the Ethernet interface.
2792 */
2793 server_sock = prepare_listen_sock_udp_v4(&saddr4);
2794 zassert_not_equal(server_sock, -1, "Cannot create server socket (%d)", -errno);
2795
2796 test_started = true;
2797 loopback_enable_address_swap(false);
2798
2799 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2800 (struct net_sockaddr *)&dst_addr, sizeof(dst_addr));
2801 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2802 "invalid send len (was %d expected %d) (%d)",
2803 ret, STRLEN(TEST_STR_SMALL), -errno);
2804
2805 /* Test that the sent data is received from Ethernet interface. */
2806 addrlen = sizeof(saddr4);
2807 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2808 0, (struct net_sockaddr *)&saddr4, &addrlen);
2809 zexpect_true(ret >= 0, "recvfrom fail");
2810 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2811 "unexpected received bytes");
2812 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2813 "wrong data");
2814
2815 /* Clear the old interface value by setting it to 0 */
2816 optlen = sizeof(mreqn);
2817 mreqn.imr_ifindex = 0;
2818 mreqn.imr_address.s_addr = 0;
2819
2820 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2821 &mreqn, optlen);
2822 err = -errno;
2823 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2824
2825 /* Then do it the other way around, set the address but leave the
2826 * interface number unassigned.
2827 */
2828 optlen = sizeof(mreqn);
2829 mreqn.imr_ifindex = 0;
2830
2831 /* Get the address of default interface and set it as a target
2832 * interface.
2833 */
2834 ifaddr = net_if_ipv4_addr_get_first_by_index(net_if_get_by_iface(net_if_get_default()));
2835 zexpect_not_null(ifaddr, "No address found for interface %d",
2836 net_if_get_by_iface(net_if_get_default()));
2837 mreqn.imr_address.s_addr = ifaddr->address.in_addr.s_addr;
2838
2839 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2840 &mreqn, optlen);
2841 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2842
2843 /* Verify that we get the default interface address */
2844 optlen = sizeof(struct net_in_addr);
2845 ret = zsock_getsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2846 &addr, &optlen);
2847 err = -errno;
2848 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2849 zexpect_equal(optlen, sizeof(struct net_in_addr), "setsockopt optlen (%d)", optlen);
2850 ret = net_if_ipv4_addr_lookup_by_index(&addr);
2851 zexpect_equal(ret, net_if_get_by_iface(net_if_get_default()),
2852 "getsockopt multicast ifindex (expected %d got %d)",
2853 net_if_get_by_iface(net_if_get_default()), ret);
2854 zexpect_equal(ifaddr->address.in_addr.s_addr,
2855 addr.s_addr,
2856 "getsockopt iface address mismatch (expected %s got %s)",
2857 net_sprint_ipv4_addr(&ifaddr->address.in_addr),
2858 net_sprint_ipv4_addr(&addr));
2859
2860 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2861 (struct net_sockaddr *)&dst_addr, sizeof(dst_addr));
2862 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2863 "invalid send len (was %d expected %d) (%d)",
2864 ret, STRLEN(TEST_STR_SMALL), -errno);
2865
2866 /* Test that the sent data is received from default interface. */
2867 addrlen = sizeof(saddr4);
2868 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2869 0, (struct net_sockaddr *)&saddr4, &addrlen);
2870 zexpect_true(ret >= 0, "recvfrom fail");
2871 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2872 "unexpected received bytes");
2873 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2874 "wrong data");
2875
2876 /* Then use mreq structure to set the interface */
2877 optlen = sizeof(mreq);
2878 ifaddr = net_if_ipv4_addr_get_first_by_index(net_if_get_by_iface(net_if_get_default()));
2879 zexpect_not_null(ifaddr, "No address found for interface %d",
2880 net_if_get_by_iface(net_if_get_default()));
2881 mreq.imr_interface.s_addr = ifaddr->address.in_addr.s_addr;
2882
2883 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_MULTICAST_IF,
2884 &mreq, optlen);
2885 zexpect_equal(ret, 0, "setsockopt failed (%d)", errno);
2886
2887 ret = zsock_sendto(sock, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
2888 (struct net_sockaddr *)&dst_addr, sizeof(dst_addr));
2889 zexpect_equal(ret, STRLEN(TEST_STR_SMALL),
2890 "invalid send len (was %d expected %d) (%d)",
2891 ret, STRLEN(TEST_STR_SMALL), -errno);
2892
2893 /* Test that the sent data is received from default interface. */
2894 addrlen = sizeof(saddr4);
2895 ret = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
2896 0, (struct net_sockaddr *)&saddr4, &addrlen);
2897 zexpect_true(ret >= 0, "recvfrom fail");
2898 zexpect_equal(ret, strlen(TEST_STR_SMALL),
2899 "unexpected received bytes");
2900 zexpect_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1,
2901 "wrong data");
2902
2903 ret = zsock_close(sock);
2904 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2905
2906 ret = zsock_close(server_sock);
2907 zassert_equal(ret, 0, "Cannot close socket (%d)", -errno);
2908
2909 test_started = false;
2910 loopback_enable_address_swap(true);
2911 }
2912
2913 #if defined(CONFIG_NET_CONTEXT_CLAMP_PORT_RANGE)
2914
2915 #define PORT_RANGE(lower, upper) \
2916 (uint32_t)(((uint16_t)(upper) << 16) | (uint16_t)(lower))
2917
check_port_range(struct net_sockaddr * my_addr,size_t my_addr_len,struct net_sockaddr * local_addr,size_t local_addr_len)2918 static void check_port_range(struct net_sockaddr *my_addr,
2919 size_t my_addr_len,
2920 struct net_sockaddr *local_addr,
2921 size_t local_addr_len)
2922 {
2923 net_sa_family_t family = NET_AF_UNSPEC;
2924 uint32_t optval;
2925 net_socklen_t addr_len;
2926 net_socklen_t optlen;
2927 int sock;
2928 int ret, err;
2929
2930 addr_len = local_addr_len;
2931
2932 if (my_addr->sa_family == NET_AF_INET) {
2933 family = NET_AF_INET;
2934 } else if (my_addr->sa_family == NET_AF_INET6) {
2935 family = NET_AF_INET6;
2936 } else {
2937 zassert_true(false, "Invalid address family %d",
2938 my_addr->sa_family);
2939 }
2940
2941 sock = zsock_socket(family, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
2942 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
2943
2944 optval = PORT_RANGE(1024, 1500);
2945 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2946 &optval, sizeof(optval));
2947 err = -errno;
2948 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2949
2950 optval = 0; optlen = 0U;
2951 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2952 &optval, optlen);
2953 err = -errno;
2954 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
2955
2956 optval = 0; optlen = sizeof(uint64_t);
2957 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2958 &optval, optlen);
2959 err = -errno;
2960 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
2961
2962 optval = PORT_RANGE(0, 0);
2963 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2964 &optval, sizeof(optval));
2965 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2966
2967 /* Linux allows setting the invalid port range but that is not
2968 * then taken into use when we bind the socket.
2969 */
2970 optval = PORT_RANGE(1024, 0);
2971 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2972 &optval, sizeof(optval));
2973 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2974
2975 optval = PORT_RANGE(0, 1024);
2976 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2977 &optval, sizeof(optval));
2978 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2979
2980 /* Then set a valid range and verify that bound socket is using it */
2981 optval = PORT_RANGE(10000, 10010);
2982 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2983 &optval, sizeof(optval));
2984 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2985
2986 optval = 0; optlen = sizeof(optval);
2987 ret = zsock_getsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
2988 &optval, &optlen);
2989 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
2990 zexpect_equal(optval, PORT_RANGE(10000, 10010), "Invalid port range");
2991
2992 ret = zsock_bind(sock, my_addr, my_addr_len);
2993 err = -errno;
2994 zexpect_equal(ret, 0, "bind failed (%d)", err);
2995
2996 ret = zsock_getsockname(sock, local_addr, &addr_len);
2997 err = -errno;
2998 zexpect_equal(ret, 0, "getsockname failed (%d)", err);
2999
3000 /* The port should be in the range */
3001 zexpect_true(net_ntohs(net_sin(local_addr)->sin_port) >= 10000 &&
3002 net_ntohs(net_sin(local_addr)->sin_port) <= 10010,
3003 "Invalid port %d", net_ntohs(net_sin(local_addr)->sin_port));
3004
3005 (void)zsock_close(sock);
3006
3007 /* Try setting invalid range and verify that we do not net a port from that
3008 * range.
3009 */
3010 sock = zsock_socket(family, NET_SOCK_DGRAM, NET_IPPROTO_UDP);
3011 zassert_true(sock >= 0, "Cannot create socket (%d)", -errno);
3012
3013 optval = PORT_RANGE(1001, 1000);
3014 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
3015 &optval, sizeof(optval));
3016 err = -errno;
3017 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
3018 zexpect_equal(err, -EINVAL, "Invalid errno (%d)", -err);
3019
3020 /* Port range cannot be just one port */
3021 optval = PORT_RANGE(1001, 1001);
3022 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
3023 &optval, sizeof(optval));
3024 err = -errno;
3025 zexpect_equal(ret, -1, "setsockopt failed (%d)", err);
3026 zexpect_equal(err, -EINVAL, "Invalid errno (%d)", -err);
3027
3028 optval = PORT_RANGE(0, 1000);
3029 ret = zsock_setsockopt(sock, NET_IPPROTO_IP, ZSOCK_IP_LOCAL_PORT_RANGE,
3030 &optval, sizeof(optval));
3031 err = -errno;
3032 zexpect_equal(ret, 0, "setsockopt failed (%d)", err);
3033
3034 ret = zsock_bind(sock, my_addr, my_addr_len);
3035 err = -errno;
3036 zexpect_equal(ret, 0, "bind failed (%d)", err);
3037
3038 addr_len = local_addr_len;
3039 ret = zsock_getsockname(sock, local_addr, &addr_len);
3040 err = -errno;
3041 zexpect_equal(ret, 0, "getsockname failed (%d)", err);
3042
3043 /* The port should not be in the range */
3044 zexpect_false(net_ntohs(net_sin(local_addr)->sin_port) >= 1000 &&
3045 net_ntohs(net_sin(local_addr)->sin_port) <= 1001,
3046 "Invalid port %d", net_ntohs(net_sin(local_addr)->sin_port));
3047
3048 (void)zsock_close(sock);
3049 }
3050 #endif
3051
ZTEST(net_socket_udp,test_clamp_udp_tcp_port_range)3052 ZTEST(net_socket_udp, test_clamp_udp_tcp_port_range)
3053 {
3054 #if defined(CONFIG_NET_CONTEXT_CLAMP_PORT_RANGE)
3055 struct net_sockaddr_in my_addr4 = {
3056 .sin_family = NET_AF_INET,
3057 .sin_port = 0,
3058 .sin_addr = { { { 192, 0, 2, 2 } } },
3059 };
3060 struct net_sockaddr_in6 my_addr6 = {
3061 .sin6_family = NET_AF_INET6,
3062 .sin6_port = 0,
3063 .sin6_addr = net_in6addr_loopback,
3064 };
3065 struct net_sockaddr_in local_addr4;
3066 struct net_sockaddr_in6 local_addr6;
3067
3068 /* First try with a IPv4 socket */
3069 check_port_range((struct net_sockaddr *)&my_addr4, sizeof(my_addr4),
3070 (struct net_sockaddr *)&local_addr4, sizeof(local_addr4));
3071
3072 /* Finally try with a IPv6 socket */
3073 check_port_range((struct net_sockaddr *)&my_addr6, sizeof(my_addr6),
3074 (struct net_sockaddr *)&local_addr6, sizeof(local_addr6));
3075 #else
3076 ztest_test_skip();
3077 #endif
3078 }
3079
test_dgram_peer_addr_reset(int sock_c,int sock_s1,int sock_s2,struct net_sockaddr * addr_c,net_socklen_t addrlen_c,struct net_sockaddr * addr_s1,net_socklen_t addrlen_s1,struct net_sockaddr * addr_s2,net_socklen_t addrlen_s2)3080 static void test_dgram_peer_addr_reset(int sock_c, int sock_s1, int sock_s2,
3081 struct net_sockaddr *addr_c, net_socklen_t addrlen_c,
3082 struct net_sockaddr *addr_s1, net_socklen_t addrlen_s1,
3083 struct net_sockaddr *addr_s2, net_socklen_t addrlen_s2)
3084 {
3085 uint8_t tx_buf = 0xab;
3086 uint8_t rx_buf;
3087 struct net_sockaddr_storage unspec = {
3088 .ss_family = NET_AF_UNSPEC,
3089 };
3090 int rv;
3091
3092 rv = zsock_bind(sock_c, addr_c, addrlen_c);
3093 zassert_equal(rv, 0, "client bind failed");
3094
3095 rv = zsock_bind(sock_s1, addr_s1, addrlen_s1);
3096 zassert_equal(rv, 0, "server bind failed");
3097
3098 rv = zsock_bind(sock_s2, addr_s2, addrlen_s2);
3099 zassert_equal(rv, 0, "server bind failed");
3100
3101 /* Connect client socket to a specific peer address. */
3102 rv = zsock_connect(sock_c, addr_s1, addrlen_s1);
3103 zassert_equal(rv, 0, "connect failed");
3104
3105 /* Verify that a datagram is not received from other address */
3106 rv = zsock_sendto(sock_s2, &tx_buf, sizeof(tx_buf), 0, addr_c, addrlen_c);
3107 zassert_equal(rv, sizeof(tx_buf), "send failed");
3108
3109 /* Give the packet a chance to go through the net stack */
3110 k_msleep(10);
3111
3112 rv = zsock_recv(sock_c, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
3113 zassert_equal(rv, -1, "recv should've failed");
3114 zassert_equal(errno, EAGAIN, "incorrect errno");
3115
3116 /* Reset peer address */
3117 rv = zsock_connect(sock_c, (struct net_sockaddr *)&unspec, sizeof(unspec));
3118 zassert_equal(rv, 0, "connect failed");
3119
3120 /* Verify that a datagram can be received from other address */
3121 rv = zsock_sendto(sock_s2, &tx_buf, sizeof(tx_buf), 0, addr_c, addrlen_c);
3122 zassert_equal(rv, sizeof(tx_buf), "send failed");
3123
3124 /* Give the packet a chance to go through the net stack */
3125 k_msleep(10);
3126
3127 rx_buf = 0;
3128 rv = zsock_recv(sock_c, &rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
3129 zassert_equal(rv, sizeof(rx_buf), "recv failed %d", errno);
3130 zassert_equal(rx_buf, tx_buf, "wrong data");
3131
3132 rv = zsock_close(sock_c);
3133 zassert_equal(rv, 0, "close failed");
3134 rv = zsock_close(sock_s1);
3135 zassert_equal(rv, 0, "close failed");
3136 rv = zsock_close(sock_s2);
3137 zassert_equal(rv, 0, "close failed");
3138 }
3139
ZTEST(net_socket_udp,test_v4_dgram_peer_addr_reset)3140 ZTEST(net_socket_udp, test_v4_dgram_peer_addr_reset)
3141 {
3142 int client_sock;
3143 int server_sock_1;
3144 int server_sock_2;
3145 struct net_sockaddr_in client_addr;
3146 struct net_sockaddr_in server_addr_1;
3147 struct net_sockaddr_in server_addr_2;
3148
3149 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock, &client_addr);
3150 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock_1, &server_addr_1);
3151 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT + 1, &server_sock_2, &server_addr_2);
3152
3153 test_dgram_peer_addr_reset(client_sock, server_sock_1, server_sock_2,
3154 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
3155 (struct net_sockaddr *)&server_addr_1, sizeof(server_addr_1),
3156 (struct net_sockaddr *)&server_addr_2, sizeof(server_addr_2));
3157 }
3158
ZTEST(net_socket_udp,test_v6_dgram_peer_addr_reset)3159 ZTEST(net_socket_udp, test_v6_dgram_peer_addr_reset)
3160 {
3161 int client_sock;
3162 int server_sock_1;
3163 int server_sock_2;
3164 struct net_sockaddr_in6 client_addr;
3165 struct net_sockaddr_in6 server_addr_1;
3166 struct net_sockaddr_in6 server_addr_2;
3167
3168 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock, &client_addr);
3169 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock_1, &server_addr_1);
3170 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT + 1, &server_sock_2, &server_addr_2);
3171
3172 test_dgram_peer_addr_reset(client_sock, server_sock_1, server_sock_2,
3173 (struct net_sockaddr *)&client_addr, sizeof(client_addr),
3174 (struct net_sockaddr *)&server_addr_1, sizeof(server_addr_1),
3175 (struct net_sockaddr *)&server_addr_2, sizeof(server_addr_2));
3176 }
3177
comm_sendmsg_recvmsg_hop_limit(int client_sock,struct net_sockaddr * client_addr,net_socklen_t client_addrlen,const struct net_msghdr * client_msg,int server_sock,struct net_sockaddr * server_addr,net_socklen_t server_addrlen,struct net_msghdr * msg,void * cmsgbuf,int cmsgbuf_len,bool expect_control_data)3178 static void comm_sendmsg_recvmsg_hop_limit(int client_sock,
3179 struct net_sockaddr *client_addr,
3180 net_socklen_t client_addrlen,
3181 const struct net_msghdr *client_msg,
3182 int server_sock,
3183 struct net_sockaddr *server_addr,
3184 net_socklen_t server_addrlen,
3185 struct net_msghdr *msg,
3186 void *cmsgbuf, int cmsgbuf_len,
3187 bool expect_control_data)
3188 {
3189 #define MAX_BUF_LEN 64
3190 char buf[MAX_BUF_LEN];
3191 struct net_iovec io_vector[1];
3192 ssize_t sent;
3193 ssize_t recved;
3194 struct net_sockaddr addr;
3195 net_socklen_t addrlen = server_addrlen;
3196 int len, i;
3197
3198 zassert_not_null(client_addr, "null client addr");
3199 zassert_not_null(server_addr, "null server addr");
3200
3201 /*
3202 * Test client -> server sending
3203 */
3204
3205 sent = zsock_sendmsg(client_sock, client_msg, 0);
3206 zassert_true(sent > 0, "sendmsg failed, %s (%d)", strerror(errno), -errno);
3207
3208 /* One negative test with invalid msg_iov */
3209 memset(msg, 0, sizeof(*msg));
3210 recved = zsock_recvmsg(server_sock, msg, 0);
3211 zassert_true(recved < 0 && errno == ENOMEM, "Wrong errno (%d)", errno);
3212
3213 for (i = 0, len = 0; i < client_msg->msg_iovlen; i++) {
3214 len += client_msg->msg_iov[i].iov_len;
3215 }
3216
3217 zassert_equal(sent, len, "iovec len (%d) vs sent (%d)", len, sent);
3218
3219 /* Test first with one iovec */
3220 io_vector[0].iov_base = buf;
3221 io_vector[0].iov_len = sizeof(buf);
3222
3223 memset(msg, 0, sizeof(*msg));
3224 if (cmsgbuf != NULL) {
3225 memset(cmsgbuf, 0, cmsgbuf_len);
3226 }
3227 msg->msg_control = cmsgbuf;
3228 msg->msg_controllen = cmsgbuf_len;
3229 msg->msg_iov = io_vector;
3230 msg->msg_iovlen = 1;
3231 msg->msg_name = &addr;
3232 msg->msg_namelen = addrlen;
3233
3234 /* Test normal recvmsg() */
3235 clear_buf(rx_buf);
3236 recved = zsock_recvmsg(server_sock, msg, 0);
3237 zassert_true(recved > 0, "recvfrom fail");
3238 zassert_equal(recved, len, "unexpected received bytes");
3239 zassert_equal(msg->msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
3240 zassert_equal(msg->msg_iov[0].iov_len, sizeof(buf),
3241 "recvmsg should not modify buffer length");
3242 zassert_mem_equal(buf, TEST_STR_SMALL, len,
3243 "wrong data (%s)", rx_buf);
3244 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
3245
3246 /* Control data should be empty */
3247 if (!expect_control_data) {
3248 zassert_equal(msg->msg_controllen, 0,
3249 "We received control data (%u vs %zu)",
3250 0U, msg->msg_controllen);
3251 }
3252 }
3253
run_ancillary_recvmsg_hoplimit_test(int client_sock,struct net_sockaddr * client_addr,int client_addr_len,int server_sock,struct net_sockaddr * server_addr,int server_addr_len)3254 static void run_ancillary_recvmsg_hoplimit_test(int client_sock,
3255 struct net_sockaddr *client_addr,
3256 int client_addr_len,
3257 int server_sock,
3258 struct net_sockaddr *server_addr,
3259 int server_addr_len)
3260 {
3261 int rv;
3262 int opt;
3263 net_socklen_t optlen;
3264 struct net_msghdr msg;
3265 struct net_msghdr server_msg;
3266 struct net_iovec io_vector[1];
3267 struct net_cmsghdr *cmsg, *prevcmsg;
3268 int send_hop_limit = 90, recv_hop_limit = 0;
3269 union {
3270 struct net_cmsghdr hdr;
3271 unsigned char buf[NET_CMSG_SPACE(sizeof(int))];
3272 } cmsgbuf;
3273
3274 Z_TEST_SKIP_IFNDEF(CONFIG_NET_CONTEXT_RECV_HOPLIMIT);
3275
3276 rv = zsock_bind(server_sock, server_addr, server_addr_len);
3277 zassert_equal(rv, 0, "server bind failed");
3278
3279 rv = zsock_bind(client_sock, client_addr, client_addr_len);
3280 zassert_equal(rv, 0, "client bind failed");
3281
3282 io_vector[0].iov_base = TEST_STR_SMALL;
3283 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
3284
3285 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
3286
3287 memset(&msg, 0, sizeof(msg));
3288 msg.msg_name = server_addr;
3289 msg.msg_namelen = server_addr_len;
3290 msg.msg_iov = io_vector;
3291 msg.msg_iovlen = 1;
3292 msg.msg_control = &cmsgbuf.buf;
3293 msg.msg_controllen = sizeof(cmsgbuf.buf);
3294
3295 cmsg = NET_CMSG_FIRSTHDR(&msg);
3296 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
3297 if (client_addr->sa_family == NET_AF_INET) {
3298 cmsg->cmsg_level = NET_IPPROTO_IP;
3299 cmsg->cmsg_type = ZSOCK_IP_TTL;
3300 } else {
3301 cmsg->cmsg_level = NET_IPPROTO_IPV6;
3302 cmsg->cmsg_type = ZSOCK_IPV6_HOPLIMIT;
3303 }
3304
3305 *(int *)NET_CMSG_DATA(cmsg) = send_hop_limit;
3306
3307 comm_sendmsg_recvmsg_hop_limit(client_sock,
3308 client_addr,
3309 client_addr_len,
3310 &msg,
3311 server_sock,
3312 server_addr,
3313 server_addr_len,
3314 &server_msg,
3315 &cmsgbuf.buf,
3316 sizeof(cmsgbuf.buf),
3317 true);
3318
3319 for (prevcmsg = NULL, cmsg = NET_CMSG_FIRSTHDR(&server_msg);
3320 cmsg != NULL && prevcmsg != cmsg;
3321 prevcmsg = cmsg, cmsg = NET_CMSG_NXTHDR(&server_msg, cmsg)) {
3322 if (client_addr->sa_family == NET_AF_INET) {
3323 if (cmsg->cmsg_level == NET_IPPROTO_IP &&
3324 cmsg->cmsg_type == ZSOCK_IP_TTL) {
3325 recv_hop_limit = *(int *)NET_CMSG_DATA(cmsg);
3326 break;
3327 }
3328 } else {
3329 if (cmsg->cmsg_level == NET_IPPROTO_IPV6 &&
3330 cmsg->cmsg_type == ZSOCK_IPV6_HOPLIMIT) {
3331 recv_hop_limit = *(int *)NET_CMSG_DATA(cmsg);
3332 break;
3333 }
3334 }
3335 }
3336
3337 /* As we have not set the socket option, the hop_limit should not be set */
3338 zassert_equal(recv_hop_limit, 0, "Hop limit set!");
3339
3340 opt = 1;
3341 optlen = sizeof(opt);
3342 if (server_addr->sa_family == NET_AF_INET) {
3343 rv = zsock_setsockopt(server_sock, NET_IPPROTO_IP,
3344 ZSOCK_IP_RECVTTL, &opt, optlen);
3345 } else {
3346 rv = zsock_setsockopt(server_sock, NET_IPPROTO_IPV6,
3347 ZSOCK_IPV6_RECVHOPLIMIT, &opt, optlen);
3348 }
3349 zassert_equal(rv, 0, "setsockopt failed (%d)", -errno);
3350
3351 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
3352
3353 memset(&msg, 0, sizeof(msg));
3354 msg.msg_name = server_addr;
3355 msg.msg_namelen = server_addr_len;
3356 msg.msg_iov = io_vector;
3357 msg.msg_iovlen = 1;
3358 msg.msg_control = &cmsgbuf.buf;
3359 msg.msg_controllen = sizeof(cmsgbuf.buf);
3360
3361 cmsg = NET_CMSG_FIRSTHDR(&msg);
3362 cmsg->cmsg_len = NET_CMSG_LEN(sizeof(int));
3363 if (client_addr->sa_family == NET_AF_INET) {
3364 cmsg->cmsg_level = NET_IPPROTO_IP;
3365 cmsg->cmsg_type = ZSOCK_IP_TTL;
3366 } else {
3367 cmsg->cmsg_level = NET_IPPROTO_IPV6;
3368 cmsg->cmsg_type = ZSOCK_IPV6_HOPLIMIT;
3369 }
3370
3371 *(int *)NET_CMSG_DATA(cmsg) = send_hop_limit;
3372
3373 comm_sendmsg_recvmsg_hop_limit(client_sock,
3374 client_addr,
3375 client_addr_len,
3376 &msg,
3377 server_sock,
3378 server_addr,
3379 server_addr_len,
3380 &server_msg,
3381 &cmsgbuf.buf,
3382 sizeof(cmsgbuf.buf),
3383 true);
3384
3385 for (prevcmsg = NULL, cmsg = NET_CMSG_FIRSTHDR(&server_msg);
3386 cmsg != NULL && prevcmsg != cmsg;
3387 prevcmsg = cmsg, cmsg = NET_CMSG_NXTHDR(&server_msg, cmsg)) {
3388 if (client_addr->sa_family == NET_AF_INET) {
3389 if (cmsg->cmsg_level == NET_IPPROTO_IP &&
3390 cmsg->cmsg_type == ZSOCK_IP_TTL) {
3391 recv_hop_limit = *(int *)NET_CMSG_DATA(cmsg);
3392 break;
3393 }
3394 } else {
3395 if (cmsg->cmsg_level == NET_IPPROTO_IPV6 &&
3396 cmsg->cmsg_type == ZSOCK_IPV6_HOPLIMIT) {
3397 recv_hop_limit = *(int *)NET_CMSG_DATA(cmsg);
3398 break;
3399 }
3400 }
3401 }
3402
3403 zassert_equal(send_hop_limit, recv_hop_limit, "Hop limit not parsed correctly");
3404 }
3405
ZTEST_USER(net_socket_udp,test_recvmsg_ancillary_ipv4_hoplimit_data_user)3406 ZTEST_USER(net_socket_udp, test_recvmsg_ancillary_ipv4_hoplimit_data_user)
3407 {
3408 struct net_sockaddr_in client_addr;
3409 struct net_sockaddr_in server_addr;
3410 int client_sock;
3411 int server_sock;
3412
3413 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
3414 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
3415
3416 run_ancillary_recvmsg_hoplimit_test(client_sock,
3417 (struct net_sockaddr *)&client_addr,
3418 sizeof(client_addr),
3419 server_sock,
3420 (struct net_sockaddr *)&server_addr,
3421 sizeof(server_addr));
3422 }
3423
ZTEST_USER(net_socket_udp,test_recvmsg_ancillary_ipv6_hoplimit_data_user)3424 ZTEST_USER(net_socket_udp, test_recvmsg_ancillary_ipv6_hoplimit_data_user)
3425 {
3426 struct net_sockaddr_in6 client_addr;
3427 struct net_sockaddr_in6 server_addr;
3428 int client_sock;
3429 int server_sock;
3430
3431 prepare_sock_udp_v6(MY_IPV6_ADDR, ANY_PORT, &client_sock, &client_addr);
3432 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock, &server_addr);
3433
3434 run_ancillary_recvmsg_hoplimit_test(client_sock,
3435 (struct net_sockaddr *)&client_addr,
3436 sizeof(client_addr),
3437 server_sock,
3438 (struct net_sockaddr *)&server_addr,
3439 sizeof(server_addr));
3440 }
3441
sendto_recvfrom(int client_sock,struct net_sockaddr * client_addr,net_socklen_t client_addrlen,int server_sock,struct net_sockaddr * server_addr,net_socklen_t server_addrlen,bool expect_failure)3442 static void sendto_recvfrom(int client_sock,
3443 struct net_sockaddr *client_addr,
3444 net_socklen_t client_addrlen,
3445 int server_sock,
3446 struct net_sockaddr *server_addr,
3447 net_socklen_t server_addrlen,
3448 bool expect_failure)
3449 {
3450 ssize_t sent = 0;
3451 ssize_t recved = 0;
3452 struct net_sockaddr addr;
3453 net_socklen_t addrlen;
3454 struct net_sockaddr addr2;
3455 net_socklen_t addrlen2;
3456
3457 zassert_not_null(client_addr, "null client addr");
3458 zassert_not_null(server_addr, "null server addr");
3459
3460 /*
3461 * Test client -> server sending
3462 */
3463
3464 sent = zsock_sendto(client_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL),
3465 0, server_addr, server_addrlen);
3466 zassert_equal(sent, strlen(TEST_STR_SMALL), "sendto failed");
3467
3468 k_msleep(100);
3469
3470 /* Test normal recvfrom() */
3471 addrlen = sizeof(addr);
3472 clear_buf(rx_buf);
3473 recved = zsock_recvfrom(server_sock, rx_buf, sizeof(rx_buf),
3474 0, &addr, &addrlen);
3475 zassert_true(recved >= 0, "recvfrom fail");
3476 zassert_equal(recved, strlen(TEST_STR_SMALL),
3477 "unexpected received bytes");
3478 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
3479 zassert_equal(addrlen, client_addrlen, "unexpected addrlen");
3480
3481 /*
3482 * Test server -> client sending
3483 */
3484
3485 sent = zsock_sendto(server_sock, TEST_STR2, sizeof(TEST_STR2) - 1,
3486 0, &addr, addrlen);
3487 zassert_equal(sent, STRLEN(TEST_STR2), "sendto failed");
3488
3489 /* Test normal recvfrom() */
3490 addrlen2 = sizeof(addr);
3491 clear_buf(rx_buf);
3492 recved = zsock_recvfrom(client_sock, rx_buf, sizeof(rx_buf),
3493 expect_failure ? ZSOCK_MSG_DONTWAIT : 0,
3494 &addr2, &addrlen2);
3495 if (!expect_failure) {
3496 zassert_true(recved >= 0, "recvfrom fail");
3497 zassert_equal(recved, STRLEN(TEST_STR2),
3498 "unexpected received bytes");
3499 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR2), "wrong data");
3500 zassert_equal(addrlen2, server_addrlen, "unexpected addrlen");
3501 } else {
3502 /* We should not receive anything as the socket is shutdown for
3503 * receiving.
3504 */
3505 zassert_equal(recved, -1, "recvfrom should fail (got %d)", recved);
3506 }
3507 }
3508
ZTEST_USER(net_socket_udp,test_udp_shutdown_recv)3509 ZTEST_USER(net_socket_udp, test_udp_shutdown_recv)
3510 {
3511 int rv;
3512 int client_sock;
3513 int server_sock;
3514 struct net_sockaddr_in client_addr;
3515 struct net_sockaddr_in server_addr;
3516
3517 prepare_sock_udp_v4(MY_IPV4_ADDR, ANY_PORT, &client_sock, &client_addr);
3518 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock, &server_addr);
3519
3520 rv = zsock_bind(server_sock,
3521 (struct net_sockaddr *)&server_addr,
3522 sizeof(server_addr));
3523 zassert_equal(rv, 0, "bind failed");
3524
3525 sendto_recvfrom(client_sock,
3526 (struct net_sockaddr *)&client_addr,
3527 sizeof(client_addr),
3528 server_sock,
3529 (struct net_sockaddr *)&server_addr,
3530 sizeof(server_addr),
3531 false);
3532
3533 /* Shutdown UDP socket for receiving and verify that we do not get any data. */
3534 rv = zsock_shutdown(client_sock, ZSOCK_SHUT_RD);
3535 zassert_equal(rv, 0, "shutdown failed (%d)", -errno);
3536
3537 sendto_recvfrom(client_sock,
3538 (struct net_sockaddr *)&client_addr,
3539 sizeof(client_addr),
3540 server_sock,
3541 (struct net_sockaddr *)&server_addr,
3542 sizeof(server_addr),
3543 true);
3544
3545 rv = zsock_close(client_sock);
3546 zassert_equal(rv, 0, "close failed");
3547 rv = zsock_close(server_sock);
3548 zassert_equal(rv, 0, "close failed");
3549 }
3550
3551 enum ipv4_mapped_to_ipv6_send_mode {
3552 IPV4_MAPPED_TO_IPV6_SENDTO,
3553 IPV4_MAPPED_TO_IPV6_SENDMSG,
3554 };
3555
test_ipv4_mapped_to_ipv6_send_common(enum ipv4_mapped_to_ipv6_send_mode test_mode)3556 void test_ipv4_mapped_to_ipv6_send_common(enum ipv4_mapped_to_ipv6_send_mode test_mode)
3557 {
3558 int off = 0;
3559 int ret;
3560 int sock_s, sock_c;
3561 net_socklen_t addrlen;
3562 struct net_sockaddr_in addr_c4 = { 0 };
3563 struct net_sockaddr_in addr_s4 = { 0 };
3564 struct net_sockaddr_in6 addr_s6 = { 0 };
3565 struct net_sockaddr_in6 addr_recv = { 0 };
3566 struct net_in6_addr mapped_address = { 0 };
3567
3568 /* Create IPv4 client socket */
3569 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &sock_c, &addr_c4);
3570 /* Create IPv6 server socket */
3571 prepare_sock_udp_v6(ANY_IPV6_ADDR, SERVER_PORT, &sock_s, &addr_s6);
3572
3573 /* Prepare server's IPv4 address and expected mapped address */
3574 addr_s4.sin_family = NET_AF_INET;
3575 addr_s4.sin_port = net_htons(SERVER_PORT);
3576 ret = zsock_inet_pton(NET_AF_INET, MY_IPV4_ADDR, &addr_s4.sin_addr);
3577 zassert_equal(ret, 1, "inet_pton failed");
3578
3579 ret = zsock_inet_pton(NET_AF_INET6, MY_IPV4_MAPPED_ADDR, &mapped_address);
3580 zassert_equal(ret, 1, "inet_pton failed");
3581
3582 /* Bind the client socket to ensure we check the correct address */
3583 ret = zsock_bind(sock_c, (struct net_sockaddr *)&addr_c4, sizeof(addr_c4));
3584 zassert_ok(ret, "bind failed, %d", errno);
3585
3586 /* Turn off IPV6_V6ONLY on the server socket, so the socket becomes
3587 * dual-stack.
3588 */
3589 ret = zsock_setsockopt(sock_s, NET_IPPROTO_IPV6, ZSOCK_IPV6_V6ONLY, &off, sizeof(off));
3590 zassert_ok(ret, "setsockopt failed, %d", errno);
3591
3592 /* And bind it to ANY address */
3593 ret = zsock_bind(sock_s, (struct net_sockaddr *)&addr_s6, sizeof(addr_s6));
3594 zassert_ok(ret, "bind failed, %d", errno);
3595
3596 /* Send datagram from IPv4 client socket to dual-stack server */
3597 ret = zsock_sendto(sock_c, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
3598 (struct net_sockaddr *)&addr_s4, sizeof(addr_s4));
3599 zexpect_equal(ret, sizeof(TEST_STR_SMALL) - 1,
3600 "invalid send len (was %d expected %d) (%d)",
3601 ret, sizeof(TEST_STR_SMALL) - 1, errno);
3602
3603 /* Give the packet a chance to go through the net stack */
3604 k_msleep(10);
3605
3606 /* Server should get the datagram, with IPv4-to-IPv6 mapped address */
3607 addrlen = sizeof(addr_recv);
3608 clear_buf(rx_buf);
3609 ret = zsock_recvfrom(sock_s, rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT,
3610 (struct net_sockaddr *)&addr_recv, &addrlen);
3611 zassert_true(ret >= 0, "recvfrom fail (%d)", errno);
3612 zassert_equal(ret, sizeof(TEST_STR_SMALL) - 1, "unexpected received bytes");
3613 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
3614 zassert_equal(addrlen, sizeof(struct net_sockaddr_in6), "unexpected addrlen");
3615 zassert_equal(addr_recv.sin6_family, NET_AF_INET6,
3616 "IPv4-to-IPv6 mapped address should be NET_AF_INET6");
3617 zassert_equal(addr_recv.sin6_port, net_htons(CLIENT_PORT), "invalid port");
3618 zassert_mem_equal(&addr_recv.sin6_addr, &mapped_address,
3619 sizeof(mapped_address), "invalid mapped address");
3620
3621 /* Echo data back */
3622 if (test_mode == IPV4_MAPPED_TO_IPV6_SENDTO) {
3623 ret = zsock_sendto(sock_s, TEST_STR_SMALL, sizeof(TEST_STR_SMALL) - 1, 0,
3624 (struct net_sockaddr *)&addr_recv, addrlen);
3625 zexpect_equal(ret, sizeof(TEST_STR_SMALL) - 1,
3626 "invalid send len (was %d expected %d) (%d)",
3627 ret, sizeof(TEST_STR_SMALL) - 1, errno);
3628 } else if (test_mode == IPV4_MAPPED_TO_IPV6_SENDMSG) {
3629 struct net_msghdr msg = { 0 };
3630 struct net_iovec io_vector[1] = { 0 };
3631
3632 io_vector[0].iov_base = TEST_STR_SMALL;
3633 io_vector[0].iov_len = strlen(TEST_STR_SMALL);
3634
3635 msg.msg_iov = io_vector;
3636 msg.msg_iovlen = 1;
3637 msg.msg_name = &addr_recv;
3638 msg.msg_namelen = addrlen;
3639
3640 ret = zsock_sendmsg(sock_s, &msg, 0);
3641 zexpect_equal(ret, sizeof(TEST_STR_SMALL) - 1,
3642 "invalid send len (was %d expected %d) (%d)",
3643 ret, sizeof(TEST_STR_SMALL) - 1, errno);
3644 } else {
3645 zassert_unreachable("invalid test mode");
3646 }
3647
3648 /* Give the packet a chance to go through the net stack */
3649 k_msleep(10);
3650
3651 /* Client should get the echoed datagram */
3652 clear_buf(rx_buf);
3653 ret = zsock_recv(sock_c, rx_buf, sizeof(rx_buf), ZSOCK_MSG_DONTWAIT);
3654 zassert_true(ret >= 0, "recvfrom fail (%d)", errno);
3655 zassert_equal(ret, sizeof(TEST_STR_SMALL) - 1, "unexpected received bytes");
3656 zassert_mem_equal(rx_buf, BUF_AND_SIZE(TEST_STR_SMALL), "wrong data");
3657
3658 ret = zsock_close(sock_c);
3659 zassert_ok(ret, "close failed, %d", errno);
3660 ret = zsock_close(sock_s);
3661 zassert_ok(ret, "close failed, %d", errno);
3662 }
3663
ZTEST(net_socket_udp,test_ipv4_mapped_to_ipv6_sendto)3664 ZTEST(net_socket_udp, test_ipv4_mapped_to_ipv6_sendto)
3665 {
3666 Z_TEST_SKIP_IFNDEF(CONFIG_NET_IPV4_MAPPING_TO_IPV6);
3667
3668 test_ipv4_mapped_to_ipv6_send_common(IPV4_MAPPED_TO_IPV6_SENDTO);
3669 }
3670
ZTEST(net_socket_udp,test_ipv4_mapped_to_ipv6_sendmsg)3671 ZTEST(net_socket_udp, test_ipv4_mapped_to_ipv6_sendmsg)
3672 {
3673 Z_TEST_SKIP_IFNDEF(CONFIG_NET_IPV4_MAPPING_TO_IPV6);
3674
3675 test_ipv4_mapped_to_ipv6_send_common(IPV4_MAPPED_TO_IPV6_SENDMSG);
3676 }
3677
test_rebinding_common(net_sa_family_t family)3678 static void test_rebinding_common(net_sa_family_t family)
3679 {
3680 int rv;
3681 int client_sock;
3682 int server_sock;
3683 struct net_sockaddr client_addr;
3684 struct net_sockaddr server_addr;
3685 net_socklen_t addrlen;
3686
3687 if (family == NET_AF_INET) {
3688 prepare_sock_udp_v4(MY_IPV4_ADDR, CLIENT_PORT, &client_sock,
3689 (struct net_sockaddr_in *)&client_addr);
3690 prepare_sock_udp_v4(MY_IPV4_ADDR, SERVER_PORT, &server_sock,
3691 (struct net_sockaddr_in *)&server_addr);
3692 addrlen = sizeof(struct net_sockaddr_in);
3693 } else {
3694 prepare_sock_udp_v6(MY_IPV6_ADDR, CLIENT_PORT, &client_sock,
3695 (struct net_sockaddr_in6 *)&client_addr);
3696 prepare_sock_udp_v6(MY_IPV6_ADDR, SERVER_PORT, &server_sock,
3697 (struct net_sockaddr_in6 *)&server_addr);
3698 addrlen = sizeof(struct net_sockaddr_in6);
3699 }
3700
3701 rv = zsock_bind(client_sock, &client_addr, addrlen);
3702 zassert_equal(rv, 0, "bind failed");
3703
3704 rv = zsock_bind(server_sock, &server_addr, addrlen);
3705 zassert_equal(rv, 0, "bind failed");
3706
3707 /* Initial datagram exchange */
3708 comm_sendto_recvfrom(client_sock, &client_addr, addrlen,
3709 server_sock, &server_addr, addrlen);
3710
3711 /* Rebind client socket */
3712 if (family == NET_AF_INET) {
3713 net_sin(&client_addr)->sin_port = net_htons(CLIENT_PORT + 1);
3714 } else {
3715 net_sin6(&client_addr)->sin6_port = net_htons(CLIENT_PORT + 1);
3716 }
3717 rv = zsock_bind(client_sock, &client_addr, addrlen);
3718 zassert_equal(rv, 0, "rebinding failed");
3719
3720 /* Datagram exchange with rebound client socket */
3721 comm_sendto_recvfrom(client_sock, &client_addr, addrlen,
3722 server_sock, &server_addr, addrlen);
3723
3724 /* Rebind server socket */
3725 if (family == NET_AF_INET) {
3726 net_sin(&server_addr)->sin_port = net_htons(SERVER_PORT + 1);
3727 } else {
3728 net_sin6(&server_addr)->sin6_port = net_htons(SERVER_PORT + 1);
3729 }
3730 rv = zsock_bind(server_sock, &server_addr, addrlen);
3731 zassert_equal(rv, 0, "rebinding failed");
3732
3733 /* Datagram exchange with rebound server socket */
3734 comm_sendto_recvfrom(client_sock, &client_addr, addrlen,
3735 server_sock, &server_addr, addrlen);
3736
3737 rv = zsock_close(client_sock);
3738 zassert_equal(rv, 0, "close failed");
3739 rv = zsock_close(server_sock);
3740 zassert_equal(rv, 0, "close failed");
3741 }
3742
ZTEST(net_socket_udp,test_v4_rebinding)3743 ZTEST(net_socket_udp, test_v4_rebinding)
3744 {
3745 test_rebinding_common(NET_AF_INET);
3746 }
3747
ZTEST(net_socket_udp,test_v6_rebinding)3748 ZTEST(net_socket_udp, test_v6_rebinding)
3749 {
3750 test_rebinding_common(NET_AF_INET6);
3751 }
3752
after(void * arg)3753 static void after(void *arg)
3754 {
3755 ARG_UNUSED(arg);
3756
3757 for (int i = 0; i < ZVFS_OPEN_SIZE; ++i) {
3758 (void)zsock_close(i);
3759 }
3760 }
3761
setup(void)3762 static void *setup(void)
3763 {
3764 struct net_if_addr *ifaddr;
3765 int ret;
3766
3767
3768 net_if_foreach(iface_cb, ð_iface);
3769 zassert_not_null(eth_iface, "No ethernet interface found");
3770
3771 net_if_down(eth_iface);
3772
3773 ifaddr = net_if_ipv6_addr_add(eth_iface, &my_addr1,
3774 NET_ADDR_MANUAL, 0);
3775 if (!ifaddr) {
3776 DBG("Cannot add IPv6 address %s\n",
3777 net_sprint_ipv6_addr(&my_addr1));
3778 zassert_not_null(ifaddr, "addr1");
3779 }
3780
3781 ifaddr = net_if_ipv4_addr_add(eth_iface, &my_addr2,
3782 NET_ADDR_MANUAL, 0);
3783 if (!ifaddr) {
3784 DBG("Cannot add IPv4 address %s\n",
3785 net_sprint_ipv4_addr(&my_addr2));
3786 zassert_not_null(ifaddr, "addr2");
3787 }
3788
3789 net_if_up(eth_iface);
3790
3791 (void)memset(&udp_server_addr, 0, sizeof(udp_server_addr));
3792 udp_server_addr.sin6_family = NET_AF_INET6;
3793 udp_server_addr.sin6_port = net_htons(1234);
3794 ret = zsock_inet_pton(NET_AF_INET6, PEER_IPV6_ADDR_ETH, &udp_server_addr.sin6_addr);
3795 zassert_equal(ret, 1, "inet_pton failed");
3796
3797 /* In order to avoid neighbor discovery, populate neighbor cache */
3798 net_ipv6_nbr_add(eth_iface, &udp_server_addr.sin6_addr, &server_link_addr,
3799 true, NET_IPV6_NBR_STATE_REACHABLE);
3800
3801 (void)sys_sem_init(&wait_data, 0, 1);
3802
3803 return NULL;
3804 }
3805
3806 ZTEST_SUITE(net_socket_udp, NULL, setup, NULL, after, NULL);
3807
