1 #include "test_tcp.h"
2
3 #include "lwip/priv/tcp_priv.h"
4 #include "lwip/stats.h"
5 #include "lwip/inet.h"
6 #include "tcp_helper.h"
7 #include "lwip/inet_chksum.h"
8
9 #ifdef _MSC_VER
10 #pragma warning(disable: 4307) /* we explicitly wrap around TCP seqnos */
11 #endif
12
13 #if !LWIP_STATS || !TCP_STATS || !MEMP_STATS
14 #error "This tests needs TCP- and MEMP-statistics enabled"
15 #endif
16 #if TCP_SND_BUF <= TCP_WND
17 #error "This tests needs TCP_SND_BUF to be > TCP_WND"
18 #endif
19
20 /* used with check_seqnos() */
21 #define SEQNO1 (0xFFFFFF00 - TCP_MSS)
22 #define ISS 6510
23 static u32_t seqnos[] = {
24 SEQNO1,
25 SEQNO1 + (1 * TCP_MSS),
26 SEQNO1 + (2 * TCP_MSS),
27 SEQNO1 + (3 * TCP_MSS),
28 SEQNO1 + (4 * TCP_MSS),
29 SEQNO1 + (5 * TCP_MSS) };
30
31 static u8_t test_tcp_timer;
32
33 /* our own version of tcp_tmr so we can reset fast/slow timer state */
34 static void
test_tcp_tmr(void)35 test_tcp_tmr(void)
36 {
37 tcp_fasttmr();
38 if (++test_tcp_timer & 1) {
39 tcp_slowtmr();
40 }
41 }
42
43 /* Setups/teardown functions */
44 static struct netif *old_netif_list;
45 static struct netif *old_netif_default;
46
47 static void
tcp_setup(void)48 tcp_setup(void)
49 {
50 struct tcp_pcb dummy_pcb; /* we need this for tcp_next_iss() only */
51
52 old_netif_list = netif_list;
53 old_netif_default = netif_default;
54 netif_list = NULL;
55 netif_default = NULL;
56 /* reset iss to default (6510) */
57 tcp_ticks = 0;
58 tcp_ticks = 0 - (tcp_next_iss(&dummy_pcb) - 6510);
59 tcp_next_iss(&dummy_pcb);
60 tcp_ticks = 0;
61
62 test_tcp_timer = 0;
63 tcp_remove_all();
64 lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
65 }
66
67 static void
tcp_teardown(void)68 tcp_teardown(void)
69 {
70 netif_list = NULL;
71 netif_default = NULL;
72 tcp_remove_all();
73 /* restore netif_list for next tests (e.g. loopif) */
74 netif_list = old_netif_list;
75 netif_default = old_netif_default;
76 lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
77 }
78
79
80 /* Test functions */
81
82 /** Call tcp_new() and tcp_abort() and test memp stats */
START_TEST(test_tcp_new_abort)83 START_TEST(test_tcp_new_abort)
84 {
85 struct tcp_pcb* pcb;
86 LWIP_UNUSED_ARG(_i);
87
88 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
89
90 pcb = tcp_new();
91 fail_unless(pcb != NULL);
92 if (pcb != NULL) {
93 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
94 tcp_abort(pcb);
95 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
96 }
97 }
98 END_TEST
99
100 /** Call tcp_new() and tcp_abort() and test memp stats */
START_TEST(test_tcp_listen_passive_open)101 START_TEST(test_tcp_listen_passive_open)
102 {
103 struct tcp_pcb *pcb, *pcbl;
104 struct tcp_pcb_listen *lpcb;
105 struct netif netif;
106 struct test_tcp_txcounters txcounters;
107 struct test_tcp_counters counters;
108 struct pbuf *p;
109 ip_addr_t src_addr;
110 err_t err;
111 LWIP_UNUSED_ARG(_i);
112
113 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
114
115 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
116 /* initialize counter struct */
117 memset(&counters, 0, sizeof(counters));
118
119 pcb = tcp_new();
120 EXPECT_RET(pcb != NULL);
121 err = tcp_bind(pcb, &netif.ip_addr, 1234);
122 EXPECT(err == ERR_OK);
123 pcbl = tcp_listen(pcb);
124 EXPECT_RET(pcbl != NULL);
125 EXPECT_RET(pcbl != pcb);
126 lpcb = (struct tcp_pcb_listen *)pcbl;
127
128 ip_addr_set_ip4_u32_val(src_addr, lwip_htonl(lwip_ntohl(ip_addr_get_ip4_u32(&lpcb->local_ip)) + 1));
129
130 /* check correct syn packet */
131 p = tcp_create_segment(&src_addr, &lpcb->local_ip, 12345,
132 lpcb->local_port, NULL, 0, 12345, 54321, TCP_SYN);
133 EXPECT(p != NULL);
134 if (p != NULL) {
135 /* pass the segment to tcp_input */
136 test_tcp_input(p, &netif);
137 /* check if counters are as expected */
138 EXPECT(txcounters.num_tx_calls == 1);
139 }
140
141 /* check syn packet with short length */
142 p = tcp_create_segment(&src_addr, &lpcb->local_ip, 12345,
143 lpcb->local_port, NULL, 0, 12345, 54321, TCP_SYN);
144 EXPECT(p != NULL);
145 EXPECT(p->next == NULL);
146 if ((p != NULL) && (p->next == NULL)) {
147 p->len -= 2;
148 p->tot_len -= 2;
149 /* pass the segment to tcp_input */
150 test_tcp_input(p, &netif);
151 /* check if counters are as expected */
152 EXPECT(txcounters.num_tx_calls == 1);
153 }
154
155 tcp_close(pcbl);
156 }
157 END_TEST
158
159 /** Create an ESTABLISHED pcb and check if receive callback is called */
START_TEST(test_tcp_recv_inseq)160 START_TEST(test_tcp_recv_inseq)
161 {
162 struct test_tcp_counters counters;
163 struct tcp_pcb* pcb;
164 struct pbuf* p;
165 char data[] = {1, 2, 3, 4};
166 u16_t data_len;
167 struct netif netif;
168 struct test_tcp_txcounters txcounters;
169 LWIP_UNUSED_ARG(_i);
170
171 /* initialize local vars */
172 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
173 data_len = sizeof(data);
174 /* initialize counter struct */
175 memset(&counters, 0, sizeof(counters));
176 counters.expected_data_len = data_len;
177 counters.expected_data = data;
178
179 /* create and initialize the pcb */
180 pcb = test_tcp_new_counters_pcb(&counters);
181 EXPECT_RET(pcb != NULL);
182 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
183
184 /* create a segment */
185 p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
186 EXPECT(p != NULL);
187 if (p != NULL) {
188 /* pass the segment to tcp_input */
189 test_tcp_input(p, &netif);
190 /* check if counters are as expected */
191 EXPECT(counters.close_calls == 0);
192 EXPECT(counters.recv_calls == 1);
193 EXPECT(counters.recved_bytes == data_len);
194 EXPECT(counters.err_calls == 0);
195 }
196
197 /* make sure the pcb is freed */
198 EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
199 tcp_abort(pcb);
200 EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
201 }
202 END_TEST
203
204 /** Create an ESTABLISHED pcb and check if receive callback is called if a segment
205 * overlapping rcv_nxt is received */
START_TEST(test_tcp_recv_inseq_trim)206 START_TEST(test_tcp_recv_inseq_trim)
207 {
208 struct test_tcp_counters counters;
209 struct tcp_pcb* pcb;
210 struct pbuf* p;
211 char data[PBUF_POOL_BUFSIZE*2];
212 u16_t data_len;
213 struct netif netif;
214 struct test_tcp_txcounters txcounters;
215 const u32_t new_data_len = 40;
216 LWIP_UNUSED_ARG(_i);
217
218 /* initialize local vars */
219 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
220 data_len = sizeof(data);
221 memset(data, 0, sizeof(data));
222 /* initialize counter struct */
223 memset(&counters, 0, sizeof(counters));
224 counters.expected_data_len = data_len;
225 counters.expected_data = data;
226
227 /* create and initialize the pcb */
228 pcb = test_tcp_new_counters_pcb(&counters);
229 EXPECT_RET(pcb != NULL);
230 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
231
232 /* create a segment (with an overlapping/old seqno so that the new data begins in the 2nd pbuf) */
233 p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, (u32_t)(0-(data_len-new_data_len)), 0, 0);
234 EXPECT(p != NULL);
235 if (p != NULL) {
236 EXPECT(p->next != NULL);
237 if (p->next != NULL) {
238 EXPECT(p->next->next != NULL);
239 }
240 }
241 if ((p != NULL) && (p->next != NULL) && (p->next->next != NULL)) {
242 /* pass the segment to tcp_input */
243 test_tcp_input(p, &netif);
244 /* check if counters are as expected */
245 EXPECT(counters.close_calls == 0);
246 EXPECT(counters.recv_calls == 1);
247 EXPECT(counters.recved_bytes == new_data_len);
248 EXPECT(counters.err_calls == 0);
249 }
250
251 /* make sure the pcb is freed */
252 EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
253 tcp_abort(pcb);
254 EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
255 }
256 END_TEST
257
258 static err_t test_tcp_recv_expect1byte(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err);
259
260 static err_t
test_tcp_recv_expectclose(void * arg,struct tcp_pcb * pcb,struct pbuf * p,err_t err)261 test_tcp_recv_expectclose(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
262 {
263 EXPECT_RETX(pcb != NULL, ERR_OK);
264 EXPECT_RETX(err == ERR_OK, ERR_OK);
265 LWIP_UNUSED_ARG(arg);
266
267 if (p != NULL) {
268 fail();
269 } else {
270 /* correct: FIN received; close our end, too */
271 err_t err2 = tcp_close(pcb);
272 fail_unless(err2 == ERR_OK);
273 /* set back to some other rx function, just to not get here again */
274 tcp_recv(pcb, test_tcp_recv_expect1byte);
275 }
276 return ERR_OK;
277 }
278
279 static err_t
test_tcp_recv_expect1byte(void * arg,struct tcp_pcb * pcb,struct pbuf * p,err_t err)280 test_tcp_recv_expect1byte(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
281 {
282 EXPECT_RETX(pcb != NULL, ERR_OK);
283 EXPECT_RETX(err == ERR_OK, ERR_OK);
284 LWIP_UNUSED_ARG(arg);
285
286 if (p != NULL) {
287 if ((p->len == 1) && (p->tot_len == 1)) {
288 tcp_recv(pcb, test_tcp_recv_expectclose);
289 } else {
290 fail();
291 }
292 pbuf_free(p);
293 } else {
294 fail();
295 }
296 return ERR_OK;
297 }
298
START_TEST(test_tcp_passive_close)299 START_TEST(test_tcp_passive_close)
300 {
301 struct test_tcp_counters counters;
302 struct tcp_pcb* pcb;
303 struct pbuf* p;
304 char data = 0x0f;
305 struct netif netif;
306 struct test_tcp_txcounters txcounters;
307 LWIP_UNUSED_ARG(_i);
308
309 /* initialize local vars */
310 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
311
312 /* initialize counter struct */
313 memset(&counters, 0, sizeof(counters));
314 counters.expected_data_len = 1;
315 counters.expected_data = &data;
316
317 /* create and initialize the pcb */
318 pcb = test_tcp_new_counters_pcb(&counters);
319 EXPECT_RET(pcb != NULL);
320 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
321
322 /* create a segment without data */
323 p = tcp_create_rx_segment(pcb, &data, 1, 0, 0, TCP_FIN);
324 EXPECT(p != NULL);
325 if (p != NULL) {
326 tcp_recv(pcb, test_tcp_recv_expect1byte);
327 /* pass the segment to tcp_input */
328 test_tcp_input(p, &netif);
329 }
330 /* don't free the pcb here (part of the test!) */
331 }
332 END_TEST
333
START_TEST(test_tcp_active_abort)334 START_TEST(test_tcp_active_abort)
335 {
336 struct test_tcp_counters counters;
337 struct tcp_pcb* pcb;
338 char data = 0x0f;
339 struct netif netif;
340 struct test_tcp_txcounters txcounters;
341 LWIP_UNUSED_ARG(_i);
342
343 memset(&txcounters, 0, sizeof(txcounters));
344
345 /* initialize local vars */
346 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
347
348 /* initialize counter struct */
349 memset(&counters, 0, sizeof(counters));
350 counters.expected_data_len = 1;
351 counters.expected_data = &data;
352
353 /* create and initialize the pcb */
354 pcb = test_tcp_new_counters_pcb(&counters);
355 EXPECT_RET(pcb != NULL);
356 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
357
358 /* abort the pcb */
359 EXPECT_RET(txcounters.num_tx_calls == 0);
360 txcounters.copy_tx_packets = 1;
361 tcp_abort(pcb);
362 txcounters.copy_tx_packets = 0;
363 EXPECT(txcounters.num_tx_calls == 1);
364 EXPECT(txcounters.num_tx_bytes == 40U);
365 EXPECT(txcounters.tx_packets != NULL);
366 if (txcounters.tx_packets != NULL) {
367 u16_t ret;
368 struct tcp_hdr tcphdr;
369 ret = pbuf_copy_partial(txcounters.tx_packets, &tcphdr, 20, 20);
370 EXPECT(ret == 20);
371 EXPECT(tcphdr.dest == PP_HTONS(TEST_REMOTE_PORT));
372 EXPECT(tcphdr.src == PP_HTONS(TEST_LOCAL_PORT));
373 pbuf_free(txcounters.tx_packets);
374 txcounters.tx_packets = NULL;
375 }
376
377 /* don't free the pcb here (part of the test!) */
378 }
379 END_TEST
380
381 /** Check that we handle malformed tcp headers, and discard the pbuf(s) */
START_TEST(test_tcp_malformed_header)382 START_TEST(test_tcp_malformed_header)
383 {
384 struct test_tcp_counters counters;
385 struct tcp_pcb* pcb;
386 struct pbuf* p;
387 char data[] = {1, 2, 3, 4};
388 u16_t data_len, chksum;
389 struct netif netif;
390 struct test_tcp_txcounters txcounters;
391 struct tcp_hdr *hdr;
392 LWIP_UNUSED_ARG(_i);
393
394 /* initialize local vars */
395 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
396 data_len = sizeof(data);
397 /* initialize counter struct */
398 memset(&counters, 0, sizeof(counters));
399 counters.expected_data_len = data_len;
400 counters.expected_data = data;
401
402 /* create and initialize the pcb */
403 pcb = test_tcp_new_counters_pcb(&counters);
404 EXPECT_RET(pcb != NULL);
405 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
406
407 /* create a segment */
408 p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
409
410 pbuf_header(p, -(s16_t)sizeof(struct ip_hdr));
411
412 hdr = (struct tcp_hdr *)p->payload;
413 TCPH_HDRLEN_FLAGS_SET(hdr, 15, 0x3d1);
414
415 hdr->chksum = 0;
416
417 chksum = ip_chksum_pseudo(p, IP_PROTO_TCP, p->tot_len,
418 &test_remote_ip, &test_local_ip);
419
420 hdr->chksum = chksum;
421
422 pbuf_header(p, sizeof(struct ip_hdr));
423
424 EXPECT(p != NULL);
425 EXPECT(p->next == NULL);
426 if (p != NULL) {
427 /* pass the segment to tcp_input */
428 test_tcp_input(p, &netif);
429 /* check if counters are as expected */
430 EXPECT(counters.close_calls == 0);
431 EXPECT(counters.recv_calls == 0);
432 EXPECT(counters.recved_bytes == 0);
433 EXPECT(counters.err_calls == 0);
434 }
435
436 /* make sure the pcb is freed */
437 EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
438 tcp_abort(pcb);
439 EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
440 }
441 END_TEST
442
443
444 /** Provoke fast retransmission by duplicate ACKs and then recover by ACKing all sent data.
445 * At the end, send more data. */
START_TEST(test_tcp_fast_retx_recover)446 START_TEST(test_tcp_fast_retx_recover)
447 {
448 struct netif netif;
449 struct test_tcp_txcounters txcounters;
450 struct test_tcp_counters counters;
451 struct tcp_pcb* pcb;
452 struct pbuf* p;
453 char data1[] = { 1, 2, 3, 4};
454 char data2[] = { 5, 6, 7, 8};
455 char data3[] = { 9, 10, 11, 12};
456 char data4[] = {13, 14, 15, 16};
457 char data5[] = {17, 18, 19, 20};
458 char data6[TCP_MSS] = {21, 22, 23, 24};
459 err_t err;
460 LWIP_UNUSED_ARG(_i);
461
462 /* initialize local vars */
463 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
464 memset(&counters, 0, sizeof(counters));
465
466 /* create and initialize the pcb */
467 pcb = test_tcp_new_counters_pcb(&counters);
468 EXPECT_RET(pcb != NULL);
469 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
470 pcb->mss = TCP_MSS;
471 /* disable initial congestion window (we don't send a SYN here...) */
472 pcb->cwnd = pcb->snd_wnd;
473
474 /* send data1 */
475 err = tcp_write(pcb, data1, sizeof(data1), TCP_WRITE_FLAG_COPY);
476 EXPECT_RET(err == ERR_OK);
477 err = tcp_output(pcb);
478 EXPECT_RET(err == ERR_OK);
479 EXPECT_RET(txcounters.num_tx_calls == 1);
480 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data1) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
481 memset(&txcounters, 0, sizeof(txcounters));
482 /* "recv" ACK for data1 */
483 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 4, TCP_ACK);
484 EXPECT_RET(p != NULL);
485 test_tcp_input(p, &netif);
486 EXPECT_RET(txcounters.num_tx_calls == 0);
487 EXPECT_RET(pcb->unacked == NULL);
488 /* send data2 */
489 err = tcp_write(pcb, data2, sizeof(data2), TCP_WRITE_FLAG_COPY);
490 EXPECT_RET(err == ERR_OK);
491 err = tcp_output(pcb);
492 EXPECT_RET(err == ERR_OK);
493 EXPECT_RET(txcounters.num_tx_calls == 1);
494 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data2) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
495 memset(&txcounters, 0, sizeof(txcounters));
496 /* duplicate ACK for data1 (data2 is lost) */
497 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
498 EXPECT_RET(p != NULL);
499 test_tcp_input(p, &netif);
500 EXPECT_RET(txcounters.num_tx_calls == 0);
501 EXPECT_RET(pcb->dupacks == 1);
502 /* send data3 */
503 err = tcp_write(pcb, data3, sizeof(data3), TCP_WRITE_FLAG_COPY);
504 EXPECT_RET(err == ERR_OK);
505 err = tcp_output(pcb);
506 EXPECT_RET(err == ERR_OK);
507 /* nagle enabled, no tx calls */
508 EXPECT_RET(txcounters.num_tx_calls == 0);
509 EXPECT_RET(txcounters.num_tx_bytes == 0);
510 memset(&txcounters, 0, sizeof(txcounters));
511 /* 2nd duplicate ACK for data1 (data2 and data3 are lost) */
512 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
513 EXPECT_RET(p != NULL);
514 test_tcp_input(p, &netif);
515 EXPECT_RET(txcounters.num_tx_calls == 0);
516 EXPECT_RET(pcb->dupacks == 2);
517 /* queue data4, don't send it (unsent-oversize is != 0) */
518 err = tcp_write(pcb, data4, sizeof(data4), TCP_WRITE_FLAG_COPY);
519 EXPECT_RET(err == ERR_OK);
520 /* 3nd duplicate ACK for data1 (data2 and data3 are lost) -> fast retransmission */
521 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
522 EXPECT_RET(p != NULL);
523 test_tcp_input(p, &netif);
524 /*EXPECT_RET(txcounters.num_tx_calls == 1);*/
525 EXPECT_RET(pcb->dupacks == 3);
526 memset(&txcounters, 0, sizeof(txcounters));
527 /* @todo: check expected data?*/
528
529 /* send data5, not output yet */
530 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
531 EXPECT_RET(err == ERR_OK);
532 /*err = tcp_output(pcb);
533 EXPECT_RET(err == ERR_OK);*/
534 EXPECT_RET(txcounters.num_tx_calls == 0);
535 EXPECT_RET(txcounters.num_tx_bytes == 0);
536 memset(&txcounters, 0, sizeof(txcounters));
537 {
538 int i = 0;
539 do
540 {
541 err = tcp_write(pcb, data6, TCP_MSS, TCP_WRITE_FLAG_COPY);
542 i++;
543 }while(err == ERR_OK);
544 EXPECT_RET(err != ERR_OK);
545 }
546 err = tcp_output(pcb);
547 EXPECT_RET(err == ERR_OK);
548 /*EXPECT_RET(txcounters.num_tx_calls == 0);
549 EXPECT_RET(txcounters.num_tx_bytes == 0);*/
550 memset(&txcounters, 0, sizeof(txcounters));
551
552 /* send even more data */
553 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
554 EXPECT_RET(err == ERR_OK);
555 err = tcp_output(pcb);
556 EXPECT_RET(err == ERR_OK);
557 /* ...and even more data */
558 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
559 EXPECT_RET(err == ERR_OK);
560 err = tcp_output(pcb);
561 EXPECT_RET(err == ERR_OK);
562 /* ...and even more data */
563 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
564 EXPECT_RET(err == ERR_OK);
565 err = tcp_output(pcb);
566 EXPECT_RET(err == ERR_OK);
567 /* ...and even more data */
568 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
569 EXPECT_RET(err == ERR_OK);
570 err = tcp_output(pcb);
571 EXPECT_RET(err == ERR_OK);
572
573 /* send ACKs for data2 and data3 */
574 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 12, TCP_ACK);
575 EXPECT_RET(p != NULL);
576 test_tcp_input(p, &netif);
577 /*EXPECT_RET(txcounters.num_tx_calls == 0);*/
578
579 /* ...and even more data */
580 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
581 EXPECT_RET(err == ERR_OK);
582 err = tcp_output(pcb);
583 EXPECT_RET(err == ERR_OK);
584 /* ...and even more data */
585 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
586 EXPECT_RET(err == ERR_OK);
587 err = tcp_output(pcb);
588 EXPECT_RET(err == ERR_OK);
589
590 #if 0
591 /* create expected segment */
592 p1 = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
593 EXPECT_RET(p != NULL);
594 if (p != NULL) {
595 /* pass the segment to tcp_input */
596 test_tcp_input(p, &netif);
597 /* check if counters are as expected */
598 EXPECT_RET(counters.close_calls == 0);
599 EXPECT_RET(counters.recv_calls == 1);
600 EXPECT_RET(counters.recved_bytes == data_len);
601 EXPECT_RET(counters.err_calls == 0);
602 }
603 #endif
604 /* make sure the pcb is freed */
605 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
606 tcp_abort(pcb);
607 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
608 }
609 END_TEST
610
611 static u8_t tx_data[TCP_WND*2];
612
613 static void
check_seqnos(struct tcp_seg * segs,int num_expected,u32_t * seqnos_expected)614 check_seqnos(struct tcp_seg *segs, int num_expected, u32_t *seqnos_expected)
615 {
616 struct tcp_seg *s = segs;
617 int i;
618 for (i = 0; i < num_expected; i++, s = s->next) {
619 EXPECT_RET(s != NULL);
620 EXPECT(s->tcphdr->seqno == htonl(seqnos_expected[i]));
621 }
622 EXPECT(s == NULL);
623 }
624
625 /** Send data with sequence numbers that wrap around the u32_t range.
626 * Then, provoke fast retransmission by duplicate ACKs and check that all
627 * segment lists are still properly sorted. */
START_TEST(test_tcp_fast_rexmit_wraparound)628 START_TEST(test_tcp_fast_rexmit_wraparound)
629 {
630 struct netif netif;
631 struct test_tcp_txcounters txcounters;
632 struct test_tcp_counters counters;
633 struct tcp_pcb* pcb;
634 struct pbuf* p;
635 err_t err;
636 size_t i;
637 u16_t sent_total = 0;
638 LWIP_UNUSED_ARG(_i);
639
640 for (i = 0; i < sizeof(tx_data); i++) {
641 tx_data[i] = (u8_t)i;
642 }
643
644 /* initialize local vars */
645 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
646 memset(&counters, 0, sizeof(counters));
647
648 /* create and initialize the pcb */
649 tcp_ticks = SEQNO1 - ISS;
650 pcb = test_tcp_new_counters_pcb(&counters);
651 EXPECT_RET(pcb != NULL);
652 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
653 pcb->mss = TCP_MSS;
654 /* disable initial congestion window (we don't send a SYN here...) */
655 pcb->cwnd = 2*TCP_MSS;
656 /* start in congestion advoidance */
657 pcb->ssthresh = pcb->cwnd;
658
659 /* send 6 mss-sized segments */
660 for (i = 0; i < 6; i++) {
661 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
662 EXPECT_RET(err == ERR_OK);
663 sent_total += TCP_MSS;
664 }
665 check_seqnos(pcb->unsent, 6, seqnos);
666 EXPECT(pcb->unacked == NULL);
667 err = tcp_output(pcb);
668 EXPECT_RET(err == ERR_OK);
669 EXPECT(txcounters.num_tx_calls == 2);
670 EXPECT(txcounters.num_tx_bytes == 2 * (TCP_MSS + 40U));
671 memset(&txcounters, 0, sizeof(txcounters));
672
673 check_seqnos(pcb->unacked, 2, seqnos);
674 check_seqnos(pcb->unsent, 4, &seqnos[2]);
675
676 /* ACK the first segment */
677 p = tcp_create_rx_segment(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK);
678 test_tcp_input(p, &netif);
679 /* ensure this didn't trigger a retransmission. Only one
680 segment should be transmitted because cwnd opened up by
681 TCP_MSS and a fraction since we are in congestion avoidance */
682 EXPECT(txcounters.num_tx_calls == 1);
683 EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
684 memset(&txcounters, 0, sizeof(txcounters));
685 check_seqnos(pcb->unacked, 2, &seqnos[1]);
686 check_seqnos(pcb->unsent, 3, &seqnos[3]);
687
688 /* 3 dupacks */
689 EXPECT(pcb->dupacks == 0);
690 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
691 test_tcp_input(p, &netif);
692 EXPECT(txcounters.num_tx_calls == 0);
693 EXPECT(pcb->dupacks == 1);
694 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
695 test_tcp_input(p, &netif);
696 EXPECT(txcounters.num_tx_calls == 0);
697 EXPECT(pcb->dupacks == 2);
698 /* 3rd dupack -> fast rexmit */
699 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
700 test_tcp_input(p, &netif);
701 EXPECT(pcb->dupacks == 3);
702 EXPECT(txcounters.num_tx_calls == 4);
703 memset(&txcounters, 0, sizeof(txcounters));
704 EXPECT(pcb->unsent == NULL);
705 check_seqnos(pcb->unacked, 5, &seqnos[1]);
706
707 /* make sure the pcb is freed */
708 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
709 tcp_abort(pcb);
710 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
711 }
712 END_TEST
713
714 /** Send data with sequence numbers that wrap around the u32_t range.
715 * Then, provoke RTO retransmission and check that all
716 * segment lists are still properly sorted. */
START_TEST(test_tcp_rto_rexmit_wraparound)717 START_TEST(test_tcp_rto_rexmit_wraparound)
718 {
719 struct netif netif;
720 struct test_tcp_txcounters txcounters;
721 struct test_tcp_counters counters;
722 struct tcp_pcb* pcb;
723 struct tcp_pcb dummy_pcb_for_iss; /* we need this for tcp_next_iss() only */
724 err_t err;
725 size_t i;
726 u16_t sent_total = 0;
727 LWIP_UNUSED_ARG(_i);
728
729 for (i = 0; i < sizeof(tx_data); i++) {
730 tx_data[i] = (u8_t)i;
731 }
732
733 /* initialize local vars */
734 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
735 memset(&counters, 0, sizeof(counters));
736
737 /* create and initialize the pcb */
738 tcp_ticks = 0;
739 tcp_ticks = 0 - tcp_next_iss(&dummy_pcb_for_iss);
740 tcp_ticks = SEQNO1 - tcp_next_iss(&dummy_pcb_for_iss);
741 pcb = test_tcp_new_counters_pcb(&counters);
742 EXPECT_RET(pcb != NULL);
743 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
744 pcb->mss = TCP_MSS;
745 /* disable initial congestion window (we don't send a SYN here...) */
746 pcb->cwnd = 2*TCP_MSS;
747
748 /* send 6 mss-sized segments */
749 for (i = 0; i < 6; i++) {
750 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
751 EXPECT_RET(err == ERR_OK);
752 sent_total += TCP_MSS;
753 }
754 check_seqnos(pcb->unsent, 6, seqnos);
755 EXPECT(pcb->unacked == NULL);
756 err = tcp_output(pcb);
757 EXPECT_RET(err == ERR_OK);
758 EXPECT(txcounters.num_tx_calls == 2);
759 EXPECT(txcounters.num_tx_bytes == 2 * (TCP_MSS + 40U));
760 memset(&txcounters, 0, sizeof(txcounters));
761
762 check_seqnos(pcb->unacked, 2, seqnos);
763 check_seqnos(pcb->unsent, 4, &seqnos[2]);
764
765 /* call the tcp timer some times */
766 for (i = 0; i < 10; i++) {
767 test_tcp_tmr();
768 EXPECT(txcounters.num_tx_calls == 0);
769 }
770 /* 11th call to tcp_tmr: RTO rexmit fires */
771 test_tcp_tmr();
772 EXPECT(txcounters.num_tx_calls == 1);
773 check_seqnos(pcb->unacked, 1, seqnos);
774 check_seqnos(pcb->unsent, 5, &seqnos[1]);
775
776 /* fake greater cwnd */
777 pcb->cwnd = pcb->snd_wnd;
778 /* send more data */
779 err = tcp_output(pcb);
780 EXPECT(err == ERR_OK);
781 /* check queues are sorted */
782 EXPECT(pcb->unsent == NULL);
783 check_seqnos(pcb->unacked, 6, seqnos);
784
785 /* make sure the pcb is freed */
786 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
787 tcp_abort(pcb);
788 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
789 }
790 END_TEST
791
792 /** Provoke fast retransmission by duplicate ACKs and then recover by ACKing all sent data.
793 * At the end, send more data. */
test_tcp_tx_full_window_lost(u8_t zero_window_probe_from_unsent)794 static void test_tcp_tx_full_window_lost(u8_t zero_window_probe_from_unsent)
795 {
796 struct netif netif;
797 struct test_tcp_txcounters txcounters;
798 struct test_tcp_counters counters;
799 struct tcp_pcb* pcb;
800 struct pbuf *p;
801 err_t err;
802 size_t i;
803 u16_t sent_total;
804 u8_t expected = 0xFE;
805
806 for (i = 0; i < sizeof(tx_data); i++) {
807 u8_t d = (u8_t)i;
808 if (d == 0xFE) {
809 d = 0xF0;
810 }
811 tx_data[i] = d;
812 }
813 if (zero_window_probe_from_unsent) {
814 tx_data[TCP_WND] = expected;
815 } else {
816 tx_data[0] = expected;
817 }
818
819 /* initialize local vars */
820 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
821 memset(&counters, 0, sizeof(counters));
822
823 /* create and initialize the pcb */
824 pcb = test_tcp_new_counters_pcb(&counters);
825 EXPECT_RET(pcb != NULL);
826 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
827 pcb->mss = TCP_MSS;
828 /* disable initial congestion window (we don't send a SYN here...) */
829 pcb->cwnd = pcb->snd_wnd;
830
831 /* send a full window (minus 1 packets) of TCP data in MSS-sized chunks */
832 sent_total = 0;
833 if ((TCP_WND - TCP_MSS) % TCP_MSS != 0) {
834 u16_t initial_data_len = (TCP_WND - TCP_MSS) % TCP_MSS;
835 err = tcp_write(pcb, &tx_data[sent_total], initial_data_len, TCP_WRITE_FLAG_COPY);
836 EXPECT_RET(err == ERR_OK);
837 err = tcp_output(pcb);
838 EXPECT_RET(err == ERR_OK);
839 EXPECT(txcounters.num_tx_calls == 1);
840 EXPECT(txcounters.num_tx_bytes == initial_data_len + 40U);
841 memset(&txcounters, 0, sizeof(txcounters));
842 sent_total += initial_data_len;
843 }
844 for (; sent_total < (TCP_WND - TCP_MSS); sent_total += TCP_MSS) {
845 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
846 EXPECT_RET(err == ERR_OK);
847 err = tcp_output(pcb);
848 EXPECT_RET(err == ERR_OK);
849 EXPECT(txcounters.num_tx_calls == 1);
850 EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
851 memset(&txcounters, 0, sizeof(txcounters));
852 }
853 EXPECT(sent_total == (TCP_WND - TCP_MSS));
854
855 /* now ACK the packet before the first */
856 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
857 test_tcp_input(p, &netif);
858 /* ensure this didn't trigger a retransmission */
859 EXPECT(txcounters.num_tx_calls == 0);
860 EXPECT(txcounters.num_tx_bytes == 0);
861
862 EXPECT(pcb->persist_backoff == 0);
863 /* send the last packet, now a complete window has been sent */
864 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
865 sent_total += TCP_MSS;
866 EXPECT_RET(err == ERR_OK);
867 err = tcp_output(pcb);
868 EXPECT_RET(err == ERR_OK);
869 EXPECT(txcounters.num_tx_calls == 1);
870 EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
871 memset(&txcounters, 0, sizeof(txcounters));
872 EXPECT(pcb->persist_backoff == 0);
873
874 if (zero_window_probe_from_unsent) {
875 /* ACK all data but close the TX window */
876 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_WND, TCP_ACK, 0);
877 test_tcp_input(p, &netif);
878 /* ensure this didn't trigger any transmission */
879 EXPECT(txcounters.num_tx_calls == 0);
880 EXPECT(txcounters.num_tx_bytes == 0);
881 /* window is completely full, but persist timer is off since send buffer is empty */
882 EXPECT(pcb->snd_wnd == 0);
883 EXPECT(pcb->persist_backoff == 0);
884 }
885
886 /* send one byte more (out of window) -> persist timer starts */
887 err = tcp_write(pcb, &tx_data[sent_total], 1, TCP_WRITE_FLAG_COPY);
888 EXPECT_RET(err == ERR_OK);
889 err = tcp_output(pcb);
890 EXPECT_RET(err == ERR_OK);
891 EXPECT(txcounters.num_tx_calls == 0);
892 EXPECT(txcounters.num_tx_bytes == 0);
893 memset(&txcounters, 0, sizeof(txcounters));
894 if (!zero_window_probe_from_unsent) {
895 /* no persist timer unless a zero window announcement has been received */
896 EXPECT(pcb->persist_backoff == 0);
897 } else {
898 EXPECT(pcb->persist_backoff == 1);
899
900 /* call tcp_timer some more times to let persist timer count up */
901 for (i = 0; i < 4; i++) {
902 test_tcp_tmr();
903 EXPECT(txcounters.num_tx_calls == 0);
904 EXPECT(txcounters.num_tx_bytes == 0);
905 }
906
907 /* this should trigger the zero-window-probe */
908 txcounters.copy_tx_packets = 1;
909 test_tcp_tmr();
910 txcounters.copy_tx_packets = 0;
911 EXPECT(txcounters.num_tx_calls == 1);
912 EXPECT(txcounters.num_tx_bytes == 1 + 40U);
913 EXPECT(txcounters.tx_packets != NULL);
914 if (txcounters.tx_packets != NULL) {
915 u8_t sent;
916 u16_t ret;
917 ret = pbuf_copy_partial(txcounters.tx_packets, &sent, 1, 40U);
918 EXPECT(ret == 1);
919 EXPECT(sent == expected);
920 }
921 if (txcounters.tx_packets != NULL) {
922 pbuf_free(txcounters.tx_packets);
923 txcounters.tx_packets = NULL;
924 }
925 }
926
927 /* make sure the pcb is freed */
928 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
929 tcp_abort(pcb);
930 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
931 }
932
START_TEST(test_tcp_tx_full_window_lost_from_unsent)933 START_TEST(test_tcp_tx_full_window_lost_from_unsent)
934 {
935 LWIP_UNUSED_ARG(_i);
936 test_tcp_tx_full_window_lost(1);
937 }
938 END_TEST
939
START_TEST(test_tcp_tx_full_window_lost_from_unacked)940 START_TEST(test_tcp_tx_full_window_lost_from_unacked)
941 {
942 LWIP_UNUSED_ARG(_i);
943 test_tcp_tx_full_window_lost(0);
944 }
945 END_TEST
946
947 /** Send data, provoke retransmission and then add data to a segment
948 * that already has been sent before. */
START_TEST(test_tcp_retx_add_to_sent)949 START_TEST(test_tcp_retx_add_to_sent)
950 {
951 struct netif netif;
952 struct test_tcp_txcounters txcounters;
953 struct test_tcp_counters counters;
954 struct tcp_pcb* pcb;
955 struct pbuf* p;
956 char data1a[] = { 1, 2, 3};
957 char data1b[] = { 4};
958 char data2a[] = { 5, 6, 7, 8};
959 char data2b[] = { 5, 6, 7};
960 char data3[] = { 9, 10, 11, 12, 12};
961 char data4[] = { 13, 14, 15, 16,17};
962 err_t err;
963 int i;
964 LWIP_UNUSED_ARG(_i);
965
966 /* initialize local vars */
967 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
968 memset(&counters, 0, sizeof(counters));
969
970 /* create and initialize the pcb */
971 pcb = test_tcp_new_counters_pcb(&counters);
972 EXPECT_RET(pcb != NULL);
973 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
974 pcb->mss = TCP_MSS;
975 /* disable initial congestion window (we don't send a SYN here...) */
976 pcb->cwnd = pcb->snd_wnd;
977
978 /* send data1 */
979 err = tcp_write(pcb, data1a, sizeof(data1a), TCP_WRITE_FLAG_COPY);
980 EXPECT_RET(err == ERR_OK);
981 err = tcp_write(pcb, data1b, sizeof(data1b), TCP_WRITE_FLAG_COPY);
982 EXPECT_RET(err == ERR_OK);
983 err = tcp_output(pcb);
984 EXPECT_RET(err == ERR_OK);
985 EXPECT_RET(txcounters.num_tx_calls == 1);
986 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data1a) + sizeof(data1b) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
987 memset(&txcounters, 0, sizeof(txcounters));
988 /* "recv" ACK for data1 */
989 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 4, TCP_ACK);
990 EXPECT_RET(p != NULL);
991 test_tcp_input(p, &netif);
992 EXPECT_RET(txcounters.num_tx_calls == 0);
993 EXPECT_RET(pcb->unacked == NULL);
994 /* send data2 */
995 err = tcp_write(pcb, data2a, sizeof(data2a), TCP_WRITE_FLAG_COPY);
996 EXPECT_RET(err == ERR_OK);
997 err = tcp_write(pcb, data2b, sizeof(data2b), TCP_WRITE_FLAG_COPY);
998 EXPECT_RET(err == ERR_OK);
999 err = tcp_output(pcb);
1000 EXPECT_RET(err == ERR_OK);
1001 EXPECT_RET(txcounters.num_tx_calls == 1);
1002 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data2a) + sizeof(data2b) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
1003 memset(&txcounters, 0, sizeof(txcounters));
1004 /* send data3 */
1005 err = tcp_write(pcb, data3, sizeof(data3), TCP_WRITE_FLAG_COPY);
1006 EXPECT_RET(err == ERR_OK);
1007 err = tcp_output(pcb);
1008 EXPECT_RET(err == ERR_OK);
1009 EXPECT_RET(txcounters.num_tx_calls == 0);
1010 EXPECT_RET(txcounters.num_tx_bytes == 0);
1011 memset(&txcounters, 0, sizeof(txcounters));
1012
1013 /* data3 not sent yet (nagle) */
1014 EXPECT_RET(pcb->unacked != NULL);
1015 EXPECT_RET(pcb->unsent != NULL);
1016
1017 /* disable nagle for this test so data to sent segment can be added below... */
1018 tcp_nagle_disable(pcb);
1019
1020 /* call the tcp timer some times */
1021 for (i = 0; i < 20; i++) {
1022 test_tcp_tmr();
1023 if (txcounters.num_tx_calls != 0) {
1024 break;
1025 }
1026 }
1027 /* data3 sent */
1028 EXPECT_RET(txcounters.num_tx_calls == 1);
1029 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data3) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
1030 EXPECT_RET(pcb->unacked != NULL);
1031 EXPECT_RET(pcb->unsent == NULL);
1032 memset(&txcounters, 0, sizeof(txcounters));
1033
1034 tcp_nagle_enable(pcb);
1035
1036 /* call the tcp timer some times */
1037 for (i = 0; i < 20; i++) {
1038 test_tcp_tmr();
1039 if (txcounters.num_tx_calls != 0) {
1040 break;
1041 }
1042 }
1043 /* RTO: rexmit of data2 */
1044 EXPECT_RET(txcounters.num_tx_calls == 1);
1045 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data2a) + sizeof(data2b) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
1046 EXPECT_RET(pcb->unacked != NULL);
1047 EXPECT_RET(pcb->unsent != NULL);
1048 memset(&txcounters, 0, sizeof(txcounters));
1049
1050 /* send data4 */
1051 err = tcp_write(pcb, data4, sizeof(data4), TCP_WRITE_FLAG_COPY);
1052 EXPECT_RET(err == ERR_OK);
1053 /* disable nagle for this test so data to transmit without further ACKs... */
1054 tcp_nagle_disable(pcb);
1055 err = tcp_output(pcb);
1056 EXPECT_RET(err == ERR_OK);
1057 /* nagle enabled, no tx calls */
1058 EXPECT_RET(txcounters.num_tx_calls == 1);
1059 EXPECT_RET(txcounters.num_tx_bytes == sizeof(data3) + sizeof(data4) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
1060 memset(&txcounters, 0, sizeof(txcounters));
1061 /* make sure the pcb is freed */
1062 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
1063 tcp_abort(pcb);
1064 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
1065 }
1066 END_TEST
1067
START_TEST(test_tcp_rto_tracking)1068 START_TEST(test_tcp_rto_tracking)
1069 {
1070 struct netif netif;
1071 struct test_tcp_txcounters txcounters;
1072 struct test_tcp_counters counters;
1073 struct tcp_pcb* pcb;
1074 struct pbuf* p;
1075 err_t err;
1076 size_t i;
1077 u16_t sent_total = 0;
1078 LWIP_UNUSED_ARG(_i);
1079
1080 for (i = 0; i < sizeof(tx_data); i++) {
1081 tx_data[i] = (u8_t)i;
1082 }
1083
1084 /* initialize local vars */
1085 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
1086 memset(&counters, 0, sizeof(counters));
1087
1088 /* create and initialize the pcb */
1089 tcp_ticks = SEQNO1 - ISS;
1090 pcb = test_tcp_new_counters_pcb(&counters);
1091 EXPECT_RET(pcb != NULL);
1092 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1093 pcb->mss = TCP_MSS;
1094 /* Set congestion window large enough to send all our segments */
1095 pcb->cwnd = 5*TCP_MSS;
1096
1097 /* send 5 mss-sized segments */
1098 for (i = 0; i < 5; i++) {
1099 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
1100 EXPECT_RET(err == ERR_OK);
1101 sent_total += TCP_MSS;
1102 }
1103 check_seqnos(pcb->unsent, 5, seqnos);
1104 EXPECT(pcb->unacked == NULL);
1105 err = tcp_output(pcb);
1106 EXPECT_RET(err == ERR_OK);
1107 EXPECT(txcounters.num_tx_calls == 5);
1108 EXPECT(txcounters.num_tx_bytes == 5 * (TCP_MSS + 40U));
1109 memset(&txcounters, 0, sizeof(txcounters));
1110 /* Check all 5 are in-flight */
1111 EXPECT(pcb->unsent == NULL);
1112 check_seqnos(pcb->unacked, 5, seqnos);
1113
1114 /* Force us into retransmisson timeout */
1115 while (!(pcb->flags & TF_RTO)) {
1116 test_tcp_tmr();
1117 }
1118 /* Ensure 4 remaining segments are back on unsent, ready for retransmission */
1119 check_seqnos(pcb->unsent, 4, &seqnos[1]);
1120 /* Ensure 1st segment is on unacked (already retransmitted) */
1121 check_seqnos(pcb->unacked, 1, seqnos);
1122 EXPECT(txcounters.num_tx_calls == 1);
1123 EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
1124 memset(&txcounters, 0, sizeof(txcounters));
1125 /* Ensure rto_end points to next byte */
1126 EXPECT(pcb->rto_end == seqnos[5]);
1127 EXPECT(pcb->rto_end == pcb->snd_nxt);
1128 /* Check cwnd was reset */
1129 EXPECT(pcb->cwnd == pcb->mss);
1130
1131 /* Add another segment to send buffer which is outside of RTO */
1132 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
1133 EXPECT_RET(err == ERR_OK);
1134 sent_total += TCP_MSS;
1135 check_seqnos(pcb->unsent, 5, &seqnos[1]);
1136 /* Ensure no new data was sent */
1137 EXPECT(txcounters.num_tx_calls == 0);
1138 EXPECT(txcounters.num_tx_bytes == 0);
1139 EXPECT(pcb->rto_end == pcb->snd_nxt);
1140
1141 /* ACK first segment */
1142 p = tcp_create_rx_segment(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK);
1143 test_tcp_input(p, &netif);
1144 /* Next two retranmissions should go out, due to cwnd in slow start */
1145 EXPECT(txcounters.num_tx_calls == 2);
1146 EXPECT(txcounters.num_tx_bytes == 2 * (TCP_MSS + 40U));
1147 memset(&txcounters, 0, sizeof(txcounters));
1148 check_seqnos(pcb->unacked, 2, &seqnos[1]);
1149 check_seqnos(pcb->unsent, 3, &seqnos[3]);
1150 /* RTO should still be marked */
1151 EXPECT(pcb->flags & TF_RTO);
1152 /* cwnd should have only grown by 1 MSS */
1153 EXPECT(pcb->cwnd == (tcpwnd_size_t)(2 * pcb->mss));
1154 /* Ensure no new data was sent */
1155 EXPECT(pcb->rto_end == pcb->snd_nxt);
1156
1157 /* ACK the next two segments */
1158 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 2*TCP_MSS, TCP_ACK);
1159 test_tcp_input(p, &netif);
1160 /* Final 2 retransmissions and 1 new data should go out */
1161 EXPECT(txcounters.num_tx_calls == 3);
1162 EXPECT(txcounters.num_tx_bytes == 3 * (TCP_MSS + 40U));
1163 memset(&txcounters, 0, sizeof(txcounters));
1164 check_seqnos(pcb->unacked, 3, &seqnos[3]);
1165 EXPECT(pcb->unsent == NULL);
1166 /* RTO should still be marked */
1167 EXPECT(pcb->flags & TF_RTO);
1168 /* cwnd should have only grown by 1 MSS */
1169 EXPECT(pcb->cwnd == (tcpwnd_size_t)(3 * pcb->mss));
1170 /* snd_nxt should have been advanced past rto_end */
1171 EXPECT(TCP_SEQ_GT(pcb->snd_nxt, pcb->rto_end));
1172
1173 /* ACK the next two segments, finishing our RTO, leaving new segment unacked */
1174 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 2*TCP_MSS, TCP_ACK);
1175 test_tcp_input(p, &netif);
1176 EXPECT(!(pcb->flags & TF_RTO));
1177 check_seqnos(pcb->unacked, 1, &seqnos[5]);
1178 /* We should be in ABC congestion avoidance, so no change in cwnd */
1179 EXPECT(pcb->cwnd == (tcpwnd_size_t)(3 * pcb->mss));
1180 EXPECT(pcb->cwnd >= pcb->ssthresh);
1181 /* Ensure ABC congestion avoidance is tracking bytes acked */
1182 EXPECT(pcb->bytes_acked == (tcpwnd_size_t)(2 * pcb->mss));
1183
1184 /* make sure the pcb is freed */
1185 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
1186 tcp_abort(pcb);
1187 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
1188 }
1189 END_TEST
1190
test_tcp_rto_timeout_impl(int link_down)1191 static void test_tcp_rto_timeout_impl(int link_down)
1192 {
1193 struct netif netif;
1194 struct test_tcp_txcounters txcounters;
1195 struct test_tcp_counters counters;
1196 struct tcp_pcb *pcb, *cur;
1197 err_t err;
1198 size_t i;
1199 const size_t max_wait_ctr = 1024 * 1024;
1200
1201 /* Setup data for a single segment */
1202 for (i = 0; i < TCP_MSS; i++) {
1203 tx_data[i] = (u8_t)i;
1204 }
1205
1206 /* initialize local vars */
1207 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
1208 memset(&counters, 0, sizeof(counters));
1209
1210 /* create and initialize the pcb */
1211 tcp_ticks = SEQNO1 - ISS;
1212 pcb = test_tcp_new_counters_pcb(&counters);
1213 EXPECT_RET(pcb != NULL);
1214 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1215 pcb->mss = TCP_MSS;
1216 pcb->cwnd = TCP_MSS;
1217
1218 /* send our segment */
1219 err = tcp_write(pcb, &tx_data[0], TCP_MSS, TCP_WRITE_FLAG_COPY);
1220 EXPECT_RET(err == ERR_OK);
1221 err = tcp_output(pcb);
1222 EXPECT_RET(err == ERR_OK);
1223 EXPECT(txcounters.num_tx_calls == 1);
1224 EXPECT(txcounters.num_tx_bytes == 1 * (TCP_MSS + 40U));
1225 memset(&txcounters, 0, sizeof(txcounters));
1226
1227 /* ensure no errors have been recorded */
1228 EXPECT(counters.err_calls == 0);
1229 EXPECT(counters.last_err == ERR_OK);
1230
1231 /* Force us into retransmisson timeout */
1232 for (i = 0; !(pcb->flags & TF_RTO) && i < max_wait_ctr; i++) {
1233 test_tcp_tmr();
1234 }
1235 EXPECT(i < max_wait_ctr);
1236
1237 /* check first rexmit */
1238 EXPECT(pcb->nrtx == 1);
1239 EXPECT(txcounters.num_tx_calls == 1);
1240 EXPECT(txcounters.num_tx_bytes == 1 * (TCP_MSS + 40U));
1241
1242 /* still no error expected */
1243 EXPECT(counters.err_calls == 0);
1244 EXPECT(counters.last_err == ERR_OK);
1245
1246 if (link_down) {
1247 netif_set_link_down(&netif);
1248 }
1249
1250 /* keep running the timer till we hit our maximum RTO */
1251 for (i = 0; counters.last_err == ERR_OK && i < max_wait_ctr; i++) {
1252 test_tcp_tmr();
1253 }
1254 EXPECT(i < max_wait_ctr);
1255
1256 /* check number of retransmissions */
1257 if (link_down) {
1258 EXPECT(txcounters.num_tx_calls == 1);
1259 EXPECT(txcounters.num_tx_bytes == 1 * (TCP_MSS + 40U));
1260 } else {
1261 EXPECT(txcounters.num_tx_calls == TCP_MAXRTX);
1262 EXPECT(txcounters.num_tx_bytes == TCP_MAXRTX * (TCP_MSS + 40U));
1263 }
1264
1265 /* check the connection (pcb) has been aborted */
1266 EXPECT(counters.err_calls == 1);
1267 EXPECT(counters.last_err == ERR_ABRT);
1268 /* check our pcb is no longer active */
1269 for (cur = tcp_active_pcbs; cur != NULL; cur = cur->next) {
1270 EXPECT(cur != pcb);
1271 }
1272 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
1273 }
1274
START_TEST(test_tcp_rto_timeout)1275 START_TEST(test_tcp_rto_timeout)
1276 {
1277 LWIP_UNUSED_ARG(_i);
1278 test_tcp_rto_timeout_impl(0);
1279 }
1280 END_TEST
1281
START_TEST(test_tcp_rto_timeout_link_down)1282 START_TEST(test_tcp_rto_timeout_link_down)
1283 {
1284 LWIP_UNUSED_ARG(_i);
1285 test_tcp_rto_timeout_impl(1);
1286 }
1287 END_TEST
1288
test_tcp_rto_timeout_syn_sent_impl(int link_down)1289 static void test_tcp_rto_timeout_syn_sent_impl(int link_down)
1290 {
1291 struct netif netif;
1292 struct test_tcp_txcounters txcounters;
1293 struct test_tcp_counters counters;
1294 struct tcp_pcb *pcb, *cur;
1295 err_t err;
1296 size_t i;
1297 const size_t max_wait_ctr = 1024 * 1024;
1298 const u16_t tcp_syn_opts_len = LWIP_TCP_OPT_LENGTH(TF_SEG_OPTS_MSS|TF_SEG_OPTS_WND_SCALE|TF_SEG_OPTS_SACK_PERM|TF_SEG_OPTS_TS);
1299
1300 /* Setup data for a single segment */
1301 for (i = 0; i < TCP_MSS; i++) {
1302 tx_data[i] = (u8_t)i;
1303 }
1304
1305 /* initialize local vars */
1306 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
1307 memset(&counters, 0, sizeof(counters));
1308
1309 /* create and initialize the pcb */
1310 tcp_ticks = SEQNO1 - ISS;
1311 pcb = test_tcp_new_counters_pcb(&counters);
1312 EXPECT_RET(pcb != NULL);
1313 err = tcp_connect(pcb, &netif.gw, 123, NULL);
1314 EXPECT_RET(err == ERR_OK);
1315 EXPECT_RET(pcb->state == SYN_SENT);
1316 EXPECT(txcounters.num_tx_calls == 1);
1317 EXPECT(txcounters.num_tx_bytes == 40U + tcp_syn_opts_len);
1318
1319 /* ensure no errors have been recorded */
1320 EXPECT(counters.err_calls == 0);
1321 EXPECT(counters.last_err == ERR_OK);
1322
1323 txcounters.num_tx_calls = 0;
1324 txcounters.num_tx_bytes = 0;
1325
1326 /* Force us into retransmisson timeout */
1327 for (i = 0; !(pcb->flags & TF_RTO) && i < max_wait_ctr; i++) {
1328 test_tcp_tmr();
1329 }
1330 EXPECT(i < max_wait_ctr);
1331
1332 /* check first rexmit */
1333 EXPECT(pcb->nrtx == 1);
1334 EXPECT(txcounters.num_tx_calls == 1);
1335 EXPECT(txcounters.num_tx_bytes == 40U + tcp_syn_opts_len); /* 40: headers; >=: options */
1336
1337 /* still no error expected */
1338 EXPECT(counters.err_calls == 0);
1339 EXPECT(counters.last_err == ERR_OK);
1340
1341 if (link_down) {
1342 /* set link down and check what happens to the RTO counter */
1343 netif_set_link_down(&netif);
1344 }
1345
1346 /* keep running the timer till we hit our maximum RTO */
1347 for (i = 0; counters.last_err == ERR_OK && i < max_wait_ctr; i++) {
1348 test_tcp_tmr();
1349 }
1350 EXPECT(i < max_wait_ctr);
1351
1352 /* check number of retransmissions */
1353 if (link_down) {
1354 EXPECT(txcounters.num_tx_calls == 1);
1355 EXPECT(txcounters.num_tx_bytes == 40U + tcp_syn_opts_len);
1356 } else {
1357 EXPECT(txcounters.num_tx_calls == TCP_SYNMAXRTX);
1358 EXPECT(txcounters.num_tx_bytes == TCP_SYNMAXRTX * (tcp_syn_opts_len + 40U));
1359 }
1360
1361 /* check the connection (pcb) has been aborted */
1362 EXPECT(counters.err_calls == 1);
1363 EXPECT(counters.last_err == ERR_ABRT);
1364 /* check our pcb is no longer active */
1365 for (cur = tcp_active_pcbs; cur != NULL; cur = cur->next) {
1366 EXPECT(cur != pcb);
1367 }
1368 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
1369 }
1370
START_TEST(test_tcp_rto_timeout_syn_sent)1371 START_TEST(test_tcp_rto_timeout_syn_sent)
1372 {
1373 LWIP_UNUSED_ARG(_i);
1374 test_tcp_rto_timeout_syn_sent_impl(0);
1375 }
1376 END_TEST
1377
START_TEST(test_tcp_rto_timeout_syn_sent_link_down)1378 START_TEST(test_tcp_rto_timeout_syn_sent_link_down)
1379 {
1380 LWIP_UNUSED_ARG(_i);
1381 test_tcp_rto_timeout_syn_sent_impl(1);
1382 }
1383 END_TEST
1384
test_tcp_zwp_timeout_impl(int link_down)1385 static void test_tcp_zwp_timeout_impl(int link_down)
1386 {
1387 struct netif netif;
1388 struct test_tcp_txcounters txcounters;
1389 struct test_tcp_counters counters;
1390 struct tcp_pcb *pcb, *cur;
1391 struct pbuf* p;
1392 err_t err;
1393 size_t i;
1394
1395 /* Setup data for two segments */
1396 for (i = 0; i < 2*TCP_MSS; i++) {
1397 tx_data[i] = (u8_t)i;
1398 }
1399
1400 /* initialize local vars */
1401 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
1402 memset(&counters, 0, sizeof(counters));
1403
1404 /* create and initialize the pcb */
1405 tcp_ticks = SEQNO1 - ISS;
1406 pcb = test_tcp_new_counters_pcb(&counters);
1407 EXPECT_RET(pcb != NULL);
1408 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1409 pcb->mss = TCP_MSS;
1410 pcb->cwnd = TCP_MSS;
1411
1412 /* send first segment */
1413 err = tcp_write(pcb, &tx_data[0], TCP_MSS, TCP_WRITE_FLAG_COPY);
1414 EXPECT(err == ERR_OK);
1415 err = tcp_output(pcb);
1416 EXPECT(err == ERR_OK);
1417
1418 /* verify segment is in-flight */
1419 EXPECT(pcb->unsent == NULL);
1420 check_seqnos(pcb->unacked, 1, seqnos);
1421 EXPECT(txcounters.num_tx_calls == 1);
1422 EXPECT(txcounters.num_tx_bytes == 1 * (TCP_MSS + 40U));
1423 memset(&txcounters, 0, sizeof(txcounters));
1424
1425 /* ACK the segment and close the TX window */
1426 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK, 0);
1427 test_tcp_input(p, &netif);
1428 EXPECT(pcb->unacked == NULL);
1429 EXPECT(pcb->unsent == NULL);
1430 /* send buffer empty, persist should be off */
1431 EXPECT(pcb->persist_backoff == 0);
1432 EXPECT(pcb->snd_wnd == 0);
1433
1434 /* send second segment, should be buffered */
1435 err = tcp_write(pcb, &tx_data[TCP_MSS], TCP_MSS, TCP_WRITE_FLAG_COPY);
1436 EXPECT(err == ERR_OK);
1437 err = tcp_output(pcb);
1438 EXPECT(err == ERR_OK);
1439
1440 /* ensure it is buffered and persist timer started */
1441 EXPECT(pcb->unacked == NULL);
1442 check_seqnos(pcb->unsent, 1, &seqnos[1]);
1443 EXPECT(txcounters.num_tx_calls == 0);
1444 EXPECT(txcounters.num_tx_bytes == 0);
1445 EXPECT(pcb->persist_backoff == 1);
1446
1447 /* ensure no errors have been recorded */
1448 EXPECT(counters.err_calls == 0);
1449 EXPECT(counters.last_err == ERR_OK);
1450
1451 /* run timer till first probe */
1452 EXPECT(pcb->persist_probe == 0);
1453 while (pcb->persist_probe == 0) {
1454 test_tcp_tmr();
1455 }
1456 EXPECT(txcounters.num_tx_calls == 1);
1457 EXPECT(txcounters.num_tx_bytes == (1 + 40U));
1458 memset(&txcounters, 0, sizeof(txcounters));
1459
1460 /* respond to probe with remote's current SEQ, ACK, and zero-window */
1461 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, 0, TCP_ACK, 0);
1462 test_tcp_input(p, &netif);
1463 /* ensure zero-window is still active, but probe count reset */
1464 EXPECT(pcb->persist_backoff > 1);
1465 EXPECT(pcb->persist_probe == 0);
1466 EXPECT(pcb->snd_wnd == 0);
1467
1468 /* ensure no errors have been recorded */
1469 EXPECT(counters.err_calls == 0);
1470 EXPECT(counters.last_err == ERR_OK);
1471
1472 if (link_down) {
1473 netif_set_link_down(&netif);
1474 }
1475
1476 /* now run the timer till we hit our maximum probe count */
1477 while (counters.last_err == ERR_OK) {
1478 test_tcp_tmr();
1479 }
1480
1481 if (link_down) {
1482 EXPECT(txcounters.num_tx_calls == 0);
1483 EXPECT(txcounters.num_tx_bytes == 0);
1484 } else {
1485 /* check maximum number of 1 byte probes were sent */
1486 EXPECT(txcounters.num_tx_calls == TCP_MAXRTX);
1487 EXPECT(txcounters.num_tx_bytes == TCP_MAXRTX * (1 + 40U));
1488 }
1489
1490 /* check the connection (pcb) has been aborted */
1491 EXPECT(counters.err_calls == 1);
1492 EXPECT(counters.last_err == ERR_ABRT);
1493 /* check our pcb is no longer active */
1494 for (cur = tcp_active_pcbs; cur != NULL; cur = cur->next) {
1495 EXPECT(cur != pcb);
1496 }
1497 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
1498 }
1499
START_TEST(test_tcp_zwp_timeout)1500 START_TEST(test_tcp_zwp_timeout)
1501 {
1502 LWIP_UNUSED_ARG(_i);
1503 test_tcp_zwp_timeout_impl(0);
1504 }
1505 END_TEST
1506
START_TEST(test_tcp_zwp_timeout_link_down)1507 START_TEST(test_tcp_zwp_timeout_link_down)
1508 {
1509 LWIP_UNUSED_ARG(_i);
1510 test_tcp_zwp_timeout_impl(1);
1511 }
1512 END_TEST
1513
START_TEST(test_tcp_persist_split)1514 START_TEST(test_tcp_persist_split)
1515 {
1516 struct netif netif;
1517 struct test_tcp_txcounters txcounters;
1518 struct test_tcp_counters counters;
1519 struct tcp_pcb *pcb;
1520 struct pbuf* p;
1521 err_t err;
1522 size_t i;
1523 LWIP_UNUSED_ARG(_i);
1524
1525 /* Setup data for four segments */
1526 for (i = 0; i < 4 * TCP_MSS; i++) {
1527 tx_data[i] = (u8_t)i;
1528 }
1529
1530 /* initialize local vars */
1531 test_tcp_init_netif(&netif, &txcounters, &test_local_ip, &test_netmask);
1532 memset(&counters, 0, sizeof(counters));
1533
1534 /* create and initialize the pcb */
1535 tcp_ticks = SEQNO1 - ISS;
1536 pcb = test_tcp_new_counters_pcb(&counters);
1537 EXPECT_RET(pcb != NULL);
1538 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1539 pcb->mss = TCP_MSS;
1540 /* set window to three segments */
1541 pcb->cwnd = 3 * TCP_MSS;
1542 pcb->snd_wnd = 3 * TCP_MSS;
1543 pcb->snd_wnd_max = 3 * TCP_MSS;
1544
1545 /* send four segments. Fourth should stay buffered and is a 3/4 MSS segment to
1546 get coverage on the oversized segment case */
1547 err = tcp_write(pcb, &tx_data[0], (3 * TCP_MSS) + (TCP_MSS - (TCP_MSS / 4)), TCP_WRITE_FLAG_COPY);
1548 EXPECT(err == ERR_OK);
1549 err = tcp_output(pcb);
1550 EXPECT(err == ERR_OK);
1551
1552 /* verify 3 segments are in-flight */
1553 EXPECT(pcb->unacked != NULL);
1554 check_seqnos(pcb->unacked, 3, seqnos);
1555 EXPECT(txcounters.num_tx_calls == 3);
1556 EXPECT(txcounters.num_tx_bytes == 3 * (TCP_MSS + 40U));
1557 memset(&txcounters, 0, sizeof(txcounters));
1558 /* verify 4th segment is on unsent */
1559 EXPECT(pcb->unsent != NULL);
1560 EXPECT(pcb->unsent->len == TCP_MSS - (TCP_MSS / 4));
1561 check_seqnos(pcb->unsent, 1, &seqnos[3]);
1562 #if TCP_OVERSIZE
1563 EXPECT(pcb->unsent_oversize == TCP_MSS / 4);
1564 #if TCP_OVERSIZE_DBGCHECK
1565 EXPECT(pcb->unsent->oversize_left == pcb->unsent_oversize);
1566 #endif /* TCP_OVERSIZE_DBGCHECK */
1567 #endif /* TCP_OVERSIZE */
1568
1569 /* ACK the 3 segments and update the window to only 1/2 TCP_MSS.
1570 4th segment should stay on unsent because it's bigger than 1/2 MSS */
1571 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, 3 * TCP_MSS, TCP_ACK, TCP_MSS / 2);
1572 test_tcp_input(p, &netif);
1573 EXPECT(pcb->unacked == NULL);
1574 EXPECT(pcb->snd_wnd == TCP_MSS / 2);
1575 EXPECT(pcb->unsent != NULL);
1576 check_seqnos(pcb->unsent, 1, &seqnos[3]);
1577 EXPECT(txcounters.num_tx_calls == 0);
1578 EXPECT(txcounters.num_tx_bytes == 0);
1579 /* persist timer should be started since 4th segment is stuck waiting on snd_wnd */
1580 EXPECT(pcb->persist_backoff == 1);
1581
1582 /* ensure no errors have been recorded */
1583 EXPECT(counters.err_calls == 0);
1584 EXPECT(counters.last_err == ERR_OK);
1585
1586 /* call tcp_timer some more times to let persist timer count up */
1587 for (i = 0; i < 4; i++) {
1588 test_tcp_tmr();
1589 EXPECT(txcounters.num_tx_calls == 0);
1590 EXPECT(txcounters.num_tx_bytes == 0);
1591 }
1592
1593 /* this should be the first timer shot, which should split the
1594 * segment and send a runt (of the remaining window size) */
1595 txcounters.copy_tx_packets = 1;
1596 test_tcp_tmr();
1597 txcounters.copy_tx_packets = 0;
1598 /* persist will be disabled as RTO timer takes over */
1599 EXPECT(pcb->persist_backoff == 0);
1600 EXPECT(txcounters.num_tx_calls == 1);
1601 EXPECT(txcounters.num_tx_bytes == ((TCP_MSS /2) + 40U));
1602 /* verify 1/2 MSS segment sent, 1/4 MSS still buffered */
1603 EXPECT(pcb->unsent != NULL);
1604 EXPECT(pcb->unsent->len == TCP_MSS / 4);
1605 EXPECT(pcb->unacked != NULL);
1606 EXPECT(pcb->unacked->len == TCP_MSS / 2);
1607 #if TCP_OVERSIZE
1608 /* verify there is no oversized remaining since during the
1609 segment split, the remainder pbuf is always the exact length */
1610 EXPECT(pcb->unsent_oversize == 0);
1611 #if TCP_OVERSIZE_DBGCHECK
1612 /* Split segment already transmitted, should be at 0 */
1613 EXPECT(pcb->unacked->oversize_left == 0);
1614 /* Remainder segment should match pcb value (which is 0) */
1615 EXPECT(pcb->unsent->oversize_left == pcb->unsent_oversize);
1616 #endif /* TCP_OVERSIZE_DBGCHECK */
1617 #endif /* TCP_OVERSIZE */
1618
1619 /* verify first half segment */
1620 EXPECT(txcounters.tx_packets != NULL);
1621 if (txcounters.tx_packets != NULL) {
1622 u8_t sent[TCP_MSS / 2];
1623 u16_t ret;
1624 ret = pbuf_copy_partial(txcounters.tx_packets, &sent, TCP_MSS / 2, 40U);
1625 EXPECT(ret == TCP_MSS / 2);
1626 EXPECT(memcmp(sent, &tx_data[3 * TCP_MSS], TCP_MSS / 2) == 0);
1627 }
1628 if (txcounters.tx_packets != NULL) {
1629 pbuf_free(txcounters.tx_packets);
1630 txcounters.tx_packets = NULL;
1631 }
1632 memset(&txcounters, 0, sizeof(txcounters));
1633
1634 /* ACK the half segment, leave window at half segment */
1635 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_MSS / 2, TCP_ACK, TCP_MSS / 2);
1636 txcounters.copy_tx_packets = 1;
1637 test_tcp_input(p, &netif);
1638 txcounters.copy_tx_packets = 0;
1639 /* ensure remaining segment was sent */
1640 EXPECT(txcounters.num_tx_calls == 1);
1641 EXPECT(txcounters.num_tx_bytes == ((TCP_MSS / 4) + 40U));
1642 EXPECT(pcb->unsent == NULL);
1643 EXPECT(pcb->unacked != NULL);
1644 EXPECT(pcb->unacked->len == TCP_MSS / 4);
1645 EXPECT(pcb->snd_wnd == TCP_MSS / 2);
1646
1647 /* verify remainder segment */
1648 EXPECT(txcounters.tx_packets != NULL);
1649 if (txcounters.tx_packets != NULL) {
1650 u8_t sent[TCP_MSS / 4];
1651 u16_t ret;
1652 ret = pbuf_copy_partial(txcounters.tx_packets, &sent, TCP_MSS / 4, 40U);
1653 EXPECT(ret == TCP_MSS / 4);
1654 EXPECT(memcmp(sent, &tx_data[(3 * TCP_MSS) + TCP_MSS / 2], TCP_MSS / 4) == 0);
1655 }
1656 if (txcounters.tx_packets != NULL) {
1657 pbuf_free(txcounters.tx_packets);
1658 txcounters.tx_packets = NULL;
1659 }
1660
1661 /* ensure no errors have been recorded */
1662 EXPECT(counters.err_calls == 0);
1663 EXPECT(counters.last_err == ERR_OK);
1664
1665 /* make sure the pcb is freed */
1666 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
1667 tcp_abort(pcb);
1668 EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
1669 }
1670 END_TEST
1671
1672 /** Create the suite including all tests for this module */
1673 Suite *
tcp_suite(void)1674 tcp_suite(void)
1675 {
1676 testfunc tests[] = {
1677 TESTFUNC(test_tcp_new_abort),
1678 TESTFUNC(test_tcp_listen_passive_open),
1679 TESTFUNC(test_tcp_recv_inseq),
1680 TESTFUNC(test_tcp_recv_inseq_trim),
1681 TESTFUNC(test_tcp_passive_close),
1682 TESTFUNC(test_tcp_active_abort),
1683 TESTFUNC(test_tcp_malformed_header),
1684 TESTFUNC(test_tcp_fast_retx_recover),
1685 TESTFUNC(test_tcp_fast_rexmit_wraparound),
1686 TESTFUNC(test_tcp_rto_rexmit_wraparound),
1687 TESTFUNC(test_tcp_tx_full_window_lost_from_unacked),
1688 TESTFUNC(test_tcp_tx_full_window_lost_from_unsent),
1689 TESTFUNC(test_tcp_retx_add_to_sent),
1690 TESTFUNC(test_tcp_rto_tracking),
1691 TESTFUNC(test_tcp_rto_timeout),
1692 TESTFUNC(test_tcp_rto_timeout_link_down),
1693 TESTFUNC(test_tcp_rto_timeout_syn_sent),
1694 TESTFUNC(test_tcp_rto_timeout_syn_sent_link_down),
1695 TESTFUNC(test_tcp_zwp_timeout),
1696 TESTFUNC(test_tcp_zwp_timeout_link_down),
1697 TESTFUNC(test_tcp_persist_split)
1698 };
1699 return create_suite("TCP", tests, sizeof(tests)/sizeof(testfunc), tcp_setup, tcp_teardown);
1700 }
1701