Lines Matching refs:pcb
84 struct tcp_pcb* pcb;
89 pcb = tcp_new();
90 fail_unless(pcb != NULL);
91 if (pcb != NULL) {
93 tcp_abort(pcb);
102 struct tcp_pcb *pcb, *pcbl;
118 pcb = tcp_new();
119 EXPECT_RET(pcb != NULL);
120 err = tcp_bind(pcb, &netif.ip_addr, 1234);
122 pcbl = tcp_listen(pcb);
124 EXPECT_RET(pcbl != pcb);
158 /** Create an ESTABLISHED pcb and check if receive callback is called */
162 struct tcp_pcb* pcb;
178 /* create and initialize the pcb */
179 pcb = test_tcp_new_counters_pcb(&counters);
180 EXPECT_RET(pcb != NULL);
181 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
184 p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
196 /* make sure the pcb is freed */
198 tcp_abort(pcb);
203 /** Create an ESTABLISHED pcb and check if receive callback is called if a segment
208 struct tcp_pcb* pcb;
226 /* create and initialize the pcb */
227 pcb = test_tcp_new_counters_pcb(&counters);
228 EXPECT_RET(pcb != NULL);
229 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
232 p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, (u32_t)(0-(data_len-new_data_len)), 0, 0);
250 /* make sure the pcb is freed */
252 tcp_abort(pcb);
257 static err_t test_tcp_recv_expect1byte(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err);
260 test_tcp_recv_expectclose(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
262 EXPECT_RETX(pcb != NULL, ERR_OK);
270 err_t err2 = tcp_close(pcb);
273 tcp_recv(pcb, test_tcp_recv_expect1byte);
279 test_tcp_recv_expect1byte(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
281 EXPECT_RETX(pcb != NULL, ERR_OK);
287 tcp_recv(pcb, test_tcp_recv_expectclose);
301 struct tcp_pcb* pcb;
316 /* create and initialize the pcb */
317 pcb = test_tcp_new_counters_pcb(&counters);
318 EXPECT_RET(pcb != NULL);
319 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
322 p = tcp_create_rx_segment(pcb, &data, 1, 0, 0, TCP_FIN);
325 tcp_recv(pcb, test_tcp_recv_expect1byte);
329 /* don't free the pcb here (part of the test!) */
336 struct tcp_pcb* pcb;
352 /* create and initialize the pcb */
353 pcb = test_tcp_new_counters_pcb(&counters);
354 EXPECT_RET(pcb != NULL);
355 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
357 /* abort the pcb */
360 tcp_abort(pcb);
376 /* don't free the pcb here (part of the test!) */
384 struct tcp_pcb* pcb;
401 /* create and initialize the pcb */
402 pcb = test_tcp_new_counters_pcb(&counters);
403 EXPECT_RET(pcb != NULL);
404 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
407 p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
435 /* make sure the pcb is freed */
437 tcp_abort(pcb);
450 struct tcp_pcb* pcb;
465 /* create and initialize the pcb */
466 pcb = test_tcp_new_counters_pcb(&counters);
467 EXPECT_RET(pcb != NULL);
468 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
469 pcb->mss = TCP_MSS;
471 pcb->cwnd = pcb->snd_wnd;
474 err = tcp_write(pcb, data1, sizeof(data1), TCP_WRITE_FLAG_COPY);
476 err = tcp_output(pcb);
482 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 4, TCP_ACK);
486 EXPECT_RET(pcb->unacked == NULL);
488 err = tcp_write(pcb, data2, sizeof(data2), TCP_WRITE_FLAG_COPY);
490 err = tcp_output(pcb);
496 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
500 EXPECT_RET(pcb->dupacks == 1);
502 err = tcp_write(pcb, data3, sizeof(data3), TCP_WRITE_FLAG_COPY);
504 err = tcp_output(pcb);
511 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
515 EXPECT_RET(pcb->dupacks == 2);
517 err = tcp_write(pcb, data4, sizeof(data4), TCP_WRITE_FLAG_COPY);
520 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
524 EXPECT_RET(pcb->dupacks == 3);
529 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
531 /*err = tcp_output(pcb);
540 err = tcp_write(pcb, data6, TCP_MSS, TCP_WRITE_FLAG_COPY);
545 err = tcp_output(pcb);
552 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
554 err = tcp_output(pcb);
557 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
559 err = tcp_output(pcb);
562 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
564 err = tcp_output(pcb);
567 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
569 err = tcp_output(pcb);
573 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 12, TCP_ACK);
579 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
581 err = tcp_output(pcb);
584 err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
586 err = tcp_output(pcb);
591 p1 = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
603 /* make sure the pcb is freed */
605 tcp_abort(pcb);
632 struct tcp_pcb* pcb;
647 /* create and initialize the pcb */
649 pcb = test_tcp_new_counters_pcb(&counters);
650 EXPECT_RET(pcb != NULL);
651 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
652 pcb->mss = TCP_MSS;
654 pcb->cwnd = 2*TCP_MSS;
656 pcb->ssthresh = pcb->cwnd;
660 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
664 check_seqnos(pcb->unsent, 6, seqnos);
665 EXPECT(pcb->unacked == NULL);
666 err = tcp_output(pcb);
671 check_seqnos(pcb->unacked, 2, seqnos);
672 check_seqnos(pcb->unsent, 4, &seqnos[2]);
675 p = tcp_create_rx_segment(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK);
683 check_seqnos(pcb->unacked, 2, &seqnos[1]);
684 check_seqnos(pcb->unsent, 3, &seqnos[3]);
687 EXPECT(pcb->dupacks == 0);
688 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
691 EXPECT(pcb->dupacks == 1);
692 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
695 EXPECT(pcb->dupacks == 2);
697 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
699 EXPECT(pcb->dupacks == 3);
702 EXPECT(pcb->unsent == NULL);
703 check_seqnos(pcb->unacked, 5, &seqnos[1]);
705 /* make sure the pcb is freed */
707 tcp_abort(pcb);
720 struct tcp_pcb* pcb;
735 /* create and initialize the pcb */
739 pcb = test_tcp_new_counters_pcb(&counters);
740 EXPECT_RET(pcb != NULL);
741 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
742 pcb->mss = TCP_MSS;
744 pcb->cwnd = 2*TCP_MSS;
748 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
752 check_seqnos(pcb->unsent, 6, seqnos);
753 EXPECT(pcb->unacked == NULL);
754 err = tcp_output(pcb);
759 check_seqnos(pcb->unacked, 2, seqnos);
760 check_seqnos(pcb->unsent, 4, &seqnos[2]);
770 check_seqnos(pcb->unacked, 1, seqnos);
771 check_seqnos(pcb->unsent, 5, &seqnos[1]);
774 pcb->cwnd = pcb->snd_wnd;
776 err = tcp_output(pcb);
779 EXPECT(pcb->unsent == NULL);
780 check_seqnos(pcb->unacked, 6, seqnos);
782 /* make sure the pcb is freed */
784 tcp_abort(pcb);
796 struct tcp_pcb* pcb;
820 /* create and initialize the pcb */
821 pcb = test_tcp_new_counters_pcb(&counters);
822 EXPECT_RET(pcb != NULL);
823 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
824 pcb->mss = TCP_MSS;
826 pcb->cwnd = pcb->snd_wnd;
832 err = tcp_write(pcb, &tx_data[sent_total], initial_data_len, TCP_WRITE_FLAG_COPY);
834 err = tcp_output(pcb);
842 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
844 err = tcp_output(pcb);
853 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
859 EXPECT(pcb->persist_backoff == 0);
861 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
864 err = tcp_output(pcb);
869 EXPECT(pcb->persist_backoff == 0);
873 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_WND, TCP_ACK, 0);
879 EXPECT(pcb->snd_wnd == 0);
880 EXPECT(pcb->persist_backoff == 0);
884 err = tcp_write(pcb, &tx_data[sent_total], 1, TCP_WRITE_FLAG_COPY);
886 err = tcp_output(pcb);
893 EXPECT(pcb->persist_backoff == 0);
895 EXPECT(pcb->persist_backoff == 1);
924 /* make sure the pcb is freed */
926 tcp_abort(pcb);
951 struct tcp_pcb* pcb;
967 /* create and initialize the pcb */
968 pcb = test_tcp_new_counters_pcb(&counters);
969 EXPECT_RET(pcb != NULL);
970 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
971 pcb->mss = TCP_MSS;
973 pcb->cwnd = pcb->snd_wnd;
976 err = tcp_write(pcb, data1a, sizeof(data1a), TCP_WRITE_FLAG_COPY);
978 err = tcp_write(pcb, data1b, sizeof(data1b), TCP_WRITE_FLAG_COPY);
980 err = tcp_output(pcb);
986 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 4, TCP_ACK);
990 EXPECT_RET(pcb->unacked == NULL);
992 err = tcp_write(pcb, data2a, sizeof(data2a), TCP_WRITE_FLAG_COPY);
994 err = tcp_write(pcb, data2b, sizeof(data2b), TCP_WRITE_FLAG_COPY);
996 err = tcp_output(pcb);
1002 err = tcp_write(pcb, data3, sizeof(data3), TCP_WRITE_FLAG_COPY);
1004 err = tcp_output(pcb);
1011 EXPECT_RET(pcb->unacked != NULL);
1012 EXPECT_RET(pcb->unsent != NULL);
1015 tcp_nagle_disable(pcb);
1027 EXPECT_RET(pcb->unacked != NULL);
1028 EXPECT_RET(pcb->unsent == NULL);
1031 tcp_nagle_enable(pcb);
1043 EXPECT_RET(pcb->unacked != NULL);
1044 EXPECT_RET(pcb->unsent != NULL);
1048 err = tcp_write(pcb, data4, sizeof(data4), TCP_WRITE_FLAG_COPY);
1051 tcp_nagle_disable(pcb);
1052 err = tcp_output(pcb);
1058 /* make sure the pcb is freed */
1060 tcp_abort(pcb);
1070 struct tcp_pcb* pcb;
1085 /* create and initialize the pcb */
1087 pcb = test_tcp_new_counters_pcb(&counters);
1088 EXPECT_RET(pcb != NULL);
1089 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1090 pcb->mss = TCP_MSS;
1092 pcb->cwnd = 5*TCP_MSS;
1096 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
1100 check_seqnos(pcb->unsent, 5, seqnos);
1101 EXPECT(pcb->unacked == NULL);
1102 err = tcp_output(pcb);
1107 EXPECT(pcb->unsent == NULL);
1108 check_seqnos(pcb->unacked, 5, seqnos);
1111 while (!(pcb->flags & TF_RTO)) {
1115 check_seqnos(pcb->unsent, 4, &seqnos[1]);
1117 check_seqnos(pcb->unacked, 1, seqnos);
1122 EXPECT(pcb->rto_end == seqnos[5]);
1123 EXPECT(pcb->rto_end == pcb->snd_nxt);
1125 EXPECT(pcb->cwnd == pcb->mss);
1128 err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
1131 check_seqnos(pcb->unsent, 5, &seqnos[1]);
1135 EXPECT(pcb->rto_end == pcb->snd_nxt);
1138 p = tcp_create_rx_segment(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK);
1144 check_seqnos(pcb->unacked, 2, &seqnos[1]);
1145 check_seqnos(pcb->unsent, 3, &seqnos[3]);
1147 EXPECT(pcb->flags & TF_RTO);
1149 EXPECT(pcb->cwnd == (tcpwnd_size_t)(2 * pcb->mss));
1151 EXPECT(pcb->rto_end == pcb->snd_nxt);
1154 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 2*TCP_MSS, TCP_ACK);
1160 check_seqnos(pcb->unacked, 3, &seqnos[3]);
1161 EXPECT(pcb->unsent == NULL);
1163 EXPECT(pcb->flags & TF_RTO);
1165 EXPECT(pcb->cwnd == (tcpwnd_size_t)(3 * pcb->mss));
1167 EXPECT(TCP_SEQ_GT(pcb->snd_nxt, pcb->rto_end));
1170 p = tcp_create_rx_segment(pcb, NULL, 0, 0, 2*TCP_MSS, TCP_ACK);
1172 EXPECT(!(pcb->flags & TF_RTO));
1173 check_seqnos(pcb->unacked, 1, &seqnos[5]);
1175 EXPECT(pcb->cwnd == (tcpwnd_size_t)(3 * pcb->mss));
1176 EXPECT(pcb->cwnd >= pcb->ssthresh);
1178 EXPECT(pcb->bytes_acked == (tcpwnd_size_t)(2 * pcb->mss));
1180 /* make sure the pcb is freed */
1182 tcp_abort(pcb);
1192 struct tcp_pcb *pcb, *cur;
1206 /* create and initialize the pcb */
1208 pcb = test_tcp_new_counters_pcb(&counters);
1209 EXPECT_RET(pcb != NULL);
1210 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1211 pcb->mss = TCP_MSS;
1212 pcb->cwnd = TCP_MSS;
1215 err = tcp_write(pcb, &tx_data[0], TCP_MSS, TCP_WRITE_FLAG_COPY);
1217 err = tcp_output(pcb);
1227 for (i = 0; !(pcb->flags & TF_RTO) && i < max_wait_ctr; i++) {
1233 EXPECT(pcb->nrtx == 1);
1260 /* check the connection (pcb) has been aborted */
1263 /* check our pcb is no longer active */
1265 EXPECT(cur != pcb);
1289 struct tcp_pcb *pcb, *cur;
1304 /* create and initialize the pcb */
1306 pcb = test_tcp_new_counters_pcb(&counters);
1307 EXPECT_RET(pcb != NULL);
1308 err = tcp_connect(pcb, &netif.gw, 123, NULL);
1310 EXPECT_RET(pcb->state == SYN_SENT);
1322 for (i = 0; !(pcb->flags & TF_RTO) && i < max_wait_ctr; i++) {
1328 EXPECT(pcb->nrtx == 1);
1356 /* check the connection (pcb) has been aborted */
1359 /* check our pcb is no longer active */
1361 EXPECT(cur != pcb);
1385 struct tcp_pcb *pcb, *cur;
1399 /* create and initialize the pcb */
1401 pcb = test_tcp_new_counters_pcb(&counters);
1402 EXPECT_RET(pcb != NULL);
1403 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1404 pcb->mss = TCP_MSS;
1405 pcb->cwnd = TCP_MSS;
1408 err = tcp_write(pcb, &tx_data[0], TCP_MSS, TCP_WRITE_FLAG_COPY);
1410 err = tcp_output(pcb);
1414 EXPECT(pcb->unsent == NULL);
1415 check_seqnos(pcb->unacked, 1, seqnos);
1421 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK, 0);
1423 EXPECT(pcb->unacked == NULL);
1424 EXPECT(pcb->unsent == NULL);
1426 EXPECT(pcb->persist_backoff == 0);
1427 EXPECT(pcb->snd_wnd == 0);
1430 err = tcp_write(pcb, &tx_data[TCP_MSS], TCP_MSS, TCP_WRITE_FLAG_COPY);
1432 err = tcp_output(pcb);
1436 EXPECT(pcb->unacked == NULL);
1437 check_seqnos(pcb->unsent, 1, &seqnos[1]);
1440 EXPECT(pcb->persist_backoff == 1);
1447 EXPECT(pcb->persist_probe == 0);
1448 while (pcb->persist_probe == 0) {
1456 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, 0, TCP_ACK, 0);
1459 EXPECT(pcb->persist_backoff > 1);
1460 EXPECT(pcb->persist_probe == 0);
1461 EXPECT(pcb->snd_wnd == 0);
1485 /* check the connection (pcb) has been aborted */
1488 /* check our pcb is no longer active */
1490 EXPECT(cur != pcb);
1514 struct tcp_pcb *pcb;
1529 /* create and initialize the pcb */
1531 pcb = test_tcp_new_counters_pcb(&counters);
1532 EXPECT_RET(pcb != NULL);
1533 tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
1534 pcb->mss = TCP_MSS;
1536 pcb->cwnd = 3 * TCP_MSS;
1537 pcb->snd_wnd = 3 * TCP_MSS;
1538 pcb->snd_wnd_max = 3 * TCP_MSS;
1542 err = tcp_write(pcb, &tx_data[0], (3 * TCP_MSS) + (TCP_MSS - (TCP_MSS / 4)), TCP_WRITE_FLAG_COPY);
1544 err = tcp_output(pcb);
1548 EXPECT(pcb->unacked != NULL);
1549 check_seqnos(pcb->unacked, 3, seqnos);
1554 EXPECT(pcb->unsent != NULL);
1555 EXPECT(pcb->unsent->len == TCP_MSS - (TCP_MSS / 4));
1556 check_seqnos(pcb->unsent, 1, &seqnos[3]);
1558 EXPECT(pcb->unsent_oversize == TCP_MSS / 4);
1560 EXPECT(pcb->unsent->oversize_left == pcb->unsent_oversize);
1566 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, 3 * TCP_MSS, TCP_ACK, TCP_MSS / 2);
1568 EXPECT(pcb->unacked == NULL);
1569 EXPECT(pcb->snd_wnd == TCP_MSS / 2);
1570 EXPECT(pcb->unsent != NULL);
1571 check_seqnos(pcb->unsent, 1, &seqnos[3]);
1575 EXPECT(pcb->persist_backoff == 1);
1594 EXPECT(pcb->persist_backoff == 0);
1598 EXPECT(pcb->unsent != NULL);
1599 EXPECT(pcb->unsent->len == TCP_MSS / 4);
1600 EXPECT(pcb->unacked != NULL);
1601 EXPECT(pcb->unacked->len == TCP_MSS / 2);
1605 EXPECT(pcb->unsent_oversize == 0);
1608 EXPECT(pcb->unacked->oversize_left == 0);
1609 /* Remainder segement should match pcb value (which is 0) */
1610 EXPECT(pcb->unsent->oversize_left == pcb->unsent_oversize);
1630 p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_MSS / 2, TCP_ACK, TCP_MSS / 2);
1637 EXPECT(pcb->unsent == NULL);
1638 EXPECT(pcb->unacked != NULL);
1639 EXPECT(pcb->unacked->len == TCP_MSS / 4);
1640 EXPECT(pcb->snd_wnd == TCP_MSS / 2);
1660 /* make sure the pcb is freed */
1662 tcp_abort(pcb);