1 /*
2 * Copyright (c) 2017 Linaro Limited
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <zephyr/logging/log.h>
8 LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
9
10 #include <zephyr/ztest_assert.h>
11 #include <zephyr/posix/fcntl.h>
12 #include <zephyr/net/net_context.h>
13 #include <zephyr/net/socket.h>
14 #include <zephyr/net/loopback.h>
15
16 #include "../../socket_helpers.h"
17
18 #define TEST_STR_SMALL "test"
19
20 #define TEST_STR_LONG \
21 "The Zephyr Project, a Linux Foundation hosted Collaboration " \
22 "Project, is an open source collaborative effort uniting leaders " \
23 "from across the industry to build a best-in-breed small, scalable, " \
24 "real-time operating system (RTOS) optimized for resource-" \
25 "constrained devices, across multiple architectures."
26
27 #define MY_IPV4_ADDR "127.0.0.1"
28 #define MY_IPV6_ADDR "::1"
29
30 #define ANY_PORT 0
31 #define SERVER_PORT 4242
32
33 #define MAX_CONNS 5
34
35 #define TCP_TEARDOWN_TIMEOUT K_SECONDS(3)
36 #define THREAD_SLEEP 50 /* ms */
37
test_bind(int sock,struct sockaddr * addr,socklen_t addrlen)38 static void test_bind(int sock, struct sockaddr *addr, socklen_t addrlen)
39 {
40 zassert_equal(zsock_bind(sock, addr, addrlen),
41 0,
42 "bind failed with error %d", errno);
43 }
44
test_listen(int sock)45 static void test_listen(int sock)
46 {
47 zassert_equal(zsock_listen(sock, MAX_CONNS),
48 0,
49 "listen failed with error %d", errno);
50 }
51
test_connect(int sock,struct sockaddr * addr,socklen_t addrlen)52 static void test_connect(int sock, struct sockaddr *addr, socklen_t addrlen)
53 {
54 zassert_equal(zsock_connect(sock, addr, addrlen),
55 0,
56 "connect failed with error %d", errno);
57
58 if (IS_ENABLED(CONFIG_NET_TC_THREAD_PREEMPTIVE)) {
59 /* Let the connection proceed */
60 k_msleep(THREAD_SLEEP);
61 }
62 }
63
test_send(int sock,const void * buf,size_t len,int flags)64 static void test_send(int sock, const void *buf, size_t len, int flags)
65 {
66 zassert_equal(zsock_send(sock, buf, len, flags),
67 len,
68 "send failed");
69 }
70
test_sendto(int sock,const void * buf,size_t len,int flags,const struct sockaddr * addr,socklen_t addrlen)71 static void test_sendto(int sock, const void *buf, size_t len, int flags,
72 const struct sockaddr *addr, socklen_t addrlen)
73 {
74 zassert_equal(zsock_sendto(sock, buf, len, flags, addr, addrlen),
75 len,
76 "send failed");
77 }
78
test_accept(int sock,int * new_sock,struct sockaddr * addr,socklen_t * addrlen)79 static void test_accept(int sock, int *new_sock, struct sockaddr *addr,
80 socklen_t *addrlen)
81 {
82 zassert_not_null(new_sock, "null newsock");
83
84 *new_sock = zsock_accept(sock, addr, addrlen);
85 zassert_true(*new_sock >= 0, "accept failed");
86 }
87
test_accept_timeout(int sock,int * new_sock,struct sockaddr * addr,socklen_t * addrlen)88 static void test_accept_timeout(int sock, int *new_sock, struct sockaddr *addr,
89 socklen_t *addrlen)
90 {
91 zassert_not_null(new_sock, "null newsock");
92
93 *new_sock = zsock_accept(sock, addr, addrlen);
94 zassert_equal(*new_sock, -1, "accept succeed");
95 zassert_equal(errno, EAGAIN, "");
96 }
97
test_fcntl(int sock,int cmd,int val)98 static void test_fcntl(int sock, int cmd, int val)
99 {
100 zassert_equal(zsock_fcntl(sock, cmd, val), 0, "fcntl failed");
101 }
102
test_recv(int sock,int flags)103 static void test_recv(int sock, int flags)
104 {
105 ssize_t recved = 0;
106 char rx_buf[30] = {0};
107
108 recved = zsock_recv(sock, rx_buf, sizeof(rx_buf), flags);
109 zassert_equal(recved,
110 strlen(TEST_STR_SMALL),
111 "unexpected received bytes");
112 zassert_equal(strncmp(rx_buf, TEST_STR_SMALL, strlen(TEST_STR_SMALL)),
113 0,
114 "unexpected data");
115 }
116
test_recvfrom(int sock,int flags,struct sockaddr * addr,socklen_t * addrlen)117 static void test_recvfrom(int sock,
118 int flags,
119 struct sockaddr *addr,
120 socklen_t *addrlen)
121 {
122 ssize_t recved = 0;
123 char rx_buf[30] = {0};
124
125 recved = zsock_recvfrom(sock, rx_buf, sizeof(rx_buf), flags, addr, addrlen);
126 zassert_equal(recved,
127 strlen(TEST_STR_SMALL),
128 "unexpected received bytes");
129 zassert_equal(strncmp(rx_buf, TEST_STR_SMALL, strlen(TEST_STR_SMALL)),
130 0,
131 "unexpected data");
132 }
133
test_recvmsg(int sock,struct msghdr * msg,int flags,size_t expected,int line)134 static void test_recvmsg(int sock,
135 struct msghdr *msg,
136 int flags,
137 size_t expected,
138 int line)
139 {
140 ssize_t recved;
141
142 recved = zsock_recvmsg(sock, msg, flags);
143
144 zassert_equal(recved, expected,
145 "line %d, unexpected received bytes (%d vs %d)",
146 line, recved, expected);
147 }
148
test_shutdown(int sock,int how)149 static void test_shutdown(int sock, int how)
150 {
151 zassert_equal(zsock_shutdown(sock, how),
152 0,
153 "shutdown failed");
154 }
155
test_close(int sock)156 static void test_close(int sock)
157 {
158 zassert_equal(zsock_close(sock),
159 0,
160 "close failed");
161 }
162
163 /* Test that EOF handling works correctly. Should be called with socket
164 * whose peer socket was closed.
165 */
test_eof(int sock)166 static void test_eof(int sock)
167 {
168 char rx_buf[1];
169 ssize_t recved;
170
171 /* Test that EOF properly detected. */
172 recved = zsock_recv(sock, rx_buf, sizeof(rx_buf), 0);
173 zassert_equal(recved, 0, "");
174
175 /* Calling again should be OK. */
176 recved = zsock_recv(sock, rx_buf, sizeof(rx_buf), 0);
177 zassert_equal(recved, 0, "");
178
179 /* Calling when TCP connection is fully torn down should be still OK. */
180 k_sleep(TCP_TEARDOWN_TIMEOUT);
181 recved = zsock_recv(sock, rx_buf, sizeof(rx_buf), 0);
182 zassert_equal(recved, 0, "");
183 }
184
calc_net_context(struct net_context * context,void * user_data)185 static void calc_net_context(struct net_context *context, void *user_data)
186 {
187 int *count = user_data;
188
189 (*count)++;
190 }
191
192 /* Wait until the number of TCP contexts reaches a certain level
193 * exp_num_contexts : The number of contexts to wait for
194 * timeout : The time to wait for
195 */
wait_for_n_tcp_contexts(int exp_num_contexts,k_timeout_t timeout)196 int wait_for_n_tcp_contexts(int exp_num_contexts, k_timeout_t timeout)
197 {
198 uint32_t start_time = k_uptime_get_32();
199 uint32_t time_diff;
200 int context_count = 0;
201
202 /* After the client socket closing, the context count should be 1 less */
203 net_context_foreach(calc_net_context, &context_count);
204
205 time_diff = k_uptime_get_32() - start_time;
206
207 /* Eventually the client socket should be cleaned up */
208 while (context_count != exp_num_contexts) {
209 context_count = 0;
210 net_context_foreach(calc_net_context, &context_count);
211 k_sleep(K_MSEC(50));
212 time_diff = k_uptime_get_32() - start_time;
213
214 if (K_MSEC(time_diff).ticks > timeout.ticks) {
215 return -ETIMEDOUT;
216 }
217 }
218
219 return 0;
220 }
221
test_context_cleanup(void)222 static void test_context_cleanup(void)
223 {
224 zassert_equal(wait_for_n_tcp_contexts(0, TCP_TEARDOWN_TIMEOUT),
225 0,
226 "Not all TCP contexts properly cleaned up");
227 }
228
229
ZTEST_USER(net_socket_tcp,test_v4_send_recv)230 ZTEST_USER(net_socket_tcp, test_v4_send_recv)
231 {
232 /* Test if send() and recv() work on a ipv4 stream socket. */
233 int c_sock;
234 int s_sock;
235 int new_sock;
236 struct sockaddr_in c_saddr;
237 struct sockaddr_in s_saddr;
238 struct sockaddr addr;
239 socklen_t addrlen = sizeof(addr);
240
241 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
242 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
243
244 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
245 test_listen(s_sock);
246
247 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
248 test_send(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0);
249
250 test_accept(s_sock, &new_sock, &addr, &addrlen);
251 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
252
253 test_recv(new_sock, ZSOCK_MSG_PEEK);
254 test_recv(new_sock, 0);
255
256 test_close(c_sock);
257 test_eof(new_sock);
258
259 test_close(new_sock);
260 test_close(s_sock);
261
262 k_sleep(TCP_TEARDOWN_TIMEOUT);
263 }
264
ZTEST_USER(net_socket_tcp,test_v6_send_recv)265 ZTEST_USER(net_socket_tcp, test_v6_send_recv)
266 {
267 /* Test if send() and recv() work on a ipv6 stream socket. */
268 int c_sock;
269 int s_sock;
270 int new_sock;
271 struct sockaddr_in6 c_saddr;
272 struct sockaddr_in6 s_saddr;
273 struct sockaddr addr;
274 socklen_t addrlen = sizeof(addr);
275
276 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
277 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
278
279 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
280 test_listen(s_sock);
281
282 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
283 test_send(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0);
284
285 test_accept(s_sock, &new_sock, &addr, &addrlen);
286 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
287
288 test_recv(new_sock, ZSOCK_MSG_PEEK);
289 test_recv(new_sock, 0);
290
291 test_close(c_sock);
292 test_eof(new_sock);
293
294 test_close(new_sock);
295 test_close(s_sock);
296
297 k_sleep(TCP_TEARDOWN_TIMEOUT);
298 }
299
300 /* Test the stack behavior with a resonable sized block data, be sure to have multiple packets */
301 #define TEST_LARGE_TRANSFER_SIZE 60000
302 #define TEST_PRIME 811
303
304 #define TCP_SERVER_STACK_SIZE 2048
305
306 K_THREAD_STACK_DEFINE(tcp_server_stack_area, TCP_SERVER_STACK_SIZE);
307 struct k_thread tcp_server_thread_data;
308
309 /* A thread that receives, while the other part transmits */
tcp_server_block_thread(void * vps_sock,void * unused2,void * unused3)310 void tcp_server_block_thread(void *vps_sock, void *unused2, void *unused3)
311 {
312 int new_sock;
313 struct sockaddr addr;
314 int *ps_sock = (int *)vps_sock;
315 socklen_t addrlen = sizeof(addr);
316
317 test_accept(*ps_sock, &new_sock, &addr, &addrlen);
318 zassert_true(addrlen == sizeof(struct sockaddr_in)
319 || addrlen == sizeof(struct sockaddr_in6), "wrong addrlen");
320
321 /* Check the received data */
322 ssize_t recved = 0;
323 ssize_t total_received = 0;
324 int iteration = 0;
325 uint8_t buffer[256];
326
327 while (total_received < TEST_LARGE_TRANSFER_SIZE) {
328 /* Compute the remaining contents */
329 size_t chunk_size = sizeof(buffer);
330 size_t remain = TEST_LARGE_TRANSFER_SIZE - total_received;
331
332 if (chunk_size > remain) {
333 chunk_size = remain;
334 }
335
336 recved = zsock_recv(new_sock, buffer, chunk_size, 0);
337
338 zassert(recved > 0, "received bigger then 0",
339 "Error receiving bytes %i bytes, got %i on top of %i in iteration %i, errno %i",
340 chunk_size, recved, total_received, iteration, errno);
341
342 /* Validate the contents */
343 for (int i = 0; i < recved; i++) {
344 int total_idx = i + total_received;
345 uint8_t expValue = (total_idx * TEST_PRIME) & 0xff;
346
347 zassert_equal(buffer[i], expValue, "Unexpected data at %i", total_idx);
348 }
349
350 total_received += recved;
351 iteration++;
352 }
353
354 test_close(new_sock);
355 }
356
test_send_recv_large_common(int tcp_nodelay,int family)357 void test_send_recv_large_common(int tcp_nodelay, int family)
358 {
359 int rv;
360 int c_sock = 0;
361 int s_sock = 0;
362 struct sockaddr *c_saddr = NULL;
363 struct sockaddr *s_saddr = NULL;
364 size_t addrlen = 0;
365
366 struct sockaddr_in c_saddr_in;
367 struct sockaddr_in s_saddr_in;
368 struct sockaddr_in6 c_saddr_in6;
369 struct sockaddr_in6 s_saddr_in6;
370
371 if (family == AF_INET) {
372 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr_in);
373 c_saddr = (struct sockaddr *) &c_saddr_in;
374 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr_in);
375 s_saddr = (struct sockaddr *) &s_saddr_in;
376 addrlen = sizeof(s_saddr_in);
377 } else if (family == AF_INET6) {
378 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr_in6);
379 c_saddr = (struct sockaddr *) &c_saddr_in6;
380 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr_in6);
381 s_saddr = (struct sockaddr *) &s_saddr_in6;
382 addrlen = sizeof(s_saddr_in6);
383 } else {
384 zassert_unreachable();
385 }
386
387 test_bind(s_sock, s_saddr, addrlen);
388 test_listen(s_sock);
389
390 (void)k_thread_create(&tcp_server_thread_data, tcp_server_stack_area,
391 K_THREAD_STACK_SIZEOF(tcp_server_stack_area),
392 tcp_server_block_thread,
393 &s_sock, NULL, NULL,
394 k_thread_priority_get(k_current_get()), 0, K_NO_WAIT);
395
396 test_connect(c_sock, s_saddr, addrlen);
397
398 rv = zsock_setsockopt(c_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &tcp_nodelay, sizeof(int));
399 zassert_equal(rv, 0, "setsockopt failed (%d)", rv);
400
401 /* send piece by piece */
402 ssize_t total_send = 0;
403 int iteration = 0;
404 uint8_t buffer[256];
405
406 while (total_send < TEST_LARGE_TRANSFER_SIZE) {
407 /* Fill the buffer with a known pattern */
408 for (int i = 0; i < sizeof(buffer); i++) {
409 int total_idx = i + total_send;
410
411 buffer[i] = (total_idx * TEST_PRIME) & 0xff;
412 }
413
414 size_t chunk_size = sizeof(buffer);
415 size_t remain = TEST_LARGE_TRANSFER_SIZE - total_send;
416
417 if (chunk_size > remain) {
418 chunk_size = remain;
419 }
420
421 int send_bytes = zsock_send(c_sock, buffer, chunk_size, 0);
422
423 zassert(send_bytes > 0, "send_bytes bigger then 0",
424 "Error sending %i bytes on top of %i, got %i in iteration %i, errno %i",
425 chunk_size, total_send, send_bytes, iteration, errno);
426 total_send += send_bytes;
427 iteration++;
428 }
429
430 /* join the thread, to wait for the receiving part */
431 zassert_equal(k_thread_join(&tcp_server_thread_data, K_SECONDS(60)), 0,
432 "Not successfully wait for TCP thread to finish");
433
434 test_close(s_sock);
435 test_close(c_sock);
436
437 k_sleep(TCP_TEARDOWN_TIMEOUT);
438 }
439
440 /* Control the packet drop ratio at the loopback adapter 8 */
set_packet_loss_ratio(void)441 static void set_packet_loss_ratio(void)
442 {
443 /* drop one every 8 packets */
444 zassert_equal(loopback_set_packet_drop_ratio(0.125f), 0,
445 "Error setting packet drop rate");
446 }
447
restore_packet_loss_ratio(void)448 static void restore_packet_loss_ratio(void)
449 {
450 /* no packet dropping any more */
451 zassert_equal(loopback_set_packet_drop_ratio(0.0f), 0,
452 "Error setting packet drop rate");
453 }
454
ZTEST(net_socket_tcp,test_v4_send_recv_large_normal)455 ZTEST(net_socket_tcp, test_v4_send_recv_large_normal)
456 {
457 test_send_recv_large_common(0, AF_INET);
458 }
459
ZTEST(net_socket_tcp,test_v4_send_recv_large_packet_loss)460 ZTEST(net_socket_tcp, test_v4_send_recv_large_packet_loss)
461 {
462 set_packet_loss_ratio();
463 test_send_recv_large_common(0, AF_INET);
464 restore_packet_loss_ratio();
465 }
466
ZTEST(net_socket_tcp,test_v4_send_recv_large_no_delay)467 ZTEST(net_socket_tcp, test_v4_send_recv_large_no_delay)
468 {
469 set_packet_loss_ratio();
470 test_send_recv_large_common(1, AF_INET);
471 restore_packet_loss_ratio();
472 }
473
ZTEST(net_socket_tcp,test_v6_send_recv_large_normal)474 ZTEST(net_socket_tcp, test_v6_send_recv_large_normal)
475 {
476 test_send_recv_large_common(0, AF_INET6);
477 }
478
ZTEST(net_socket_tcp,test_v6_send_recv_large_packet_loss)479 ZTEST(net_socket_tcp, test_v6_send_recv_large_packet_loss)
480 {
481 set_packet_loss_ratio();
482 test_send_recv_large_common(0, AF_INET6);
483 restore_packet_loss_ratio();
484 }
485
ZTEST(net_socket_tcp,test_v6_send_recv_large_no_delay)486 ZTEST(net_socket_tcp, test_v6_send_recv_large_no_delay)
487 {
488 set_packet_loss_ratio();
489 test_send_recv_large_common(1, AF_INET6);
490 restore_packet_loss_ratio();
491 }
492
ZTEST(net_socket_tcp,test_v4_broken_link)493 ZTEST(net_socket_tcp, test_v4_broken_link)
494 {
495 /* Test if the data stops transmitting after the send returned with a timeout. */
496 int c_sock;
497 int s_sock;
498 int new_sock;
499 struct sockaddr_in c_saddr;
500 struct sockaddr_in s_saddr;
501 struct sockaddr addr;
502 socklen_t addrlen = sizeof(addr);
503
504 struct timeval optval = {
505 .tv_sec = 0,
506 .tv_usec = 500000,
507 };
508
509 struct net_stats before;
510 struct net_stats after;
511 uint32_t start_time, time_diff;
512 ssize_t recved;
513 int rv;
514 uint8_t rx_buf[10];
515
516 restore_packet_loss_ratio();
517
518 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
519 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
520
521 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
522 test_listen(s_sock);
523
524 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
525 test_send(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0);
526
527 test_accept(s_sock, &new_sock, &addr, &addrlen);
528 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
529
530 rv = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVTIMEO, &optval,
531 sizeof(optval));
532 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
533
534 test_recv(new_sock, ZSOCK_MSG_PEEK);
535 test_recv(new_sock, 0);
536
537 /* At this point break the interface */
538 zassert_equal(loopback_set_packet_drop_ratio(1.0f), 0,
539 "Error setting packet drop rate");
540
541 test_send(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0);
542
543 /* At this point break the interface */
544 start_time = k_uptime_get_32();
545
546 /* Test the loopback packet loss: message should never arrive */
547 recved = zsock_recv(new_sock, rx_buf, sizeof(rx_buf), 0);
548 time_diff = k_uptime_get_32() - start_time;
549
550 zassert_equal(recved, -1, "Unexpected return code");
551 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
552 zassert_true(time_diff >= 500, "Expected timeout after 500ms but "
553 "was %dms", time_diff);
554
555 /* Reading from client should indicate the socket has been closed */
556 recved = zsock_recv(c_sock, rx_buf, sizeof(rx_buf), 0);
557 zassert_equal(recved, -1, "Unexpected return code");
558 zassert_equal(errno, ETIMEDOUT, "Unexpected errno value: %d", errno);
559
560 /* At this point there should be no traffic any more, get the current counters */
561 net_mgmt(NET_REQUEST_STATS_GET_ALL, NULL, &before, sizeof(before));
562
563 k_sleep(K_MSEC(CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT));
564 k_sleep(K_MSEC(CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT));
565
566 net_mgmt(NET_REQUEST_STATS_GET_ALL, NULL, &after, sizeof(after));
567
568 zassert_equal(before.ipv4.sent, after.ipv4.sent, "Data sent afer connection timeout");
569
570 test_close(c_sock);
571 test_close(new_sock);
572 test_close(s_sock);
573
574 restore_packet_loss_ratio();
575
576 k_sleep(TCP_TEARDOWN_TIMEOUT);
577 }
578
ZTEST_USER(net_socket_tcp,test_v4_sendto_recvfrom)579 ZTEST_USER(net_socket_tcp, test_v4_sendto_recvfrom)
580 {
581 int c_sock;
582 int s_sock;
583 int new_sock;
584 struct sockaddr_in c_saddr;
585 struct sockaddr_in s_saddr;
586 struct sockaddr addr;
587 socklen_t addrlen = sizeof(addr);
588
589 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
590 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
591
592 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
593 test_listen(s_sock);
594
595 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
596 test_sendto(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0,
597 (struct sockaddr *)&s_saddr, sizeof(s_saddr));
598
599 test_accept(s_sock, &new_sock, &addr, &addrlen);
600 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
601
602 test_recvfrom(new_sock, ZSOCK_MSG_PEEK, &addr, &addrlen);
603 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
604
605 test_recvfrom(new_sock, 0, &addr, &addrlen);
606 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
607
608 test_close(new_sock);
609 test_close(s_sock);
610 test_close(c_sock);
611
612 k_sleep(TCP_TEARDOWN_TIMEOUT);
613 }
614
ZTEST_USER(net_socket_tcp,test_v6_sendto_recvfrom)615 ZTEST_USER(net_socket_tcp, test_v6_sendto_recvfrom)
616 {
617 int c_sock;
618 int s_sock;
619 int new_sock;
620 struct sockaddr_in6 c_saddr;
621 struct sockaddr_in6 s_saddr;
622 struct sockaddr addr;
623 socklen_t addrlen = sizeof(addr);
624
625 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
626
627 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
628
629 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
630 test_listen(s_sock);
631
632 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
633 test_sendto(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0,
634 (struct sockaddr *)&s_saddr, sizeof(s_saddr));
635
636 test_accept(s_sock, &new_sock, &addr, &addrlen);
637 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
638
639 test_recvfrom(new_sock, ZSOCK_MSG_PEEK, &addr, &addrlen);
640 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
641
642 test_recvfrom(new_sock, 0, &addr, &addrlen);
643 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
644
645 test_close(new_sock);
646 test_close(s_sock);
647 test_close(c_sock);
648
649 k_sleep(TCP_TEARDOWN_TIMEOUT);
650 }
651
ZTEST_USER(net_socket_tcp,test_v4_sendto_recvfrom_null_dest)652 ZTEST_USER(net_socket_tcp, test_v4_sendto_recvfrom_null_dest)
653 {
654 /* For a stream socket, sendto() should ignore NULL dest address */
655 int c_sock;
656 int s_sock;
657 int new_sock;
658 struct sockaddr_in c_saddr;
659 struct sockaddr_in s_saddr;
660 struct sockaddr addr;
661 socklen_t addrlen = sizeof(addr);
662
663 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
664 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
665
666 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
667 test_listen(s_sock);
668
669 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
670 test_sendto(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0,
671 (struct sockaddr *)&s_saddr, sizeof(s_saddr));
672
673 test_accept(s_sock, &new_sock, &addr, &addrlen);
674 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
675
676 test_recvfrom(new_sock, 0, NULL, NULL);
677
678 test_close(new_sock);
679 test_close(s_sock);
680 test_close(c_sock);
681
682 k_sleep(TCP_TEARDOWN_TIMEOUT);
683 }
684
ZTEST_USER(net_socket_tcp,test_v6_sendto_recvfrom_null_dest)685 ZTEST_USER(net_socket_tcp, test_v6_sendto_recvfrom_null_dest)
686 {
687 /* For a stream socket, sendto() should ignore NULL dest address */
688 int c_sock;
689 int s_sock;
690 int new_sock;
691 struct sockaddr_in6 c_saddr;
692 struct sockaddr_in6 s_saddr;
693 struct sockaddr addr;
694 socklen_t addrlen = sizeof(addr);
695
696 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
697 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
698
699 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
700 test_listen(s_sock);
701
702 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
703 test_sendto(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0,
704 (struct sockaddr *)&s_saddr, sizeof(s_saddr));
705
706 test_accept(s_sock, &new_sock, &addr, &addrlen);
707 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
708
709 test_recvfrom(new_sock, 0, NULL, NULL);
710
711 test_close(new_sock);
712 test_close(s_sock);
713 test_close(c_sock);
714
715 k_sleep(TCP_TEARDOWN_TIMEOUT);
716 }
717
ZTEST_USER(net_socket_tcp,test_v4_sendto_recvmsg)718 ZTEST_USER(net_socket_tcp, test_v4_sendto_recvmsg)
719 {
720 int c_sock;
721 int s_sock;
722 int new_sock;
723 struct sockaddr_in c_saddr;
724 struct sockaddr_in s_saddr;
725 struct sockaddr addr;
726 socklen_t addrlen = sizeof(addr);
727 #define MAX_BUF_LEN 64
728 #define SMALL_BUF_LEN (sizeof(TEST_STR_SMALL) - 1 - 2)
729 char buf[MAX_BUF_LEN];
730 char buf2[SMALL_BUF_LEN];
731 char buf3[MAX_BUF_LEN];
732 struct iovec io_vector[3];
733 struct msghdr msg;
734 int i, len;
735
736 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
737 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
738
739 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
740 test_listen(s_sock);
741
742 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
743 test_sendto(c_sock, TEST_STR_SMALL, strlen(TEST_STR_SMALL), 0,
744 (struct sockaddr *)&s_saddr, sizeof(s_saddr));
745
746 test_accept(s_sock, &new_sock, &addr, &addrlen);
747 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
748
749 /* Read data first in one chunk */
750 io_vector[0].iov_base = buf;
751 io_vector[0].iov_len = sizeof(buf);
752
753 memset(&msg, 0, sizeof(msg));
754 msg.msg_iov = io_vector;
755 msg.msg_iovlen = 1;
756 msg.msg_name = &addr;
757 msg.msg_namelen = addrlen;
758
759 len = strlen(TEST_STR_SMALL);
760 test_recvmsg(new_sock, &msg, ZSOCK_MSG_PEEK, len, __LINE__);
761 zassert_equal(msg.msg_iovlen, 1, "recvmsg should not modify msg_iovlen");
762 zassert_equal(msg.msg_iov[0].iov_len, sizeof(buf),
763 "recvmsg should not modify buffer length");
764 zassert_mem_equal(buf, TEST_STR_SMALL, len, "wrong data (%s)", buf);
765
766 /* Then in two chunks */
767 io_vector[0].iov_base = buf2;
768 io_vector[0].iov_len = sizeof(buf2);
769 io_vector[1].iov_base = buf;
770 io_vector[1].iov_len = sizeof(buf);
771
772 memset(&msg, 0, sizeof(msg));
773 msg.msg_iov = io_vector;
774 msg.msg_iovlen = 2;
775 msg.msg_name = &addr;
776 msg.msg_namelen = addrlen;
777
778 len = strlen(TEST_STR_SMALL);
779 test_recvmsg(new_sock, &msg, 0, len, __LINE__);
780 zassert_equal(msg.msg_iovlen, 2, "recvmsg should not modify msg_iovlen");
781 zassert_equal(msg.msg_iov[0].iov_len, sizeof(buf2),
782 "recvmsg should not modify buffer length");
783 zassert_equal(msg.msg_iov[1].iov_len, sizeof(buf),
784 "recvmsg should not modify buffer length");
785 zassert_mem_equal(msg.msg_iov[0].iov_base, TEST_STR_SMALL, msg.msg_iov[0].iov_len,
786 "wrong data in %s", "iov[0]");
787 len -= msg.msg_iov[0].iov_len;
788 zassert_mem_equal(msg.msg_iov[1].iov_base, &TEST_STR_SMALL[msg.msg_iov[0].iov_len],
789 len, "wrong data in %s", "iov[1]");
790
791 /* Send larger test buffer */
792 test_sendto(c_sock, TEST_STR_LONG, strlen(TEST_STR_LONG), 0,
793 (struct sockaddr *)&s_saddr, sizeof(s_saddr));
794
795 /* Verify that the data is truncated */
796 io_vector[0].iov_base = buf;
797 io_vector[0].iov_len = sizeof(buf);
798 io_vector[1].iov_base = buf2;
799 io_vector[1].iov_len = sizeof(buf2);
800 io_vector[2].iov_base = buf3;
801 io_vector[2].iov_len = sizeof(buf3);
802
803 memset(&msg, 0, sizeof(msg));
804 msg.msg_iov = io_vector;
805 msg.msg_iovlen = 3;
806 msg.msg_name = &addr;
807 msg.msg_namelen = addrlen;
808
809 for (i = 0, len = 0; i < msg.msg_iovlen; i++) {
810 len += msg.msg_iov[i].iov_len;
811 }
812
813 test_recvmsg(new_sock, &msg, 0, len, __LINE__);
814 zassert_equal(msg.msg_iovlen, 3, "recvmsg should not modify msg_iovlen");
815 zassert_equal(msg.msg_iov[0].iov_len, sizeof(buf),
816 "recvmsg should not modify buffer length");
817 zassert_equal(msg.msg_iov[1].iov_len, sizeof(buf2),
818 "recvmsg should not modify buffer length");
819 zassert_equal(msg.msg_iov[2].iov_len, sizeof(buf3),
820 "recvmsg should not modify buffer length");
821 zassert_mem_equal(msg.msg_iov[0].iov_base, TEST_STR_LONG, msg.msg_iov[0].iov_len,
822 "wrong data in %s", "iov[0]");
823 zassert_mem_equal(msg.msg_iov[1].iov_base, &TEST_STR_LONG[msg.msg_iov[0].iov_len],
824 msg.msg_iov[1].iov_len,
825 "wrong data in %s", "iov[1]");
826 zassert_mem_equal(msg.msg_iov[2].iov_base,
827 &TEST_STR_LONG[msg.msg_iov[0].iov_len + msg.msg_iov[1].iov_len],
828 msg.msg_iov[2].iov_len,
829 "wrong data in %s", "iov[2]");
830
831 test_close(new_sock);
832 test_close(s_sock);
833 test_close(c_sock);
834
835 k_sleep(TCP_TEARDOWN_TIMEOUT);
836 }
837
_test_recv_enotconn(int c_sock,int s_sock)838 void _test_recv_enotconn(int c_sock, int s_sock)
839 {
840 char rx_buf[1] = {0};
841 int res;
842
843 test_listen(s_sock);
844
845 /* Check "client" socket, just created. */
846 res = zsock_recv(c_sock, rx_buf, sizeof(rx_buf), 0);
847 zassert_equal(res, -1, "recv() on not connected sock didn't fail");
848 zassert_equal(errno, ENOTCONN, "recv() on not connected sock didn't "
849 "lead to ENOTCONN");
850
851 /* Check "server" socket, bound and listen()ed . */
852 res = zsock_recv(s_sock, rx_buf, sizeof(rx_buf), 0);
853 zassert_equal(res, -1, "recv() on not connected sock didn't fail");
854 zassert_equal(errno, ENOTCONN, "recv() on not connected sock didn't "
855 "lead to ENOTCONN");
856
857 test_close(s_sock);
858 test_close(c_sock);
859
860 k_sleep(TCP_TEARDOWN_TIMEOUT);
861 }
862
ZTEST_USER(net_socket_tcp,test_v4_recv_enotconn)863 ZTEST_USER(net_socket_tcp, test_v4_recv_enotconn)
864 {
865 /* For a stream socket, recv() without connect() or accept()
866 * should lead to ENOTCONN.
867 */
868 int c_sock, s_sock;
869 struct sockaddr_in c_saddr, s_saddr;
870
871 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
872 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
873
874 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
875
876 _test_recv_enotconn(c_sock, s_sock);
877 }
878
ZTEST_USER(net_socket_tcp,test_v6_recv_enotconn)879 ZTEST_USER(net_socket_tcp, test_v6_recv_enotconn)
880 {
881 /* For a stream socket, recv() without connect() or accept()
882 * should lead to ENOTCONN.
883 */
884 int c_sock, s_sock;
885 struct sockaddr_in6 c_saddr, s_saddr;
886
887 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
888 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
889
890 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
891
892 _test_recv_enotconn(c_sock, s_sock);
893 }
894
ZTEST_USER(net_socket_tcp,test_shutdown_rd_synchronous)895 ZTEST_USER(net_socket_tcp, test_shutdown_rd_synchronous)
896 {
897 /* recv() after shutdown(..., ZSOCK_SHUT_RD) should return 0 (EOF).
898 */
899 int c_sock;
900 int s_sock;
901 int new_sock;
902 struct sockaddr_in6 c_saddr, s_saddr;
903 struct sockaddr addr;
904 socklen_t addrlen = sizeof(addr);
905
906 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
907 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
908
909 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
910 test_listen(s_sock);
911
912 /* Connect and accept that connection */
913 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
914
915 test_accept(s_sock, &new_sock, &addr, &addrlen);
916
917 /* Shutdown reception */
918 test_shutdown(c_sock, ZSOCK_SHUT_RD);
919
920 /* EOF should be notified by recv() */
921 test_eof(c_sock);
922
923 test_close(new_sock);
924 test_close(s_sock);
925 test_close(c_sock);
926
927 k_sleep(TCP_TEARDOWN_TIMEOUT);
928 }
929
930 struct shutdown_data {
931 struct k_work_delayable work;
932 int fd;
933 int how;
934 };
935
shutdown_work(struct k_work * work)936 static void shutdown_work(struct k_work *work)
937 {
938 struct k_work_delayable *dwork = k_work_delayable_from_work(work);
939 struct shutdown_data *data = CONTAINER_OF(dwork, struct shutdown_data,
940 work);
941
942 zsock_shutdown(data->fd, data->how);
943 }
944
ZTEST(net_socket_tcp,test_shutdown_rd_while_recv)945 ZTEST(net_socket_tcp, test_shutdown_rd_while_recv)
946 {
947 /* Blocking recv() should return EOF after shutdown(..., ZSOCK_SHUT_RD) is
948 * called from another thread.
949 */
950 int c_sock;
951 int s_sock;
952 int new_sock;
953 struct sockaddr_in6 c_saddr, s_saddr;
954 struct sockaddr addr;
955 socklen_t addrlen = sizeof(addr);
956 struct shutdown_data shutdown_work_data;
957
958 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
959 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
960
961 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
962 test_listen(s_sock);
963
964 /* Connect and accept that connection */
965 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
966
967 test_accept(s_sock, &new_sock, &addr, &addrlen);
968
969 /* Schedule reception shutdown from workqueue */
970 k_work_init_delayable(&shutdown_work_data.work, shutdown_work);
971 shutdown_work_data.fd = c_sock;
972 shutdown_work_data.how = ZSOCK_SHUT_RD;
973 k_work_schedule(&shutdown_work_data.work, K_MSEC(10));
974
975 /* Start blocking recv(), which should be unblocked by shutdown() from
976 * another thread and return EOF (0).
977 */
978 test_eof(c_sock);
979
980 test_close(new_sock);
981 test_close(s_sock);
982 test_close(c_sock);
983
984 test_context_cleanup();
985 }
986
ZTEST(net_socket_tcp,test_open_close_immediately)987 ZTEST(net_socket_tcp, test_open_close_immediately)
988 {
989 /* Test if socket closing works if done immediately after
990 * receiving SYN.
991 */
992 int count_before = 0, count_after = 0;
993 struct sockaddr_in c_saddr;
994 struct sockaddr_in s_saddr;
995 int c_sock;
996 int s_sock;
997
998 test_context_cleanup();
999
1000 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1001 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1002
1003 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1004 test_listen(s_sock);
1005
1006 /* We should have two contexts open now */
1007 net_context_foreach(calc_net_context, &count_before);
1008
1009 /* Try to connect to a port that is not accepting connections.
1010 * The end result should be that we do not leak net_context.
1011 */
1012 s_saddr.sin_port = htons(SERVER_PORT + 1);
1013
1014 zassert_not_equal(zsock_connect(c_sock, (struct sockaddr *)&s_saddr,
1015 sizeof(s_saddr)),
1016 0, "connect succeed");
1017
1018 test_close(c_sock);
1019
1020 /* Allow for the close communication to finish,
1021 * this makes the test success, no longer scheduling dependent
1022 */
1023 k_sleep(K_MSEC(CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT / 2));
1024
1025 /* After the client socket closing, the context count should be 1 */
1026 net_context_foreach(calc_net_context, &count_after);
1027
1028 test_close(s_sock);
1029
1030 /* Although closing a server socket does not require communication,
1031 * wait a little to make the test robust to scheduling order
1032 */
1033 k_sleep(K_MSEC(CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT / 2));
1034
1035 zassert_equal(count_before - 1, count_after,
1036 "net_context still in use (before %d vs after %d)",
1037 count_before - 1, count_after);
1038
1039 /* No need to wait here, as the test success depends on the socket being closed */
1040 test_context_cleanup();
1041 }
1042
ZTEST(net_socket_tcp,test_connect_timeout)1043 ZTEST(net_socket_tcp, test_connect_timeout)
1044 {
1045 /* Test if socket connect fails when there is not communication
1046 * possible.
1047 */
1048 int count_after = 0;
1049 struct sockaddr_in c_saddr;
1050 struct sockaddr_in s_saddr;
1051 int c_sock;
1052 int rv;
1053
1054 restore_packet_loss_ratio();
1055
1056 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1057
1058 s_saddr.sin_family = AF_INET;
1059 s_saddr.sin_port = htons(SERVER_PORT);
1060 rv = zsock_inet_pton(AF_INET, MY_IPV4_ADDR, &s_saddr.sin_addr);
1061 zassert_equal(rv, 1, "inet_pton failed");
1062
1063 loopback_set_packet_drop_ratio(1.0f);
1064
1065 zassert_equal(zsock_connect(c_sock, (struct sockaddr *)&s_saddr,
1066 sizeof(s_saddr)),
1067 -1, "connect succeed");
1068
1069 zassert_equal(errno, ETIMEDOUT,
1070 "connect should be timed out, got %i", errno);
1071
1072 test_close(c_sock);
1073
1074 /* Sleep here in order to allow other part of the system to run and
1075 * update itself.
1076 */
1077 k_sleep(K_MSEC(10));
1078
1079 /* After the client socket closing, the context count should be 0 */
1080 net_context_foreach(calc_net_context, &count_after);
1081
1082 zassert_equal(count_after, 0,
1083 "net_context %d still in use", count_after);
1084
1085 restore_packet_loss_ratio();
1086 }
1087
1088 #define ASYNC_POLL_TIMEOUT 2000
1089 #define POLL_FDS_NUM 1
1090
1091
ZTEST(net_socket_tcp,test_async_connect_timeout)1092 ZTEST(net_socket_tcp, test_async_connect_timeout)
1093 {
1094 /* Test if asynchronous socket connect fails when there is no communication
1095 * possible.
1096 */
1097 struct sockaddr_in c_saddr;
1098 struct sockaddr_in s_saddr;
1099 int c_sock;
1100 int rv;
1101 struct zsock_pollfd poll_fds[POLL_FDS_NUM];
1102
1103 loopback_set_packet_drop_ratio(1.0f);
1104
1105 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1106 test_fcntl(c_sock, F_SETFL, O_NONBLOCK);
1107 s_saddr.sin_family = AF_INET;
1108 s_saddr.sin_port = htons(SERVER_PORT);
1109 rv = zsock_inet_pton(AF_INET, MY_IPV4_ADDR, &s_saddr.sin_addr);
1110 zassert_equal(rv, 1, "inet_pton failed");
1111
1112 rv = zsock_connect(c_sock, (struct sockaddr *)&s_saddr,
1113 sizeof(s_saddr));
1114 zassert_equal(rv, -1, "connect should not succeed");
1115 zassert_equal(errno, EINPROGRESS,
1116 "connect should be in progress, got %i", errno);
1117
1118 poll_fds[0].fd = c_sock;
1119 poll_fds[0].events = ZSOCK_POLLOUT;
1120 int poll_rc = zsock_poll(poll_fds, POLL_FDS_NUM, ASYNC_POLL_TIMEOUT);
1121
1122 zassert_equal(poll_rc, 1, "poll should return 1, got %i", poll_rc);
1123 zassert_equal(poll_fds[0].revents, ZSOCK_POLLERR,
1124 "poll should set error event");
1125
1126 test_close(c_sock);
1127
1128 test_context_cleanup();
1129
1130 restore_packet_loss_ratio();
1131 }
1132
ZTEST(net_socket_tcp,test_async_connect)1133 ZTEST(net_socket_tcp, test_async_connect)
1134 {
1135 int c_sock;
1136 int s_sock;
1137 int new_sock;
1138 struct sockaddr_in c_saddr;
1139 struct sockaddr_in s_saddr;
1140 struct sockaddr addr;
1141 socklen_t addrlen = sizeof(addr);
1142 struct zsock_pollfd poll_fds[1];
1143 int poll_rc;
1144
1145 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1146 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1147 test_fcntl(c_sock, F_SETFL, O_NONBLOCK);
1148
1149 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1150 test_listen(s_sock);
1151
1152 zassert_equal(zsock_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr)),
1153 -1,
1154 "connect shouldn't complete right away");
1155
1156 zassert_equal(errno, EINPROGRESS,
1157 "connect should be in progress, got %i", errno);
1158
1159 poll_fds[0].fd = c_sock;
1160 poll_fds[0].events = ZSOCK_POLLOUT;
1161 poll_rc = zsock_poll(poll_fds, 1, ASYNC_POLL_TIMEOUT);
1162 zassert_equal(poll_rc, 1, "poll should return 1, got %i", poll_rc);
1163 zassert_equal(poll_fds[0].revents, ZSOCK_POLLOUT,
1164 "poll should set POLLOUT");
1165
1166 test_accept(s_sock, &new_sock, &addr, &addrlen);
1167 zassert_equal(addrlen, sizeof(struct sockaddr_in), "Wrong addrlen");
1168
1169 test_close(c_sock);
1170 test_close(s_sock);
1171 test_close(new_sock);
1172
1173 test_context_cleanup();
1174 }
1175
1176 #define TCP_CLOSE_FAILURE_TIMEOUT 90000
1177
ZTEST(net_socket_tcp,test_z_close_obstructed)1178 ZTEST(net_socket_tcp, test_z_close_obstructed)
1179 {
1180 /* Test if socket closing even when there is not communication
1181 * possible any more
1182 */
1183 int count_before = 0, count_after = 0;
1184 struct sockaddr_in c_saddr;
1185 struct sockaddr_in s_saddr;
1186 struct sockaddr addr;
1187 socklen_t addrlen = sizeof(addr);
1188 int c_sock;
1189 int s_sock;
1190 int new_sock;
1191 int dropped_packets_before = 0;
1192 int dropped_packets_after = 0;
1193
1194 restore_packet_loss_ratio();
1195
1196 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1197 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1198
1199 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1200 test_listen(s_sock);
1201
1202 zassert_equal(zsock_connect(c_sock, (struct sockaddr *)&s_saddr,
1203 sizeof(s_saddr)),
1204 0, "connect not succeed");
1205 test_accept(s_sock, &new_sock, &addr, &addrlen);
1206
1207 /* We should have two contexts open now */
1208 net_context_foreach(calc_net_context, &count_before);
1209
1210 /* Break the communication */
1211 loopback_set_packet_drop_ratio(1.0f);
1212
1213 dropped_packets_before = loopback_get_num_dropped_packets();
1214
1215 test_close(c_sock);
1216
1217 wait_for_n_tcp_contexts(count_before-1, K_MSEC(TCP_CLOSE_FAILURE_TIMEOUT));
1218
1219 net_context_foreach(calc_net_context, &count_after);
1220
1221 zassert_equal(count_before - 1, count_after,
1222 "net_context still in use (before %d vs after %d)",
1223 count_before - 1, count_after);
1224
1225 dropped_packets_after = loopback_get_num_dropped_packets();
1226 int dropped_packets = dropped_packets_after - dropped_packets_before;
1227
1228 /* At least some packet should have been dropped */
1229 zassert_equal(dropped_packets,
1230 CONFIG_NET_TCP_RETRY_COUNT + 1,
1231 "Incorrect number of FIN retries, got %i, expected %i",
1232 dropped_packets, CONFIG_NET_TCP_RETRY_COUNT+1);
1233
1234 test_close(new_sock);
1235 test_close(s_sock);
1236
1237 test_context_cleanup();
1238
1239 /* After everything is closed, we expect no more dropped packets */
1240 dropped_packets_before = loopback_get_num_dropped_packets();
1241 k_sleep(K_SECONDS(2));
1242 dropped_packets_after = loopback_get_num_dropped_packets();
1243
1244 zassert_equal(dropped_packets_before, dropped_packets_after,
1245 "packets after close");
1246
1247 restore_packet_loss_ratio();
1248 }
1249
ZTEST_USER(net_socket_tcp,test_v4_accept_timeout)1250 ZTEST_USER(net_socket_tcp, test_v4_accept_timeout)
1251 {
1252 /* Test if accept() will timeout properly */
1253 int s_sock;
1254 int new_sock;
1255 uint32_t tstamp;
1256 struct sockaddr_in s_saddr;
1257 struct sockaddr addr;
1258 socklen_t addrlen = sizeof(addr);
1259
1260 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1261
1262 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1263 test_listen(s_sock);
1264
1265 test_fcntl(s_sock, F_SETFL, O_NONBLOCK);
1266
1267 tstamp = k_uptime_get_32();
1268 test_accept_timeout(s_sock, &new_sock, &addr, &addrlen);
1269 zassert_true(k_uptime_get_32() - tstamp <= 100, "");
1270
1271 test_close(s_sock);
1272
1273 k_sleep(TCP_TEARDOWN_TIMEOUT);
1274 }
1275
ZTEST(net_socket_tcp,test_so_type)1276 ZTEST(net_socket_tcp, test_so_type)
1277 {
1278 struct sockaddr_in bind_addr4;
1279 struct sockaddr_in6 bind_addr6;
1280 int sock1, sock2, rv;
1281 int optval;
1282 socklen_t optlen = sizeof(optval);
1283
1284 zassert_equal(wait_for_n_tcp_contexts(0, TCP_TEARDOWN_TIMEOUT),
1285 0,
1286 "Not all TCP contexts properly cleaned up");
1287
1288 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &sock1, &bind_addr4);
1289 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &sock2, &bind_addr6);
1290
1291 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_TYPE, &optval, &optlen);
1292 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
1293 zassert_equal(optval, SOCK_STREAM, "getsockopt got invalid type");
1294 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1295
1296 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_TYPE, &optval, &optlen);
1297 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
1298 zassert_equal(optval, SOCK_STREAM, "getsockopt got invalid type");
1299 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1300
1301 test_close(sock1);
1302 test_close(sock2);
1303
1304 zassert_equal(wait_for_n_tcp_contexts(0, TCP_TEARDOWN_TIMEOUT),
1305 0,
1306 "Not all TCP contexts properly cleaned up");
1307 }
1308
ZTEST(net_socket_tcp,test_so_protocol)1309 ZTEST(net_socket_tcp, test_so_protocol)
1310 {
1311 struct sockaddr_in bind_addr4;
1312 struct sockaddr_in6 bind_addr6;
1313 int sock1, sock2, rv;
1314 int optval;
1315 socklen_t optlen = sizeof(optval);
1316
1317 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &sock1, &bind_addr4);
1318 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &sock2, &bind_addr6);
1319
1320 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_PROTOCOL, &optval, &optlen);
1321 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
1322 zassert_equal(optval, IPPROTO_TCP, "getsockopt got invalid protocol");
1323 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1324
1325 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_PROTOCOL, &optval, &optlen);
1326 zassert_equal(rv, 0, "getsockopt failed (%d)", errno);
1327 zassert_equal(optval, IPPROTO_TCP, "getsockopt got invalid protocol");
1328 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1329
1330 test_close(sock1);
1331 test_close(sock2);
1332
1333 test_context_cleanup();
1334 }
1335
ZTEST(net_socket_tcp,test_so_rcvbuf)1336 ZTEST(net_socket_tcp, test_so_rcvbuf)
1337 {
1338 struct sockaddr_in bind_addr4;
1339 struct sockaddr_in6 bind_addr6;
1340 int sock1, sock2, rv;
1341 int retval;
1342 int optval = UINT16_MAX;
1343 socklen_t optlen = sizeof(optval);
1344
1345 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &sock1, &bind_addr4);
1346 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &sock2, &bind_addr6);
1347
1348 rv = zsock_setsockopt(sock1, SOL_SOCKET, SO_RCVBUF, &optval, sizeof(optval));
1349 zassert_equal(rv, 0, "setsockopt failed (%d)", rv);
1350 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_RCVBUF, &retval, &optlen);
1351 zassert_equal(rv, 0, "getsockopt failed (%d)", rv);
1352 zassert_equal(retval, optval, "getsockopt got invalid rcvbuf");
1353 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1354
1355 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_RCVBUF, &optval, sizeof(optval));
1356 zassert_equal(rv, 0, "setsockopt failed (%d)", rv);
1357 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_RCVBUF, &retval, &optlen);
1358 zassert_equal(rv, 0, "getsockopt failed (%d)", rv);
1359 zassert_equal(retval, optval, "getsockopt got invalid rcvbuf");
1360 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1361
1362 optval = -1;
1363 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_RCVBUF, &optval, sizeof(optval));
1364 zassert_equal(rv, -1, "setsockopt failed (%d)", rv);
1365
1366 optval = UINT16_MAX + 1;
1367 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_RCVBUF, &optval, sizeof(optval));
1368 zassert_equal(rv, -1, "setsockopt failed (%d)", rv);
1369
1370 test_close(sock1);
1371 test_close(sock2);
1372
1373 test_context_cleanup();
1374 }
1375
ZTEST(net_socket_tcp,test_so_rcvbuf_win_size)1376 ZTEST(net_socket_tcp, test_so_rcvbuf_win_size)
1377 {
1378 int rv;
1379 int c_sock;
1380 int s_sock;
1381 int new_sock;
1382 struct sockaddr_in c_saddr;
1383 struct sockaddr_in s_saddr;
1384 struct sockaddr addr;
1385 socklen_t addrlen = sizeof(addr);
1386 char tx_buf[] = TEST_STR_SMALL;
1387 int buf_optval = sizeof(TEST_STR_SMALL);
1388
1389 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1390 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1391
1392 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1393 test_listen(s_sock);
1394
1395 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1396
1397 test_accept(s_sock, &new_sock, &addr, &addrlen);
1398 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
1399
1400 /* Lower server-side RX window size. */
1401 rv = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVBUF, &buf_optval,
1402 sizeof(buf_optval));
1403 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1404
1405 rv = zsock_send(c_sock, tx_buf, sizeof(tx_buf), ZSOCK_MSG_DONTWAIT);
1406 zassert_equal(rv, sizeof(tx_buf), "Unexpected return code %d", rv);
1407
1408 /* Window should've dropped to 0, so the ACK will be delayed - wait for
1409 * it to arrive, so that the client is aware of the new window size.
1410 */
1411 k_msleep(150);
1412
1413 /* Client should not be able to send now (RX window full). */
1414 rv = zsock_send(c_sock, tx_buf, 1, ZSOCK_MSG_DONTWAIT);
1415 zassert_equal(rv, -1, "Unexpected return code %d", rv);
1416 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1417
1418 test_close(c_sock);
1419 test_close(new_sock);
1420 test_close(s_sock);
1421
1422 test_context_cleanup();
1423 }
1424
ZTEST(net_socket_tcp,test_so_sndbuf)1425 ZTEST(net_socket_tcp, test_so_sndbuf)
1426 {
1427 struct sockaddr_in bind_addr4;
1428 struct sockaddr_in6 bind_addr6;
1429 int sock1, sock2, rv;
1430 int retval;
1431 int optval = UINT16_MAX;
1432 socklen_t optlen = sizeof(optval);
1433
1434 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &sock1, &bind_addr4);
1435 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &sock2, &bind_addr6);
1436
1437 rv = zsock_setsockopt(sock1, SOL_SOCKET, SO_SNDBUF, &optval, sizeof(optval));
1438 zassert_equal(rv, 0, "setsockopt failed (%d)", rv);
1439 rv = zsock_getsockopt(sock1, SOL_SOCKET, SO_SNDBUF, &retval, &optlen);
1440 zassert_equal(rv, 0, "getsockopt failed (%d)", rv);
1441 zassert_equal(retval, optval, "getsockopt got invalid rcvbuf");
1442 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1443
1444 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_SNDBUF, &optval, sizeof(optval));
1445 zassert_equal(rv, 0, "setsockopt failed (%d)", rv);
1446 rv = zsock_getsockopt(sock2, SOL_SOCKET, SO_SNDBUF, &retval, &optlen);
1447 zassert_equal(rv, 0, "getsockopt failed (%d)", rv);
1448 zassert_equal(retval, optval, "getsockopt got invalid rcvbuf");
1449 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
1450
1451 optval = -1;
1452 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_SNDBUF, &optval, sizeof(optval));
1453 zassert_equal(rv, -1, "setsockopt failed (%d)", rv);
1454
1455 optval = UINT16_MAX + 1;
1456 rv = zsock_setsockopt(sock2, SOL_SOCKET, SO_RCVBUF, &optval, sizeof(optval));
1457 zassert_equal(rv, -1, "setsockopt failed (%d)", rv);
1458
1459 test_close(sock1);
1460 test_close(sock2);
1461
1462 test_context_cleanup();
1463 }
1464
ZTEST(net_socket_tcp,test_so_sndbuf_win_size)1465 ZTEST(net_socket_tcp, test_so_sndbuf_win_size)
1466 {
1467 int rv;
1468 int c_sock;
1469 int s_sock;
1470 int new_sock;
1471 struct sockaddr_in c_saddr;
1472 struct sockaddr_in s_saddr;
1473 struct sockaddr addr;
1474 socklen_t addrlen = sizeof(addr);
1475 char tx_buf[] = TEST_STR_SMALL;
1476 int buf_optval = sizeof(TEST_STR_SMALL);
1477
1478 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1479 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1480
1481 /* Lower client-side TX window size. */
1482 rv = zsock_setsockopt(c_sock, SOL_SOCKET, SO_SNDBUF, &buf_optval,
1483 sizeof(buf_optval));
1484 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1485
1486 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1487 test_listen(s_sock);
1488
1489 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1490
1491 test_accept(s_sock, &new_sock, &addr, &addrlen);
1492 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
1493
1494 /* Make sure the ACK from the server does not arrive. */
1495 loopback_set_packet_drop_ratio(1.0f);
1496
1497 rv = zsock_send(c_sock, tx_buf, sizeof(tx_buf), ZSOCK_MSG_DONTWAIT);
1498 zassert_equal(rv, sizeof(tx_buf), "Unexpected return code %d", rv);
1499
1500 /* Client should not be able to send now (TX window full). */
1501 rv = zsock_send(c_sock, tx_buf, 1, ZSOCK_MSG_DONTWAIT);
1502 zassert_equal(rv, -1, "Unexpected return code %d", rv);
1503 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1504
1505 restore_packet_loss_ratio();
1506
1507 test_close(c_sock);
1508 test_close(new_sock);
1509 test_close(s_sock);
1510
1511 test_context_cleanup();
1512 }
1513
ZTEST(net_socket_tcp,test_v4_so_rcvtimeo)1514 ZTEST(net_socket_tcp, test_v4_so_rcvtimeo)
1515 {
1516 int c_sock;
1517 int s_sock;
1518 int new_sock;
1519 struct sockaddr_in c_saddr;
1520 struct sockaddr_in s_saddr;
1521 struct sockaddr addr;
1522 socklen_t addrlen = sizeof(addr);
1523
1524 int rv;
1525 uint32_t start_time, time_diff;
1526 ssize_t recved = 0;
1527 char rx_buf[30] = {0};
1528
1529 struct timeval optval = {
1530 .tv_sec = 2,
1531 .tv_usec = 500000,
1532 };
1533
1534 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1535 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1536
1537 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1538 test_listen(s_sock);
1539
1540 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1541
1542 test_accept(s_sock, &new_sock, &addr, &addrlen);
1543 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
1544
1545 rv = zsock_setsockopt(c_sock, SOL_SOCKET, SO_RCVTIMEO, &optval,
1546 sizeof(optval));
1547 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1548
1549 optval.tv_usec = 0;
1550 rv = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVTIMEO, &optval,
1551 sizeof(optval));
1552 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1553
1554 start_time = k_uptime_get_32();
1555 recved = zsock_recv(c_sock, rx_buf, sizeof(rx_buf), 0);
1556 time_diff = k_uptime_get_32() - start_time;
1557
1558 zassert_equal(recved, -1, "Unexpected return code");
1559 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1560 zassert_true(time_diff >= 2500, "Expected timeout after 2500ms but "
1561 "was %dms", time_diff);
1562
1563 start_time = k_uptime_get_32();
1564 recved = zsock_recv(new_sock, rx_buf, sizeof(rx_buf), 0);
1565 time_diff = k_uptime_get_32() - start_time;
1566
1567 zassert_equal(recved, -1, "Unexpected return code");
1568 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1569 zassert_true(time_diff >= 2000, "Expected timeout after 2000ms but "
1570 "was %dms", time_diff);
1571
1572 test_close(c_sock);
1573 test_eof(new_sock);
1574
1575 test_close(new_sock);
1576 test_close(s_sock);
1577
1578 test_context_cleanup();
1579 }
1580
ZTEST(net_socket_tcp,test_v6_so_rcvtimeo)1581 ZTEST(net_socket_tcp, test_v6_so_rcvtimeo)
1582 {
1583 int c_sock;
1584 int s_sock;
1585 int new_sock;
1586 struct sockaddr_in6 c_saddr;
1587 struct sockaddr_in6 s_saddr;
1588 struct sockaddr addr;
1589 socklen_t addrlen = sizeof(addr);
1590
1591 int rv;
1592 uint32_t start_time, time_diff;
1593 ssize_t recved = 0;
1594 char rx_buf[30] = {0};
1595
1596 struct timeval optval = {
1597 .tv_sec = 2,
1598 .tv_usec = 500000,
1599 };
1600
1601 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
1602 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1603
1604 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1605 test_listen(s_sock);
1606
1607 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1608
1609 test_accept(s_sock, &new_sock, &addr, &addrlen);
1610 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
1611
1612 rv = zsock_setsockopt(c_sock, SOL_SOCKET, SO_RCVTIMEO, &optval,
1613 sizeof(optval));
1614 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1615
1616 optval.tv_usec = 0;
1617 rv = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVTIMEO, &optval,
1618 sizeof(optval));
1619 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1620
1621 start_time = k_uptime_get_32();
1622 recved = zsock_recv(c_sock, rx_buf, sizeof(rx_buf), 0);
1623 time_diff = k_uptime_get_32() - start_time;
1624
1625 zassert_equal(recved, -1, "Unexpected return code");
1626 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1627 zassert_true(time_diff >= 2500, "Expected timeout after 2500ms but "
1628 "was %dms", time_diff);
1629
1630 start_time = k_uptime_get_32();
1631 recved = zsock_recv(new_sock, rx_buf, sizeof(rx_buf), 0);
1632 time_diff = k_uptime_get_32() - start_time;
1633
1634 zassert_equal(recved, -1, "Unexpected return code");
1635 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1636 zassert_true(time_diff >= 2000, "Expected timeout after 2000ms but "
1637 "was %dms", time_diff);
1638
1639 test_close(c_sock);
1640 test_eof(new_sock);
1641
1642 test_close(new_sock);
1643 test_close(s_sock);
1644
1645 test_context_cleanup();
1646 }
1647
ZTEST(net_socket_tcp,test_v4_so_sndtimeo)1648 ZTEST(net_socket_tcp, test_v4_so_sndtimeo)
1649 {
1650 int rv;
1651 int c_sock;
1652 int s_sock;
1653 int new_sock;
1654 struct sockaddr_in c_saddr;
1655 struct sockaddr_in s_saddr;
1656 struct sockaddr addr;
1657 socklen_t addrlen = sizeof(addr);
1658 uint32_t start_time, time_diff;
1659 char tx_buf[] = TEST_STR_SMALL;
1660 int buf_optval = sizeof(TEST_STR_SMALL);
1661 struct timeval timeo_optval = {
1662 .tv_sec = 0,
1663 .tv_usec = 200000,
1664 };
1665
1666 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1667 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1668
1669 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1670 test_listen(s_sock);
1671
1672 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1673
1674 test_accept(s_sock, &new_sock, &addr, &addrlen);
1675 zassert_equal(addrlen, sizeof(struct sockaddr_in), "wrong addrlen");
1676
1677 rv = zsock_setsockopt(c_sock, SOL_SOCKET, SO_SNDTIMEO, &timeo_optval,
1678 sizeof(timeo_optval));
1679 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1680
1681 /* Simulate window full scenario with SO_RCVBUF option. */
1682 rv = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVBUF, &buf_optval,
1683 sizeof(buf_optval));
1684 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1685
1686 rv = zsock_send(c_sock, tx_buf, sizeof(tx_buf), ZSOCK_MSG_DONTWAIT);
1687 zassert_equal(rv, sizeof(tx_buf), "Unexpected return code %d", rv);
1688
1689 /* Wait for ACK (empty window). */
1690 k_msleep(150);
1691
1692 /* Client should not be able to send now and time out after SO_SNDTIMEO */
1693 start_time = k_uptime_get_32();
1694 rv = zsock_send(c_sock, tx_buf, 1, 0);
1695 time_diff = k_uptime_get_32() - start_time;
1696
1697 zassert_equal(rv, -1, "Unexpected return code %d", rv);
1698 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1699 zassert_true(time_diff >= 200, "Expected timeout after 200ms but "
1700 "was %dms", time_diff);
1701
1702 test_close(c_sock);
1703 test_close(new_sock);
1704 test_close(s_sock);
1705
1706 test_context_cleanup();
1707 }
1708
ZTEST(net_socket_tcp,test_v6_so_sndtimeo)1709 ZTEST(net_socket_tcp, test_v6_so_sndtimeo)
1710 {
1711 int rv;
1712 int c_sock;
1713 int s_sock;
1714 int new_sock;
1715 struct sockaddr_in6 c_saddr;
1716 struct sockaddr_in6 s_saddr;
1717 struct sockaddr addr;
1718 socklen_t addrlen = sizeof(addr);
1719 uint32_t start_time, time_diff;
1720 char tx_buf[] = TEST_STR_SMALL;
1721 int buf_optval = sizeof(TEST_STR_SMALL);
1722 struct timeval timeo_optval = {
1723 .tv_sec = 0,
1724 .tv_usec = 500000,
1725 };
1726
1727 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
1728 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1729
1730 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1731 test_listen(s_sock);
1732
1733 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1734
1735 test_accept(s_sock, &new_sock, &addr, &addrlen);
1736 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "wrong addrlen");
1737
1738 rv = zsock_setsockopt(c_sock, SOL_SOCKET, SO_SNDTIMEO, &timeo_optval,
1739 sizeof(timeo_optval));
1740 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1741
1742 /* Simulate window full scenario with SO_RCVBUF option. */
1743 rv = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVBUF, &buf_optval,
1744 sizeof(buf_optval));
1745 zassert_equal(rv, 0, "setsockopt failed (%d)", errno);
1746
1747 rv = zsock_send(c_sock, tx_buf, sizeof(tx_buf), ZSOCK_MSG_DONTWAIT);
1748 zassert_equal(rv, sizeof(tx_buf), "Unexpected return code %d", rv);
1749
1750 /* Wait for ACK (empty window). */
1751 k_msleep(150);
1752
1753 /* Client should not be able to send now and time out after SO_SNDTIMEO */
1754 start_time = k_uptime_get_32();
1755 rv = zsock_send(c_sock, tx_buf, 1, 0);
1756 time_diff = k_uptime_get_32() - start_time;
1757
1758 zassert_equal(rv, -1, "Unexpected return code %d", rv);
1759 zassert_equal(errno, EAGAIN, "Unexpected errno value: %d", errno);
1760 zassert_true(time_diff >= 500, "Expected timeout after 500ms but "
1761 "was %dms", time_diff);
1762
1763 test_close(c_sock);
1764 test_close(new_sock);
1765 test_close(s_sock);
1766
1767 test_context_cleanup();
1768 }
1769
1770 struct test_msg_waitall_data {
1771 struct k_work_delayable tx_work;
1772 int sock;
1773 const uint8_t *data;
1774 size_t offset;
1775 int retries;
1776 };
1777
test_msg_waitall_tx_work_handler(struct k_work * work)1778 static void test_msg_waitall_tx_work_handler(struct k_work *work)
1779 {
1780 struct k_work_delayable *dwork = k_work_delayable_from_work(work);
1781 struct test_msg_waitall_data *test_data =
1782 CONTAINER_OF(dwork, struct test_msg_waitall_data, tx_work);
1783
1784 if (test_data->retries > 0) {
1785 test_send(test_data->sock, test_data->data + test_data->offset, 1, 0);
1786 test_data->offset++;
1787 test_data->retries--;
1788 k_work_reschedule(&test_data->tx_work, K_MSEC(10));
1789 }
1790 }
1791
ZTEST(net_socket_tcp,test_v4_msg_waitall)1792 ZTEST(net_socket_tcp, test_v4_msg_waitall)
1793 {
1794 struct test_msg_waitall_data test_data = {
1795 .data = TEST_STR_SMALL,
1796 };
1797 int c_sock;
1798 int s_sock;
1799 int new_sock;
1800 struct sockaddr_in c_saddr;
1801 struct sockaddr_in s_saddr;
1802 struct sockaddr addr;
1803 socklen_t addrlen = sizeof(addr);
1804 int ret;
1805 uint8_t rx_buf[sizeof(TEST_STR_SMALL) - 1] = { 0 };
1806 struct timeval timeo_optval = {
1807 .tv_sec = 0,
1808 .tv_usec = 100000,
1809 };
1810
1811 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
1812 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1813
1814 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1815 test_listen(s_sock);
1816
1817 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1818
1819 test_accept(s_sock, &new_sock, &addr, &addrlen);
1820 zassert_equal(addrlen, sizeof(struct sockaddr_in), "Wrong addrlen");
1821
1822
1823 /* Regular MSG_WAITALL - make sure recv returns only after
1824 * requested amount is received.
1825 */
1826 test_data.offset = 0;
1827 test_data.retries = sizeof(rx_buf);
1828 test_data.sock = c_sock;
1829 k_work_init_delayable(&test_data.tx_work,
1830 test_msg_waitall_tx_work_handler);
1831 k_work_reschedule(&test_data.tx_work, K_MSEC(10));
1832
1833 ret = zsock_recv(new_sock, rx_buf, sizeof(rx_buf), ZSOCK_MSG_WAITALL);
1834 zassert_equal(ret, sizeof(rx_buf), "Invalid length received");
1835 zassert_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(rx_buf),
1836 "Invalid data received");
1837 k_work_cancel_delayable(&test_data.tx_work);
1838
1839 /* MSG_WAITALL + SO_RCVTIMEO - make sure recv returns the amount of data
1840 * received so far
1841 */
1842 ret = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVTIMEO, &timeo_optval,
1843 sizeof(timeo_optval));
1844 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
1845
1846 memset(rx_buf, 0, sizeof(rx_buf));
1847 test_data.offset = 0;
1848 test_data.retries = sizeof(rx_buf) - 1;
1849 test_data.sock = c_sock;
1850 k_work_init_delayable(&test_data.tx_work,
1851 test_msg_waitall_tx_work_handler);
1852 k_work_reschedule(&test_data.tx_work, K_MSEC(10));
1853
1854 ret = zsock_recv(new_sock, rx_buf, sizeof(rx_buf) - 1, ZSOCK_MSG_WAITALL);
1855 if (ret < 0) {
1856 LOG_ERR("receive return val %i", ret);
1857 }
1858 zassert_equal(ret, sizeof(rx_buf) - 1, "Invalid length received");
1859 zassert_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(rx_buf) - 1,
1860 "Invalid data received");
1861 k_work_cancel_delayable(&test_data.tx_work);
1862
1863 test_close(new_sock);
1864 test_close(s_sock);
1865 test_close(c_sock);
1866
1867 test_context_cleanup();
1868 }
1869
ZTEST(net_socket_tcp,test_v6_msg_waitall)1870 ZTEST(net_socket_tcp, test_v6_msg_waitall)
1871 {
1872 struct test_msg_waitall_data test_data = {
1873 .data = TEST_STR_SMALL,
1874 };
1875 int c_sock;
1876 int s_sock;
1877 int new_sock;
1878 struct sockaddr_in6 c_saddr;
1879 struct sockaddr_in6 s_saddr;
1880 struct sockaddr addr;
1881 socklen_t addrlen = sizeof(addr);
1882 int ret;
1883 uint8_t rx_buf[sizeof(TEST_STR_SMALL) - 1] = { 0 };
1884 struct timeval timeo_optval = {
1885 .tv_sec = 0,
1886 .tv_usec = 100000,
1887 };
1888
1889 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
1890 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
1891
1892 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1893 test_listen(s_sock);
1894
1895 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
1896
1897 test_accept(s_sock, &new_sock, &addr, &addrlen);
1898 zassert_equal(addrlen, sizeof(struct sockaddr_in6), "Wrong addrlen");
1899
1900 /* Regular MSG_WAITALL - make sure recv returns only after
1901 * requested amount is received.
1902 */
1903 test_data.offset = 0;
1904 test_data.retries = sizeof(rx_buf);
1905 test_data.sock = c_sock;
1906 k_work_init_delayable(&test_data.tx_work,
1907 test_msg_waitall_tx_work_handler);
1908 k_work_reschedule(&test_data.tx_work, K_MSEC(10));
1909
1910 ret = zsock_recv(new_sock, rx_buf, sizeof(rx_buf), ZSOCK_MSG_WAITALL);
1911 zassert_equal(ret, sizeof(rx_buf), "Invalid length received");
1912 zassert_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(rx_buf),
1913 "Invalid data received");
1914 k_work_cancel_delayable(&test_data.tx_work);
1915
1916 /* MSG_WAITALL + SO_RCVTIMEO - make sure recv returns the amount of data
1917 * received so far
1918 */
1919 ret = zsock_setsockopt(new_sock, SOL_SOCKET, SO_RCVTIMEO, &timeo_optval,
1920 sizeof(timeo_optval));
1921 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
1922
1923 memset(rx_buf, 0, sizeof(rx_buf));
1924 test_data.offset = 0;
1925 test_data.retries = sizeof(rx_buf) - 1;
1926 test_data.sock = c_sock;
1927 k_work_init_delayable(&test_data.tx_work,
1928 test_msg_waitall_tx_work_handler);
1929 k_work_reschedule(&test_data.tx_work, K_MSEC(10));
1930
1931 ret = zsock_recv(new_sock, rx_buf, sizeof(rx_buf) - 1, ZSOCK_MSG_WAITALL);
1932 zassert_equal(ret, sizeof(rx_buf) - 1, "Invalid length received");
1933 zassert_mem_equal(rx_buf, TEST_STR_SMALL, sizeof(rx_buf) - 1,
1934 "Invalid data received");
1935 k_work_cancel_delayable(&test_data.tx_work);
1936
1937 test_close(new_sock);
1938 test_close(s_sock);
1939 test_close(c_sock);
1940
1941 test_context_cleanup();
1942 }
1943
1944 #ifdef CONFIG_USERSPACE
1945 #define CHILD_STACK_SZ (2048 + CONFIG_TEST_EXTRA_STACK_SIZE)
1946 struct k_thread child_thread;
1947 K_THREAD_STACK_DEFINE(child_stack, CHILD_STACK_SZ);
1948 ZTEST_BMEM volatile int result;
1949
child_entry(void * p1,void * p2,void * p3)1950 static void child_entry(void *p1, void *p2, void *p3)
1951 {
1952 int sock = POINTER_TO_INT(p1);
1953
1954 result = zsock_close(sock);
1955 }
1956
spawn_child(int sock)1957 static void spawn_child(int sock)
1958 {
1959 k_thread_create(&child_thread, child_stack,
1960 K_THREAD_STACK_SIZEOF(child_stack), child_entry,
1961 INT_TO_POINTER(sock), NULL, NULL, 0, K_USER,
1962 K_FOREVER);
1963 }
1964 #endif
1965
ZTEST(net_socket_tcp,test_socket_permission)1966 ZTEST(net_socket_tcp, test_socket_permission)
1967 {
1968 #ifdef CONFIG_USERSPACE
1969 int sock;
1970 struct sockaddr_in saddr;
1971 struct net_context *ctx;
1972
1973 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &sock, &saddr);
1974
1975 ctx = zsock_get_context_object(sock);
1976 zassert_not_null(ctx, "zsock_get_context_object() failed");
1977
1978 /* Spawn a child thread which doesn't inherit our permissions,
1979 * it will try to perform a socket operation and fail due to lack
1980 * of permissions on it.
1981 */
1982 spawn_child(sock);
1983 k_thread_start(&child_thread);
1984 k_thread_join(&child_thread, K_FOREVER);
1985
1986 zassert_not_equal(result, 0, "child succeeded with no permission");
1987
1988 /* Now spawn the same child thread again, but this time we grant
1989 * permission on the net_context before we start it, and the
1990 * child should now succeed.
1991 */
1992 spawn_child(sock);
1993 k_object_access_grant(ctx, &child_thread);
1994 k_thread_start(&child_thread);
1995 k_thread_join(&child_thread, K_FOREVER);
1996
1997 zassert_equal(result, 0, "child failed with permissions");
1998 #else
1999 ztest_test_skip();
2000 #endif /* CONFIG_USERSPACE */
2001 }
2002
setup(void)2003 static void *setup(void)
2004 {
2005 #ifdef CONFIG_USERSPACE
2006 /* ztest thread inherit permissions from main */
2007 k_thread_access_grant(k_current_get(), &child_thread, child_stack);
2008 #endif
2009
2010 if (IS_ENABLED(CONFIG_NET_TC_THREAD_COOPERATIVE)) {
2011 k_thread_priority_set(k_current_get(),
2012 K_PRIO_COOP(CONFIG_NUM_COOP_PRIORITIES - 1));
2013 } else {
2014 k_thread_priority_set(k_current_get(), K_PRIO_PREEMPT(8));
2015 }
2016
2017 return NULL;
2018 }
2019
2020 struct close_data {
2021 struct k_work_delayable work;
2022 int fd;
2023 };
2024
close_work(struct k_work * work)2025 static void close_work(struct k_work *work)
2026 {
2027 struct k_work_delayable *dwork = k_work_delayable_from_work(work);
2028 struct close_data *data = CONTAINER_OF(dwork, struct close_data, work);
2029
2030 zsock_close(data->fd);
2031 }
2032
ZTEST(net_socket_tcp,test_close_while_recv)2033 ZTEST(net_socket_tcp, test_close_while_recv)
2034 {
2035 /* Blocking recv() should return an error after close() is
2036 * called from another thread.
2037 */
2038 int c_sock;
2039 int s_sock;
2040 int new_sock;
2041 struct sockaddr_in6 c_saddr, s_saddr;
2042 struct sockaddr addr;
2043 socklen_t addrlen = sizeof(addr);
2044 struct close_data close_work_data;
2045 char rx_buf[1];
2046 ssize_t ret;
2047
2048 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &c_sock, &c_saddr);
2049 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
2050
2051 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
2052 test_listen(s_sock);
2053
2054 /* Connect and accept that connection */
2055 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
2056
2057 test_accept(s_sock, &new_sock, &addr, &addrlen);
2058
2059 /* Schedule close() from workqueue */
2060 k_work_init_delayable(&close_work_data.work, close_work);
2061 close_work_data.fd = c_sock;
2062 k_work_schedule(&close_work_data.work, K_MSEC(10));
2063
2064 /* Start blocking recv(), which should be unblocked by close() from
2065 * another thread and return an error.
2066 */
2067 ret = zsock_recv(c_sock, rx_buf, sizeof(rx_buf), 0);
2068 zassert_equal(ret, -1, "recv did not return error");
2069 zassert_equal(errno, EINTR, "Unexpected errno value: %d", errno);
2070
2071 test_close(new_sock);
2072 test_close(s_sock);
2073
2074 test_context_cleanup();
2075 }
2076
ZTEST(net_socket_tcp,test_close_while_accept)2077 ZTEST(net_socket_tcp, test_close_while_accept)
2078 {
2079 /* Blocking accept() should return an error after close() is
2080 * called from another thread.
2081 */
2082 int s_sock;
2083 int new_sock;
2084 struct sockaddr_in6 s_saddr;
2085 struct sockaddr addr;
2086 socklen_t addrlen = sizeof(addr);
2087 struct close_data close_work_data;
2088
2089 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &s_sock, &s_saddr);
2090
2091 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
2092 test_listen(s_sock);
2093
2094 /* Schedule close() from workqueue */
2095 k_work_init_delayable(&close_work_data.work, close_work);
2096 close_work_data.fd = s_sock;
2097 k_work_schedule(&close_work_data.work, K_MSEC(10));
2098
2099 /* Start blocking accept(), which should be unblocked by close() from
2100 * another thread and return an error.
2101 */
2102 new_sock = zsock_accept(s_sock, &addr, &addrlen);
2103 zassert_equal(new_sock, -1, "accept did not return error");
2104 zassert_equal(errno, EINTR, "Unexpected errno value: %d", errno);
2105
2106 test_context_cleanup();
2107 }
2108
2109 #undef read
2110 #define read(fd, buf, len) zsock_recv(fd, buf, len, 0)
2111
2112 #undef write
2113 #define write(fd, buf, len) zsock_send(fd, buf, len, 0)
2114
2115 enum test_ioctl_fionread_sockid {
2116 CLIENT, SERVER, ACCEPT,
2117 };
2118
test_ioctl_fionread_setup(int af,int fd[3])2119 static void test_ioctl_fionread_setup(int af, int fd[3])
2120 {
2121 socklen_t addrlen;
2122 socklen_t addrlen2;
2123 struct sockaddr_in6 addr;
2124 struct sockaddr_in6 c_saddr;
2125 struct sockaddr_in6 s_saddr;
2126
2127 fd[0] = -1;
2128 fd[1] = -1;
2129 fd[2] = -1;
2130
2131 switch (af) {
2132 case AF_INET: {
2133 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &fd[CLIENT],
2134 (struct sockaddr_in *)&c_saddr);
2135 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &fd[ACCEPT],
2136 (struct sockaddr_in *)&s_saddr);
2137 addrlen = sizeof(struct sockaddr_in);
2138 } break;
2139
2140 case AF_INET6: {
2141 prepare_sock_tcp_v6(MY_IPV6_ADDR, ANY_PORT, &fd[CLIENT], &c_saddr);
2142 prepare_sock_tcp_v6(MY_IPV6_ADDR, SERVER_PORT, &fd[ACCEPT], &s_saddr);
2143 addrlen = sizeof(struct sockaddr_in6);
2144 } break;
2145
2146 default:
2147 zassert_true(false);
2148 return;
2149 }
2150
2151 addrlen2 = addrlen;
2152
2153 test_bind(fd[ACCEPT], (struct sockaddr *)&s_saddr, addrlen);
2154 test_listen(fd[ACCEPT]);
2155
2156 test_connect(fd[CLIENT], (struct sockaddr *)&s_saddr, addrlen);
2157 test_accept(fd[ACCEPT], &fd[SERVER], (struct sockaddr *)&addr, &addrlen2);
2158 }
2159
2160 /* note: this is duplicated from tests/net/socket/socketpair/src/fionread.c */
test_ioctl_fionread_common(int af)2161 static void test_ioctl_fionread_common(int af)
2162 {
2163 int avail;
2164 uint8_t bytes[2];
2165 /* server fd := 0, client fd := 1, accept fd := 2 */
2166 enum fde {
2167 SERVER,
2168 CLIENT,
2169 ACCEPT,
2170 };
2171 int fd[] = {-1, -1, -1};
2172
2173 test_ioctl_fionread_setup(af, fd);
2174
2175 /* both ends should have zero bytes available after being newly created */
2176 for (enum fde i = SERVER; i <= CLIENT; ++i) {
2177 avail = 42;
2178 zassert_ok(zsock_ioctl(fd[i], ZFD_IOCTL_FIONREAD, &avail));
2179 zassert_equal(0, avail, "exp: %d: act: %d", 0, avail);
2180 }
2181
2182 /* write something to one end, check availability from the other end */
2183 for (enum fde i = SERVER; i <= CLIENT; ++i) {
2184 enum fde j = (i + 1) % (CLIENT + 1);
2185
2186 zassert_equal(1, write(fd[i], "\x42", 1));
2187 zassert_equal(1, write(fd[i], "\x73", 1));
2188 k_msleep(100);
2189 zassert_ok(zsock_ioctl(fd[j], ZFD_IOCTL_FIONREAD, &avail));
2190 zassert_equal(ARRAY_SIZE(bytes), avail, "exp: %d: act: %d", ARRAY_SIZE(bytes),
2191 avail);
2192 }
2193
2194 /* read the other end, ensure availability is zero again */
2195 for (enum fde i = SERVER; i <= CLIENT; ++i) {
2196 int ex = ARRAY_SIZE(bytes);
2197 int act = read(fd[i], bytes, ARRAY_SIZE(bytes));
2198
2199 zassert_equal(ex, act, "read() failed: errno: %d exp: %d act: %d", errno, ex, act);
2200 zassert_ok(zsock_ioctl(fd[i], ZFD_IOCTL_FIONREAD, &avail));
2201 zassert_equal(0, avail, "exp: %d: act: %d", 0, avail);
2202 }
2203
2204 zsock_close(fd[SERVER]);
2205 zsock_close(fd[CLIENT]);
2206 zsock_close(fd[ACCEPT]);
2207
2208 test_context_cleanup();
2209 }
2210
ZTEST(net_socket_tcp,test_ioctl_fionread_v4)2211 ZTEST(net_socket_tcp, test_ioctl_fionread_v4)
2212 {
2213 test_ioctl_fionread_common(AF_INET);
2214 }
ZTEST(net_socket_tcp,test_ioctl_fionread_v6)2215 ZTEST(net_socket_tcp, test_ioctl_fionread_v6)
2216 {
2217 test_ioctl_fionread_common(AF_INET6);
2218 }
2219
2220 /* Connect to peer which is not listening the test port and
2221 * make sure select() returns proper error for the closed
2222 * connection.
2223 */
ZTEST(net_socket_tcp,test_connect_and_wait_for_v4_select)2224 ZTEST(net_socket_tcp, test_connect_and_wait_for_v4_select)
2225 {
2226 struct sockaddr_in addr = { 0 };
2227 struct in_addr v4addr;
2228 int fd, flags, ret, optval;
2229 socklen_t optlen = sizeof(optval);
2230
2231 fd = zsock_socket(AF_INET, SOCK_STREAM, 0);
2232
2233 flags = zsock_fcntl(fd, F_GETFL, 0);
2234 zsock_fcntl(fd, F_SETFL, flags | O_NONBLOCK);
2235
2236 zsock_inet_pton(AF_INET, "127.0.0.1", (void *)&v4addr);
2237
2238 addr.sin_family = AF_INET;
2239 net_ipaddr_copy(&addr.sin_addr, &v4addr);
2240
2241 /* There should be nobody serving this port */
2242 addr.sin_port = htons(8088);
2243
2244 ret = zsock_connect(fd, (const struct sockaddr *)&addr, sizeof(addr));
2245 zassert_equal(ret, -1, "connect succeed, %d", errno);
2246 zassert_equal(errno, EINPROGRESS, "connect succeed, %d", errno);
2247
2248 /* Wait for the connection (this should fail eventually) */
2249 while (1) {
2250 zsock_fd_set wfds;
2251 struct timeval tv = {
2252 .tv_sec = 1,
2253 .tv_usec = 0
2254 };
2255
2256 ZSOCK_FD_ZERO(&wfds);
2257 ZSOCK_FD_SET(fd, &wfds);
2258
2259 /* Check if the connection is there, this should timeout */
2260 ret = zsock_select(fd + 1, NULL, &wfds, NULL, &tv);
2261 if (ret < 0) {
2262 break;
2263 }
2264
2265 if (ret > 0) {
2266 if (ZSOCK_FD_ISSET(fd, &wfds)) {
2267 break;
2268 }
2269 }
2270 }
2271
2272 zassert_true(ret > 0, "select failed, %d", errno);
2273
2274 /* Get the reason for the connect */
2275 ret = zsock_getsockopt(fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
2276 zassert_equal(ret, 0, "getsockopt failed, %d", errno);
2277
2278 /* If SO_ERROR is 0, then it means that connect succeed. Any
2279 * other value (errno) means that it failed.
2280 */
2281 zassert_equal(optval, ECONNREFUSED, "unexpected connect status, %d", optval);
2282
2283 ret = zsock_close(fd);
2284 zassert_equal(ret, 0, "close failed, %d", errno);
2285 }
2286
2287 /* Connect to peer which is not listening the test port and
2288 * make sure poll() returns proper error for the closed
2289 * connection.
2290 */
ZTEST(net_socket_tcp,test_connect_and_wait_for_v4_poll)2291 ZTEST(net_socket_tcp, test_connect_and_wait_for_v4_poll)
2292 {
2293 struct sockaddr_in addr = { 0 };
2294 struct zsock_pollfd fds[1];
2295 struct in_addr v4addr;
2296 int fd, flags, ret, optval;
2297 bool closed = false;
2298 socklen_t optlen = sizeof(optval);
2299
2300 fd = zsock_socket(AF_INET, SOCK_STREAM, 0);
2301
2302 flags = zsock_fcntl(fd, F_GETFL, 0);
2303 zsock_fcntl(fd, F_SETFL, flags | O_NONBLOCK);
2304
2305 zsock_inet_pton(AF_INET, "127.0.0.1", (void *)&v4addr);
2306
2307 addr.sin_family = AF_INET;
2308 net_ipaddr_copy(&addr.sin_addr, &v4addr);
2309
2310 /* There should be nobody serving this port */
2311 addr.sin_port = htons(8088);
2312
2313 ret = zsock_connect(fd, (const struct sockaddr *)&addr, sizeof(addr));
2314 zassert_equal(ret, -1, "connect succeed, %d", errno);
2315 zassert_equal(errno, EINPROGRESS, "connect succeed, %d", errno);
2316
2317 /* Wait for the connection (this should fail eventually) */
2318 while (1) {
2319 memset(fds, 0, sizeof(fds));
2320 fds[0].fd = fd;
2321 fds[0].events = ZSOCK_POLLOUT;
2322
2323 /* Check if the connection is there, this should timeout */
2324 ret = zsock_poll(fds, 1, 10);
2325 if (ret < 0) {
2326 break;
2327 }
2328
2329 if (fds[0].revents > 0) {
2330 if (fds[0].revents & ZSOCK_POLLERR) {
2331 closed = true;
2332 break;
2333 }
2334 }
2335 }
2336
2337 zassert_true(closed, "poll failed, %d", errno);
2338
2339 /* Get the reason for the connect */
2340 ret = zsock_getsockopt(fd, SOL_SOCKET, SO_ERROR, &optval, &optlen);
2341 zassert_equal(ret, 0, "getsockopt failed, %d", errno);
2342
2343 /* If SO_ERROR is 0, then it means that connect succeed. Any
2344 * other value (errno) means that it failed.
2345 */
2346 zassert_equal(optval, ECONNREFUSED, "unexpected connect status, %d", optval);
2347
2348 ret = zsock_close(fd);
2349 zassert_equal(ret, 0, "close failed, %d", errno);
2350 }
2351
ZTEST(net_socket_tcp,test_so_keepalive)2352 ZTEST(net_socket_tcp, test_so_keepalive)
2353 {
2354 struct sockaddr_in bind_addr4;
2355 int sock, ret;
2356 int optval;
2357 socklen_t optlen = sizeof(optval);
2358
2359 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &sock, &bind_addr4);
2360
2361 /* Keep-alive should be disabled by default. */
2362 ret = zsock_getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen);
2363 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2364 zassert_equal(optval, 0, "getsockopt got invalid value");
2365 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2366
2367 /* Enable keep-alive. */
2368 optval = 1;
2369 ret = zsock_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
2370 &optval, sizeof(optval));
2371 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2372
2373 ret = zsock_getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen);
2374 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2375 zassert_equal(optval, 1, "getsockopt got invalid value");
2376 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2377
2378 /* Check keep-alive parameters defaults. */
2379 ret = zsock_getsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &optval, &optlen);
2380 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2381 zassert_equal(optval, CONFIG_NET_TCP_KEEPIDLE_DEFAULT,
2382 "getsockopt got invalid value");
2383 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2384
2385 ret = zsock_getsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &optval, &optlen);
2386 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2387 zassert_equal(optval, CONFIG_NET_TCP_KEEPINTVL_DEFAULT,
2388 "getsockopt got invalid value");
2389 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2390
2391 ret = zsock_getsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &optval, &optlen);
2392 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2393 zassert_equal(optval, CONFIG_NET_TCP_KEEPCNT_DEFAULT,
2394 "getsockopt got invalid value");
2395 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2396
2397 /* Check keep-alive parameters update. */
2398 optval = 123;
2399 ret = zsock_setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE,
2400 &optval, sizeof(optval));
2401 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2402
2403 optval = 10;
2404 ret = zsock_setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL,
2405 &optval, sizeof(optval));
2406 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2407
2408 optval = 2;
2409 ret = zsock_setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT,
2410 &optval, sizeof(optval));
2411 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2412
2413 ret = zsock_getsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &optval, &optlen);
2414 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2415 zassert_equal(optval, 123, "getsockopt got invalid value");
2416 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2417
2418 ret = zsock_getsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &optval, &optlen);
2419 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2420 zassert_equal(optval, 10, "getsockopt got invalid value");
2421 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2422
2423 ret = zsock_getsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &optval, &optlen);
2424 zassert_equal(ret, 0, "getsockopt failed (%d)", errno);
2425 zassert_equal(optval, 2, "getsockopt got invalid value");
2426 zassert_equal(optlen, sizeof(optval), "getsockopt got invalid size");
2427
2428 test_close(sock);
2429
2430 test_context_cleanup();
2431 }
2432
ZTEST(net_socket_tcp,test_keepalive_timeout)2433 ZTEST(net_socket_tcp, test_keepalive_timeout)
2434 {
2435 struct sockaddr_in c_saddr, s_saddr;
2436 int c_sock, s_sock, new_sock;
2437 uint8_t rx_buf;
2438 int optval;
2439 int ret;
2440
2441 prepare_sock_tcp_v4(MY_IPV4_ADDR, ANY_PORT, &c_sock, &c_saddr);
2442 prepare_sock_tcp_v4(MY_IPV4_ADDR, SERVER_PORT, &s_sock, &s_saddr);
2443
2444 /* Enable keep-alive on both ends and set timeouts/retries to minimum */
2445 optval = 1;
2446 ret = zsock_setsockopt(c_sock, SOL_SOCKET, SO_KEEPALIVE,
2447 &optval, sizeof(optval));
2448 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2449 ret = zsock_setsockopt(s_sock, SOL_SOCKET, SO_KEEPALIVE,
2450 &optval, sizeof(optval));
2451 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2452
2453 optval = 1;
2454 ret = zsock_setsockopt(c_sock, IPPROTO_TCP, TCP_KEEPIDLE,
2455 &optval, sizeof(optval));
2456 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2457 ret = zsock_setsockopt(s_sock, IPPROTO_TCP, TCP_KEEPIDLE,
2458 &optval, sizeof(optval));
2459 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2460
2461 optval = 1;
2462 ret = zsock_setsockopt(c_sock, IPPROTO_TCP, TCP_KEEPINTVL,
2463 &optval, sizeof(optval));
2464 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2465 ret = zsock_setsockopt(s_sock, IPPROTO_TCP, TCP_KEEPINTVL,
2466 &optval, sizeof(optval));
2467 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2468
2469 optval = 1;
2470 ret = zsock_setsockopt(c_sock, IPPROTO_TCP, TCP_KEEPCNT,
2471 &optval, sizeof(optval));
2472 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2473 ret = zsock_setsockopt(s_sock, IPPROTO_TCP, TCP_KEEPCNT,
2474 &optval, sizeof(optval));
2475 zassert_equal(ret, 0, "setsockopt failed (%d)", errno);
2476
2477 /* Establish connection */
2478 test_bind(s_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
2479 test_listen(s_sock);
2480 test_connect(c_sock, (struct sockaddr *)&s_saddr, sizeof(s_saddr));
2481 test_accept(s_sock, &new_sock, NULL, NULL);
2482
2483 /* Kill communication - expect that connection will be closed after
2484 * a timeout period.
2485 */
2486 loopback_set_packet_drop_ratio(1.0f);
2487
2488 ret = zsock_recv(c_sock, &rx_buf, sizeof(rx_buf), 0);
2489 zassert_equal(ret, -1, "recv() should've failed");
2490 zassert_equal(errno, ETIMEDOUT, "wrong errno value, %d", errno);
2491
2492 /* Same on the other end. */
2493 ret = zsock_recv(new_sock, &rx_buf, sizeof(rx_buf), 0);
2494 zassert_equal(ret, -1, "recv() should've failed");
2495 zassert_equal(errno, ETIMEDOUT, "wrong errno value, %d", errno);
2496
2497 test_close(c_sock);
2498 test_close(new_sock);
2499 test_close(s_sock);
2500
2501 loopback_set_packet_drop_ratio(0.0f);
2502 test_context_cleanup();
2503 }
2504
after(void * arg)2505 static void after(void *arg)
2506 {
2507 ARG_UNUSED(arg);
2508
2509 for (int i = 0; i < CONFIG_ZVFS_OPEN_MAX; ++i) {
2510 (void)zsock_close(i);
2511 }
2512 }
2513
2514 ZTEST_SUITE(net_socket_tcp, NULL, setup, NULL, after, NULL);
2515
