1 /**
2 * @file
3 * Sockets stresstest
4 *
5 * This file uses the lwIP socket API to do stress tests that should test the
6 * stability when used in many different situations, with many concurrent
7 * sockets making concurrent transfers in different manners.
8 *
9 * - test rely on loopback sockets for now, so netif drivers are not tested
10 * - all enabled functions shall be used
11 * - parallelism of the tests depend on enough resources being available
12 * (configure your lwipopts.h settings high enough)
13 * - test should also be able to run in a real target
14 *
15 * TODO:
16 * - full duplex
17 * - add asserts about internal socket/netconn/pcb state?
18 */
19
20 /*
21 * Copyright (c) 2017 Simon Goldschmidt
22 * All rights reserved.
23 *
24 * Redistribution and use in source and binary forms, with or without modification,
25 * are permitted provided that the following conditions are met:
26 *
27 * 1. Redistributions of source code must retain the above copyright notice,
28 * this list of conditions and the following disclaimer.
29 * 2. Redistributions in binary form must reproduce the above copyright notice,
30 * this list of conditions and the following disclaimer in the documentation
31 * and/or other materials provided with the distribution.
32 * 3. The name of the author may not be used to endorse or promote products
33 * derived from this software without specific prior written permission.
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
36 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
37 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
38 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
39 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
40 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
41 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
42 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
43 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
44 * OF SUCH DAMAGE.
45 *
46 * This file is part of the lwIP TCP/IP stack.
47 *
48 * Author: Simon Goldschmidt <goldsimon@gmx.de>
49 *
50 */
51
52 #include "lwip/opt.h"
53 #include "sockets_stresstest.h"
54
55 #include "lwip/sockets.h"
56 #include "lwip/sys.h"
57
58 #include "lwip/mem.h"
59
60 #include <stdio.h>
61 #include <string.h>
62
63 #if LWIP_SOCKET && LWIP_IPV4 /* this uses IPv4 loopback sockets, currently */
64
65 #ifndef TEST_SOCKETS_STRESS
66 #define TEST_SOCKETS_STRESS LWIP_DBG_OFF
67 #endif
68
69 #define TEST_TIME_SECONDS 10
70 #define TEST_TXRX_BUFSIZE (TCP_MSS * 2)
71 #define TEST_MAX_RXWAIT_MS 50
72 #define TEST_MAX_CONNECTIONS 50
73
74 #define TEST_SOCK_READABLE 0x01
75 #define TEST_SOCK_WRITABLE 0x02
76 #define TEST_SOCK_ERR 0x04
77
78 #define TEST_MODE_SELECT 0x01
79 #define TEST_MODE_POLL 0x02
80 #define TEST_MODE_NONBLOCKING 0x04
81 #define TEST_MODE_WAIT 0x08
82 #define TEST_MODE_RECVTIMEO 0x10
83 #define TEST_MODE_SLEEP 0x20
84
85 static int sockets_stresstest_numthreads;
86
87 struct test_settings {
88 struct sockaddr_storage addr;
89 int start_client;
90 int loop_cnt;
91 };
92
93 struct sockets_stresstest_fullduplex {
94 int s;
95 volatile int closed;
96 };
97
98 static void
fill_test_data(void * buf,size_t buf_len_bytes)99 fill_test_data(void *buf, size_t buf_len_bytes)
100 {
101 u8_t *p = (u8_t*)buf;
102 u16_t i, chk;
103
104 LWIP_ASSERT("buffer too short", buf_len_bytes >= 4);
105 LWIP_ASSERT("buffer too big", buf_len_bytes <= 0xFFFF);
106 /* store the total number of bytes */
107 p[0] = (u8_t)(buf_len_bytes >> 8);
108 p[1] = (u8_t)buf_len_bytes;
109
110 /* fill buffer with random */
111 chk = 0;
112 for (i = 4; i < buf_len_bytes; i++) {
113 u8_t rnd = (u8_t)LWIP_RAND();
114 p[i] = rnd;
115 chk += rnd;
116 }
117 /* store checksum */
118 p[2] = (u8_t)(chk >> 8);
119 p[3] = (u8_t)chk;
120 }
121
122 static size_t
check_test_data(const void * buf,size_t buf_len_bytes)123 check_test_data(const void *buf, size_t buf_len_bytes)
124 {
125 u8_t *p = (u8_t*)buf;
126 u16_t i, chk, chk_rx, len_rx;
127
128 LWIP_ASSERT("buffer too short", buf_len_bytes >= 4);
129 len_rx = (((u16_t)p[0]) << 8) | p[1];
130 LWIP_ASSERT("len too short", len_rx >= 4);
131 if (len_rx > buf_len_bytes) {
132 /* not all data received in this segment */
133 LWIP_DEBUGF(TEST_SOCKETS_STRESS | LWIP_DBG_TRACE, ("check-\n"));
134 return buf_len_bytes;
135 }
136 chk_rx = (((u16_t)p[2]) << 8) | p[3];
137 /* calculate received checksum */
138 chk = 0;
139 for (i = 4; i < len_rx; i++) {
140 chk += p[i];
141 }
142 LWIP_ASSERT("invalid checksum", chk == chk_rx);
143 if (len_rx < buf_len_bytes) {
144 size_t data_left = buf_len_bytes - len_rx;
145 memmove(p, &p[len_rx], data_left);
146 return data_left;
147 }
148 /* if we come here, we received exactly one chunk
149 -> next offset is 0 */
150 return 0;
151 }
152
153 static size_t
recv_and_check_data_return_offset(int s,char * rxbuf,size_t rxbufsize,size_t rxoff,int * closed,const char * dbg)154 recv_and_check_data_return_offset(int s, char *rxbuf, size_t rxbufsize, size_t rxoff, int *closed, const char *dbg)
155 {
156 ssize_t ret;
157
158 ret = lwip_read(s, &rxbuf[rxoff], rxbufsize - rxoff);
159 if (ret == 0) {
160 *closed = 1;
161 return rxoff;
162 }
163 *closed = 0;
164 LWIP_DEBUGF(TEST_SOCKETS_STRESS | LWIP_DBG_TRACE, ("%s %d rx %d\n", dbg, s, (int)ret));
165 if (ret == -1) {
166 /* TODO: for this to work, 'errno' has to support multithreading... */
167 int err = errno;
168 if (err == ENOTCONN) {
169 *closed = 1;
170 return 0;
171 }
172 LWIP_ASSERT("err == 0", err == 0);
173 }
174 LWIP_ASSERT("ret > 0", ret > 0);
175 return check_test_data(rxbuf, rxoff + ret);
176 }
177
178 #if LWIP_SOCKET_SELECT
179 static int
sockets_stresstest_wait_readable_select(int s,int timeout_ms)180 sockets_stresstest_wait_readable_select(int s, int timeout_ms)
181 {
182 int ret;
183 struct timeval tv;
184 fd_set fs_r;
185 fd_set fs_w;
186 fd_set fs_e;
187
188 FD_ZERO(&fs_r);
189 FD_ZERO(&fs_w);
190 FD_ZERO(&fs_e);
191
192 FD_SET(s, &fs_r);
193 FD_SET(s, &fs_e);
194
195 tv.tv_sec = timeout_ms / 1000;
196 tv.tv_usec = (timeout_ms - (tv.tv_sec * 1000)) * 1000;
197 ret = lwip_select(s + 1, &fs_r, &fs_w, &fs_e, &tv);
198 LWIP_ASSERT("select error", ret >= 0);
199 if (ret) {
200 /* convert poll flags to our flags */
201 ret = 0;
202 if (FD_ISSET(s, &fs_r)) {
203 ret |= TEST_SOCK_READABLE;
204 }
205 if (FD_ISSET(s, &fs_w)) {
206 ret |= TEST_SOCK_WRITABLE;
207 }
208 if (FD_ISSET(s, &fs_e)) {
209 ret |= TEST_SOCK_ERR;
210 }
211 return ret;
212 }
213 return 0;
214 }
215 #endif
216
217 #if LWIP_SOCKET_POLL
218 static int
sockets_stresstest_wait_readable_poll(int s,int timeout_ms)219 sockets_stresstest_wait_readable_poll(int s, int timeout_ms)
220 {
221 int ret;
222 struct pollfd pfd;
223
224 pfd.fd = s;
225 pfd.revents = 0;
226 pfd.events = POLLIN | POLLERR;
227
228 ret = lwip_poll(&pfd, 1, timeout_ms);
229 if (ret) {
230 /* convert poll flags to our flags */
231 ret = 0;
232 if (pfd.revents & POLLIN) {
233 ret |= TEST_SOCK_READABLE;
234 }
235 if (pfd.revents & POLLOUT) {
236 ret |= TEST_SOCK_WRITABLE;
237 }
238 if (pfd.revents & POLLERR) {
239 ret |= TEST_SOCK_ERR;
240 }
241 return ret;
242 }
243 return 0;
244 }
245 #endif
246
247 #if LWIP_SO_RCVTIMEO
248 static int
sockets_stresstest_wait_readable_recvtimeo(int s,int timeout_ms)249 sockets_stresstest_wait_readable_recvtimeo(int s, int timeout_ms)
250 {
251 int ret;
252 char buf;
253 #if LWIP_SO_SNDRCVTIMEO_NONSTANDARD
254 int opt_on = timeout_ms;
255 int opt_off = 0;
256 #else
257 struct timeval opt_on, opt_off;
258 opt_on.tv_sec = timeout_ms / 1000;
259 opt_on.tv_usec = (timeout_ms - (opt_on.tv_sec * 1000)) * 1000;
260 opt_off.tv_sec = 0;
261 opt_off.tv_usec = 0;
262 #endif
263
264 /* enable receive timeout */
265 ret = lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &opt_on, sizeof(opt_on));
266 LWIP_ASSERT("setsockopt error", ret == 0);
267
268 /* peek for one byte with timeout */
269 ret = lwip_recv(s, &buf, 1, MSG_PEEK);
270
271 /* disable receive timeout */
272 ret = lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &opt_off, sizeof(opt_off));
273 LWIP_ASSERT("setsockopt error", ret == 0);
274
275 if (ret == 1) {
276 return TEST_SOCK_READABLE;
277 }
278 if (ret == 0) {
279 return 0;
280 }
281 if (ret == -1) {
282 return TEST_SOCK_ERR;
283 }
284 LWIP_ASSERT("invalid return value", 0);
285 return TEST_SOCK_ERR;
286 }
287 #endif
288
289 static int
sockets_stresstest_wait_readable_wait_peek(int s,int timeout_ms)290 sockets_stresstest_wait_readable_wait_peek(int s, int timeout_ms)
291 {
292 int ret;
293 char buf;
294
295 LWIP_UNUSED_ARG(timeout_ms); /* cannot time out here */
296
297 /* peek for one byte */
298 ret = lwip_recv(s, &buf, 1, MSG_PEEK);
299
300 if (ret == 1) {
301 return TEST_SOCK_READABLE;
302 }
303 if (ret == 0) {
304 return 0;
305 }
306 if (ret == -1) {
307 return TEST_SOCK_ERR;
308 }
309 LWIP_ASSERT("invalid return value", 0);
310 return TEST_SOCK_ERR;
311 }
312
313 static int
sockets_stresstest_wait_readable_nonblock(int s,int timeout_ms)314 sockets_stresstest_wait_readable_nonblock(int s, int timeout_ms)
315 {
316 int ret;
317 char buf;
318 u32_t wait_until = sys_now() + timeout_ms;
319
320 while(sys_now() < wait_until) {
321 /* peek for one byte */
322 ret = lwip_recv(s, &buf, 1, MSG_PEEK | MSG_DONTWAIT);
323
324 if (ret == 1) {
325 return TEST_SOCK_READABLE;
326 }
327 if (ret == -1) {
328 /* TODO: for this to work, 'errno' has to support multithreading... */
329 int err = errno;
330 if (err != EWOULDBLOCK) {
331 return TEST_SOCK_ERR;
332 }
333 }
334 /* TODO: sleep? */
335 }
336 return 0;
337 }
338
sockets_stresstest_rand_mode(int allow_wait,int allow_rx)339 static int sockets_stresstest_rand_mode(int allow_wait, int allow_rx)
340 {
341 u32_t random_value = LWIP_RAND();
342 #if LWIP_SOCKET_SELECT
343 if (random_value & TEST_MODE_SELECT) {
344 return TEST_MODE_SELECT;
345 }
346 #endif
347 #if LWIP_SOCKET_POLL
348 if (random_value & TEST_MODE_POLL) {
349 return TEST_MODE_POLL;
350 }
351 #endif
352 if (!allow_rx) {
353 return TEST_MODE_SLEEP;
354 }
355 #if LWIP_SO_RCVTIMEO
356 if (random_value & TEST_MODE_RECVTIMEO) {
357 return TEST_MODE_RECVTIMEO;
358 }
359 #endif
360 if (allow_wait) {
361 if (random_value & TEST_MODE_RECVTIMEO) {
362 return TEST_MODE_RECVTIMEO;
363 }
364 }
365 return TEST_MODE_NONBLOCKING;
366 }
367
368 static int
sockets_stresstest_wait_readable(int mode,int s,int timeout_ms)369 sockets_stresstest_wait_readable(int mode, int s, int timeout_ms)
370 {
371 switch(mode)
372 {
373 #if LWIP_SOCKET_SELECT
374 case TEST_MODE_SELECT:
375 return sockets_stresstest_wait_readable_select(s, timeout_ms);
376 #endif
377 #if LWIP_SOCKET_POLL
378 case TEST_MODE_POLL:
379 return sockets_stresstest_wait_readable_poll(s, timeout_ms);
380 #endif
381 #if LWIP_SO_RCVTIMEO
382 case TEST_MODE_RECVTIMEO:
383 return sockets_stresstest_wait_readable_recvtimeo(s, timeout_ms);
384 #endif
385 case TEST_MODE_WAIT:
386 return sockets_stresstest_wait_readable_wait_peek(s, timeout_ms);
387 case TEST_MODE_NONBLOCKING:
388 return sockets_stresstest_wait_readable_nonblock(s, timeout_ms);
389 case TEST_MODE_SLEEP:
390 {
391 sys_msleep(timeout_ms);
392 return 1;
393 }
394 default:
395 LWIP_ASSERT("invalid mode", 0);
396 break;
397 }
398 return 0;
399 }
400
401 #if LWIP_NETCONN_FULLDUPLEX
402 static void
sockets_stresstest_conn_client_r(void * arg)403 sockets_stresstest_conn_client_r(void *arg)
404 {
405 struct sockets_stresstest_fullduplex *fd = (struct sockets_stresstest_fullduplex *)arg;
406 int s = fd->s;
407 size_t rxoff = 0;
408 char rxbuf[TEST_TXRX_BUFSIZE];
409
410 while (1) {
411 int closed;
412 if (fd->closed) {
413 break;
414 }
415 rxoff = recv_and_check_data_return_offset(s, rxbuf, sizeof(rxbuf), rxoff, &closed, "cli");
416 if (fd->closed) {
417 break;
418 }
419 if (closed) {
420 lwip_close(s);
421 break;
422 }
423 }
424
425 SYS_ARCH_DEC(sockets_stresstest_numthreads, 1);
426 LWIP_ASSERT("", sockets_stresstest_numthreads >= 0);
427 }
428 #endif
429
430 static void
sockets_stresstest_conn_client(void * arg)431 sockets_stresstest_conn_client(void *arg)
432 {
433 struct sockaddr_storage addr;
434 struct sockaddr_in *addr_in;
435 int s, ret;
436 char txbuf[TEST_TXRX_BUFSIZE];
437 char rxbuf[TEST_TXRX_BUFSIZE];
438 size_t rxoff = 0;
439 u32_t max_time = sys_now() + (TEST_TIME_SECONDS * 1000);
440 int do_rx = 1;
441 struct sockets_stresstest_fullduplex *data = NULL;
442
443 memcpy(&addr, arg, sizeof(addr));
444 LWIP_ASSERT("", addr.ss_family == AF_INET);
445 addr_in = (struct sockaddr_in *)&addr;
446 addr_in->sin_addr.s_addr = inet_addr("127.0.0.1");
447
448 /* sleep a random time between 1 and 2 seconds */
449 sys_msleep(1000 + (LWIP_RAND() % 1000));
450
451 /* connect to the server */
452 s = lwip_socket(addr.ss_family, SOCK_STREAM, 0);
453 LWIP_ASSERT("s >= 0", s >= 0);
454
455 #if LWIP_NETCONN_FULLDUPLEX
456 if (LWIP_RAND() & 1) {
457 sys_thread_t t;
458 data = (struct sockets_stresstest_fullduplex*)mem_malloc(sizeof(struct sockets_stresstest_fullduplex));
459 LWIP_ASSERT("data != NULL", data != 0);
460 SYS_ARCH_INC(sockets_stresstest_numthreads, 1);
461 data->s = s;
462 data->closed = 0;
463 t = sys_thread_new("sockets_stresstest_conn_client_r", sockets_stresstest_conn_client_r, data, 0, 0);
464 LWIP_ASSERT("thread != NULL", t != 0);
465 do_rx = 0;
466 }
467 #endif
468
469 /* @todo: nonblocking connect? */
470 ret = lwip_connect(s, (struct sockaddr *)&addr, sizeof(struct sockaddr_storage));
471 LWIP_ASSERT("ret == 0", ret == 0);
472
473 while (sys_now() < max_time) {
474 int closed;
475 int mode = sockets_stresstest_rand_mode(0, do_rx);
476 int timeout_ms = LWIP_RAND() % TEST_MAX_RXWAIT_MS;
477 ret = sockets_stresstest_wait_readable(mode, s, timeout_ms);
478 if (ret) {
479 if (do_rx) {
480 /* read some */
481 LWIP_ASSERT("readable", ret == TEST_SOCK_READABLE);
482 rxoff = recv_and_check_data_return_offset(s, rxbuf, sizeof(rxbuf), rxoff, &closed, "cli");
483 LWIP_ASSERT("client got closed", !closed);
484 }
485 } else {
486 /* timeout, send some */
487 size_t send_len = (LWIP_RAND() % (sizeof(txbuf) - 4)) + 4;
488 fill_test_data(txbuf, send_len);
489 LWIP_DEBUGF(TEST_SOCKETS_STRESS | LWIP_DBG_TRACE, ("cli %d tx %d\n", s, (int)send_len));
490 ret = lwip_write(s, txbuf, send_len);
491 if (ret == -1) {
492 /* TODO: for this to work, 'errno' has to support multithreading... */
493 int err = errno;
494 LWIP_ASSERT("err == 0", err == 0);
495 }
496 LWIP_ASSERT("ret == send_len", ret == (int)send_len);
497 }
498 }
499 if (data) {
500 data->closed = 1;
501 }
502 ret = lwip_close(s);
503 LWIP_ASSERT("ret == 0", ret == 0);
504
505 SYS_ARCH_DEC(sockets_stresstest_numthreads, 1);
506 LWIP_ASSERT("", sockets_stresstest_numthreads >= 0);
507 }
508
509 static void
sockets_stresstest_conn_server(void * arg)510 sockets_stresstest_conn_server(void *arg)
511 {
512 int s, ret;
513 char txbuf[TEST_TXRX_BUFSIZE];
514 char rxbuf[TEST_TXRX_BUFSIZE];
515 size_t rxoff = 0;
516
517 s = (int)arg;
518
519 while (1) {
520 int closed;
521 int mode = sockets_stresstest_rand_mode(1, 1);
522 int timeout_ms = LWIP_RAND() % TEST_MAX_RXWAIT_MS;
523 ret = sockets_stresstest_wait_readable(mode, s, timeout_ms);
524 if (ret) {
525 if (ret & TEST_SOCK_ERR) {
526 /* closed? */
527 break;
528 }
529 /* read some */
530 LWIP_ASSERT("readable", ret == TEST_SOCK_READABLE);
531 rxoff = recv_and_check_data_return_offset(s, rxbuf, sizeof(rxbuf), rxoff, &closed, "srv");
532 if (closed) {
533 break;
534 }
535 } else {
536 /* timeout, send some */
537 size_t send_len = (LWIP_RAND() % (sizeof(txbuf) - 4)) + 4;
538 fill_test_data(txbuf, send_len);
539 LWIP_DEBUGF(TEST_SOCKETS_STRESS | LWIP_DBG_TRACE, ("srv %d tx %d\n", s, (int)send_len));
540 ret = lwip_write(s, txbuf, send_len);
541 if (ret == -1) {
542 /* TODO: for this to work, 'errno' has to support multithreading... */
543 int err = errno;
544 if (err == ECONNRESET) {
545 break;
546 }
547 if (err == ENOTCONN) {
548 break;
549 }
550 LWIP_ASSERT("unknown error", 0);
551 }
552 LWIP_ASSERT("ret == send_len", ret == (int)send_len);
553 }
554 }
555 ret = lwip_close(s);
556 LWIP_ASSERT("ret == 0", ret == 0);
557
558 SYS_ARCH_DEC(sockets_stresstest_numthreads, 1);
559 LWIP_ASSERT("", sockets_stresstest_numthreads >= 0);
560 }
561
562 static int
sockets_stresstest_start_clients(const struct sockaddr_storage * remote_addr)563 sockets_stresstest_start_clients(const struct sockaddr_storage *remote_addr)
564 {
565 /* limit the number of connections */
566 const int max_connections = LWIP_MIN(TEST_MAX_CONNECTIONS, MEMP_NUM_TCP_PCB/3);
567 int i;
568
569 for (i = 0; i < max_connections; i++) {
570 sys_thread_t t;
571 SYS_ARCH_INC(sockets_stresstest_numthreads, 1);
572 t = sys_thread_new("sockets_stresstest_conn_client", sockets_stresstest_conn_client, (void*)remote_addr, 0, 0);
573 LWIP_ASSERT("thread != NULL", t != 0);
574 }
575 return max_connections;
576 }
577
578 static void
sockets_stresstest_listener(void * arg)579 sockets_stresstest_listener(void *arg)
580 {
581 int slisten;
582 int ret;
583 struct sockaddr_storage addr;
584 socklen_t addr_len;
585 struct test_settings *settings = (struct test_settings *)arg;
586 int num_clients, num_servers = 0;
587
588 slisten = lwip_socket(AF_INET, SOCK_STREAM, 0);
589 LWIP_ASSERT("slisten >= 0", slisten >= 0);
590
591 memcpy(&addr, &settings->addr, sizeof(struct sockaddr_storage));
592 ret = lwip_bind(slisten, (struct sockaddr *)&addr, sizeof(addr));
593 LWIP_ASSERT("ret == 0", ret == 0);
594
595 ret = lwip_listen(slisten, 0);
596 LWIP_ASSERT("ret == 0", ret == 0);
597
598 addr_len = sizeof(addr);
599 ret = lwip_getsockname(slisten, (struct sockaddr *)&addr, &addr_len);
600 LWIP_ASSERT("ret == 0", ret == 0);
601
602 num_clients = sockets_stresstest_start_clients(&addr);
603
604 while (num_servers < num_clients) {
605 struct sockaddr_storage aclient;
606 socklen_t aclient_len = sizeof(aclient);
607 int sclient = lwip_accept(slisten, (struct sockaddr *)&aclient, &aclient_len);
608 #if 1
609 /* using server threads */
610 {
611 sys_thread_t t;
612 SYS_ARCH_INC(sockets_stresstest_numthreads, 1);
613 num_servers++;
614 t = sys_thread_new("sockets_stresstest_conn_server", sockets_stresstest_conn_server, (void*)sclient, 0, 0);
615 LWIP_ASSERT("thread != NULL", t != 0);
616 }
617 #else
618 /* using server select */
619 #endif
620 }
621 LWIP_DEBUGF(TEST_SOCKETS_STRESS | LWIP_DBG_STATE, ("sockets_stresstest_listener: all %d connections established\n", num_clients));
622
623 /* accepted all clients */
624 while (sockets_stresstest_numthreads > 0) {
625 sys_msleep(1);
626 }
627
628 ret = lwip_close(slisten);
629 LWIP_ASSERT("ret == 0", ret == 0);
630
631 LWIP_DEBUGF(TEST_SOCKETS_STRESS |LWIP_DBG_STATE, ("sockets_stresstest_listener: done\n"));
632 }
633
634 static void
sockets_stresstest_listener_loop(void * arg)635 sockets_stresstest_listener_loop(void *arg)
636 {
637 int i;
638 struct test_settings *settings = (struct test_settings *)arg;
639
640 if (settings->loop_cnt) {
641 for (i = 0; i < settings->loop_cnt; i++) {
642 LWIP_DEBUGF(TEST_SOCKETS_STRESS |LWIP_DBG_STATE, ("sockets_stresstest_listener_loop: iteration %d\n", i));
643 sockets_stresstest_listener(arg);
644 sys_msleep(2);
645 }
646 LWIP_DEBUGF(TEST_SOCKETS_STRESS |LWIP_DBG_STATE, ("sockets_stresstest_listener_loop: done\n"));
647 } else {
648 for (i = 0; ; i++) {
649 LWIP_DEBUGF(TEST_SOCKETS_STRESS |LWIP_DBG_STATE, ("sockets_stresstest_listener_loop: iteration %d\n", i));
650 sockets_stresstest_listener(arg);
651 sys_msleep(2);
652 }
653 }
654 }
655
656 void
sockets_stresstest_init_loopback(int addr_family)657 sockets_stresstest_init_loopback(int addr_family)
658 {
659 sys_thread_t t;
660 struct test_settings *settings = (struct test_settings *)mem_malloc(sizeof(struct test_settings));
661
662 LWIP_ASSERT("OOM", settings != NULL);
663 memset(settings, 0, sizeof(struct test_settings));
664 #if LWIP_IPV4 && LWIP_IPV6
665 LWIP_ASSERT("invalid addr_family", (addr_family == AF_INET) || (addr_family == AF_INET6));
666 #endif
667 settings->addr.ss_family = (sa_family_t)addr_family;
668 LWIP_UNUSED_ARG(addr_family);
669 settings->start_client = 1;
670
671 t = sys_thread_new("sockets_stresstest_listener_loop", sockets_stresstest_listener_loop, settings, 0, 0);
672 LWIP_ASSERT("thread != NULL", t != 0);
673 }
674
675 void
sockets_stresstest_init_server(int addr_family,u16_t server_port)676 sockets_stresstest_init_server(int addr_family, u16_t server_port)
677 {
678 sys_thread_t t;
679 struct test_settings *settings = (struct test_settings *)mem_malloc(sizeof(struct test_settings));
680
681 LWIP_ASSERT("OOM", settings != NULL);
682 memset(settings, 0, sizeof(struct test_settings));
683 #if LWIP_IPV4 && LWIP_IPV6
684 LWIP_ASSERT("invalid addr_family", (addr_family == AF_INET) || (addr_family == AF_INET6));
685 settings->addr.ss_family = (sa_family_t)addr_family;
686 #endif
687 LWIP_UNUSED_ARG(addr_family);
688 ((struct sockaddr_in *)(&settings->addr))->sin_port = server_port;
689
690 t = sys_thread_new("sockets_stresstest_listener", sockets_stresstest_listener, settings, 0, 0);
691 LWIP_ASSERT("thread != NULL", t != 0);
692 }
693
694 void
sockets_stresstest_init_client(const char * remote_ip,u16_t remote_port)695 sockets_stresstest_init_client(const char *remote_ip, u16_t remote_port)
696 {
697 #if LWIP_IPV4
698 ip4_addr_t ip4;
699 #endif
700 #if LWIP_IPV6
701 ip6_addr_t ip6;
702 #endif
703 struct sockaddr_storage *addr = (struct sockaddr_storage *)mem_malloc(sizeof(struct sockaddr_storage));
704
705 LWIP_ASSERT("OOM", addr != NULL);
706 memset(addr, 0, sizeof(struct test_settings));
707 #if LWIP_IPV4
708 if (ip4addr_aton(remote_ip, &ip4)) {
709 addr->ss_family = AF_INET;
710 ((struct sockaddr_in *)addr)->sin_addr.s_addr = ip4_addr_get_u32(&ip4);
711 }
712 #endif
713 #if LWIP_IPV4 && LWIP_IPV6
714 else
715 #endif
716 #if LWIP_IPV6
717 if (ip6addr_aton(remote_ip, &ip6)) {
718 addr->ss_family = AF_INET6;
719 /* todo: copy ipv6 address */
720 }
721 #endif
722 ((struct sockaddr_in *)addr)->sin_port = remote_port;
723 sockets_stresstest_start_clients(addr);
724 }
725
726 #endif /* LWIP_SOCKET && LWIP_IPV4 */
727