58#ifndef TCP_LOCAL_PORT_RANGE_START
61#define TCP_LOCAL_PORT_RANGE_START 0xc000
62#define TCP_LOCAL_PORT_RANGE_END 0xffff
63#define TCP_ENSURE_LOCAL_PORT_RANGE(port) (((port) & ~TCP_LOCAL_PORT_RANGE_START) + TCP_LOCAL_PORT_RANGE_START)
67#define TCP_KEEP_DUR(pcb) ((pcb)->keep_cnt * (pcb)->keep_intvl)
68#define TCP_KEEP_INTVL(pcb) ((pcb)->keep_intvl)
70#define TCP_KEEP_DUR(pcb) TCP_MAXIDLE
71#define TCP_KEEP_INTVL(pcb) TCP_KEEPINTVL_DEFAULT
74const char *
const tcp_state_str[] = {
89static u16_t tcp_port = TCP_LOCAL_PORT_RANGE_START;
93const u8_t tcp_backoff[13] =
94 { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};
96const u8_t tcp_persist_backoff[7] = { 3, 6, 12, 24, 48, 96, 120 };
101struct tcp_pcb *tcp_bound_pcbs;
103union tcp_listen_pcbs_t tcp_listen_pcbs;
106struct tcp_pcb *tcp_active_pcbs;
108struct tcp_pcb *tcp_tw_pcbs;
110#define NUM_TCP_PCB_LISTS 4
111#define NUM_TCP_PCB_LISTS_NO_TIME_WAIT 3
113struct tcp_pcb **
const tcp_pcb_lists[] = {&tcp_listen_pcbs.pcbs, &tcp_bound_pcbs,
114 &tcp_active_pcbs, &tcp_tw_pcbs};
117struct tcp_pcb *tcp_tmp_pcb;
119u8_t tcp_active_pcbs_changed;
122static u8_t tcp_timer;
123static u8_t tcp_timer_ctr;
124static u16_t tcp_new_port(
void);
132#if LWIP_RANDOMIZE_INITIAL_LOCAL_PORTS && defined(LWIP_RAND)
133 tcp_port = TCP_ENSURE_LOCAL_PORT_RANGE(LWIP_RAND());
146 if (++tcp_timer & 1) {
170tcp_close_shutdown(
struct tcp_pcb *pcb,
u8_t rst_on_unacked_data)
174 if (rst_on_unacked_data && ((pcb->state == ESTABLISHED) || (pcb->state == CLOSE_WAIT))) {
175 if ((pcb->refused_data !=
NULL) || (pcb->rcv_wnd !=
TCP_WND)) {
178 LWIP_ASSERT(
"pcb->flags & TF_RXCLOSED", pcb->flags & TF_RXCLOSED);
182 tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
183 pcb->local_port, pcb->remote_port);
187 if (pcb->state == ESTABLISHED) {
189 pcb->state = TIME_WAIT;
190 TCP_REG(&tcp_tw_pcbs, pcb);
199 switch (pcb->state) {
209 if (pcb->local_port != 0) {
210 TCP_RMV(&tcp_bound_pcbs, pcb);
217 tcp_pcb_remove(&tcp_listen_pcbs.pcbs, pcb);
223 TCP_PCB_REMOVE_ACTIVE(pcb);
229 err = tcp_send_fin(pcb);
232 pcb->state = FIN_WAIT_1;
236 err = tcp_send_fin(pcb);
239 pcb->state = FIN_WAIT_1;
243 err = tcp_send_fin(pcb);
246 pcb->state = LAST_ACK;
285tcp_close(
struct tcp_pcb *pcb)
289 tcp_debug_print_state(pcb->state);
292 if (pcb->state != LISTEN) {
294 pcb->flags |= TF_RXCLOSED;
297 return tcp_close_shutdown(pcb, 1);
313tcp_shutdown(
struct tcp_pcb *pcb,
int shut_rx,
int shut_tx)
315 if (pcb->state == LISTEN) {
320 pcb->flags |= TF_RXCLOSED;
323 return tcp_close_shutdown(pcb, 1);
326 if (pcb->refused_data !=
NULL) {
328 pcb->refused_data =
NULL;
334 switch (pcb->state) {
338 return tcp_close_shutdown(pcb, shut_rx);
357tcp_abandon(
struct tcp_pcb *pcb,
int reset)
366 LWIP_ASSERT(
"don't call tcp_abort/tcp_abandon for listen-pcbs",
367 pcb->state != LISTEN);
371 if (pcb->state == TIME_WAIT) {
372 tcp_pcb_remove(&tcp_tw_pcbs, pcb);
375 seqno = pcb->snd_nxt;
376 ackno = pcb->rcv_nxt;
380 errf_arg = pcb->callback_arg;
381 TCP_PCB_REMOVE_ACTIVE(pcb);
382 if (pcb->unacked !=
NULL) {
383 tcp_segs_free(pcb->unacked);
385 if (pcb->unsent !=
NULL) {
386 tcp_segs_free(pcb->unsent);
389 if (pcb->ooseq !=
NULL) {
390 tcp_segs_free(pcb->ooseq);
395 tcp_rst(seqno, ackno, &pcb->local_ip, &pcb->remote_ip, pcb->local_port, pcb->remote_port);
398 TCP_EVENT_ERR(errf, errf_arg,
ERR_ABRT);
413tcp_abort(
struct tcp_pcb *pcb)
436 int max_pcb_list = NUM_TCP_PCB_LISTS;
437 struct tcp_pcb *cpcb;
439 LWIP_ERROR(
"tcp_bind: can only bind in state CLOSED", pcb->state == CLOSED,
return ERR_VAL);
448 max_pcb_list = NUM_TCP_PCB_LISTS_NO_TIME_WAIT;
453 port = tcp_new_port();
460 for (i = 0; i < max_pcb_list; i++) {
461 for(cpcb = *tcp_pcb_lists[i]; cpcb !=
NULL; cpcb = cpcb->next) {
462 if (cpcb->local_port == port) {
484 pcb->local_port = port;
485 TCP_REG(&tcp_bound_pcbs, pcb);
494tcp_accept_null(
void *arg,
struct tcp_pcb *pcb,
err_t err)
519tcp_listen_with_backlog(
struct tcp_pcb *pcb,
u8_t backlog)
521 struct tcp_pcb_listen *lpcb;
524 LWIP_ERROR(
"tcp_listen: pcb already connected", pcb->state == CLOSED,
return NULL);
527 if (pcb->state == LISTEN) {
535 for(lpcb = tcp_listen_pcbs.listen_pcbs; lpcb !=
NULL; lpcb = lpcb->next) {
536 if (lpcb->local_port == pcb->local_port) {
537 if (
ip_addr_cmp(&lpcb->local_ip, &pcb->local_ip)) {
545 lpcb = (
struct tcp_pcb_listen *)
memp_malloc(MEMP_TCP_PCB_LISTEN);
549 lpcb->callback_arg = pcb->callback_arg;
550 lpcb->local_port = pcb->local_port;
551 lpcb->state = LISTEN;
552 lpcb->prio = pcb->prio;
553 lpcb->so_options = pcb->so_options;
555 lpcb->ttl = pcb->ttl;
556 lpcb->tos = pcb->tos;
558 if (pcb->local_port != 0) {
559 TCP_RMV(&tcp_bound_pcbs, pcb);
563 lpcb->accept = tcp_accept_null;
565#if TCP_LISTEN_BACKLOG
566 lpcb->accepts_pending = 0;
567 lpcb->backlog = (backlog ? backlog : 1);
569 TCP_REG(&tcp_listen_pcbs.pcbs, (
struct tcp_pcb *)lpcb);
570 return (
struct tcp_pcb *)lpcb;
579u32_t tcp_update_rcv_ann_wnd(
struct tcp_pcb *pcb)
581 u32_t new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd;
583 if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge +
LWIP_MIN((
TCP_WND / 2), pcb->mss))) {
585 pcb->rcv_ann_wnd = pcb->rcv_wnd;
586 return new_right_edge - pcb->rcv_ann_right_edge;
588 if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) {
591 pcb->rcv_ann_wnd = 0;
594 u32_t new_rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt;
595 LWIP_ASSERT(
"new_rcv_ann_wnd <= 0xffff", new_rcv_ann_wnd <= 0xffff);
596 pcb->rcv_ann_wnd = (
u16_t)new_rcv_ann_wnd;
611tcp_recved(
struct tcp_pcb *pcb,
u16_t len)
616 LWIP_ASSERT(
"don't call tcp_recved for listen-pcbs",
617 pcb->state != LISTEN);
618 LWIP_ASSERT(
"tcp_recved: len would wrap rcv_wnd\n",
619 len <= 0xffff - pcb->rcv_wnd );
626 wnd_inflation = tcp_update_rcv_ann_wnd(pcb);
638 len, pcb->rcv_wnd,
TCP_WND - pcb->rcv_wnd));
654 if (tcp_port++ == TCP_LOCAL_PORT_RANGE_END) {
655 tcp_port = TCP_LOCAL_PORT_RANGE_START;
658 for (i = 0; i < NUM_TCP_PCB_LISTS; i++) {
659 for(pcb = *tcp_pcb_lists[i]; pcb !=
NULL; pcb = pcb->next) {
660 if (pcb->local_port == tcp_port) {
661 if (++n > (TCP_LOCAL_PORT_RANGE_END - TCP_LOCAL_PORT_RANGE_START)) {
685 tcp_connected_fn connected)
689 u16_t old_local_port;
691 LWIP_ERROR(
"tcp_connect: can only connect from state CLOSED", pcb->state == CLOSED,
return ERR_ISCONN);
699 pcb->remote_port = port;
714 old_local_port = pcb->local_port;
715 if (pcb->local_port == 0) {
716 pcb->local_port = tcp_new_port();
717 if (pcb->local_port == 0) {
725 struct tcp_pcb *cpcb;
728 for (i = 2; i < NUM_TCP_PCB_LISTS; i++) {
729 for(cpcb = *tcp_pcb_lists[i]; cpcb !=
NULL; cpcb = cpcb->next) {
730 if ((cpcb->local_port == pcb->local_port) &&
731 (cpcb->remote_port == port) &&
741 iss = tcp_next_iss();
744 pcb->lastack = iss - 1;
745 pcb->snd_lbb = iss - 1;
748 pcb->rcv_ann_right_edge = pcb->rcv_nxt;
753#if TCP_CALCULATE_EFF_SEND_MSS
754 pcb->mss = tcp_eff_send_mss(pcb->mss,
ipaddr);
757 pcb->ssthresh = pcb->mss * 10;
759 pcb->connected = connected;
765 ret = tcp_enqueue_flags(pcb, TCP_SYN);
768 pcb->state = SYN_SENT;
769 if (old_local_port != 0) {
770 TCP_RMV(&tcp_bound_pcbs, pcb);
790 struct tcp_pcb *pcb, *prev;
804 pcb = tcp_active_pcbs;
808 while (pcb !=
NULL) {
810 LWIP_ASSERT(
"tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED);
811 LWIP_ASSERT(
"tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN);
812 LWIP_ASSERT(
"tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT);
813 if (pcb->last_timer == tcp_timer_ctr) {
818 pcb->last_timer = tcp_timer_ctr;
831 if (pcb->persist_backoff > 0) {
835 if (pcb->persist_cnt >= tcp_persist_backoff[pcb->persist_backoff-1]) {
836 pcb->persist_cnt = 0;
837 if (pcb->persist_backoff <
sizeof(tcp_persist_backoff)) {
838 pcb->persist_backoff++;
840 tcp_zero_window_probe(pcb);
844 if(pcb->rtime >= 0) {
848 if (pcb->unacked !=
NULL && pcb->rtime >= pcb->rto) {
851 " pcb->rto %"S16_F"\n",
852 pcb->rtime, pcb->rto));
856 if (pcb->state != SYN_SENT) {
857 pcb->rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[pcb->nrtx];
864 eff_wnd =
LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
865 pcb->ssthresh = eff_wnd >> 1;
866 if (pcb->ssthresh < (pcb->mss << 1)) {
867 pcb->ssthresh = (pcb->mss << 1);
869 pcb->cwnd = pcb->mss;
871 " ssthresh %"U16_F"\n",
872 pcb->cwnd, pcb->ssthresh));
881 if (pcb->state == FIN_WAIT_2) {
883 if (pcb->flags & TF_RXCLOSED) {
886 if ((
u32_t)(tcp_ticks - pcb->tmr) >
887 TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
896 ((pcb->state == ESTABLISHED) ||
897 (pcb->state == CLOSE_WAIT))) {
898 if((
u32_t)(tcp_ticks - pcb->tmr) >
899 (pcb->keep_idle + TCP_KEEP_DUR(pcb)) / TCP_SLOW_INTERVAL)
908 else if((
u32_t)(tcp_ticks - pcb->tmr) >
909 (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEP_INTVL(pcb))
913 pcb->keep_cnt_sent++;
921 if (pcb->ooseq !=
NULL &&
922 (
u32_t)tcp_ticks - pcb->tmr >= pcb->rto * TCP_OOSEQ_TIMEOUT) {
923 tcp_segs_free(pcb->ooseq);
930 if (pcb->state == SYN_RCVD) {
931 if ((
u32_t)(tcp_ticks - pcb->tmr) >
932 TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
939 if (pcb->state == LAST_ACK) {
940 if ((
u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
948 struct tcp_pcb *pcb2;
954 LWIP_ASSERT(
"tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
955 prev->next = pcb->next;
958 LWIP_ASSERT(
"tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
959 tcp_active_pcbs = pcb->next;
963 tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
964 pcb->local_port, pcb->remote_port);
968 err_arg = pcb->callback_arg;
973 tcp_active_pcbs_changed = 0;
974 TCP_EVENT_ERR(err_fn, err_arg,
ERR_ABRT);
975 if (tcp_active_pcbs_changed) {
976 goto tcp_slowtmr_start;
985 if (prev->polltmr >= prev->pollinterval) {
988 tcp_active_pcbs_changed = 0;
989 TCP_EVENT_POLL(prev, err);
990 if (tcp_active_pcbs_changed) {
991 goto tcp_slowtmr_start;
1005 while (pcb !=
NULL) {
1006 LWIP_ASSERT(
"tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
1010 if ((
u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
1018 struct tcp_pcb *pcb2;
1022 LWIP_ASSERT(
"tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
1023 prev->next = pcb->next;
1026 LWIP_ASSERT(
"tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
1027 tcp_tw_pcbs = pcb->next;
1048 struct tcp_pcb *pcb;
1053 pcb = tcp_active_pcbs;
1055 while(pcb !=
NULL) {
1056 if (pcb->last_timer != tcp_timer_ctr) {
1057 struct tcp_pcb *
next;
1058 pcb->last_timer = tcp_timer_ctr;
1060 if (pcb->flags & TF_ACK_DELAY) {
1064 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
1070 if (pcb->refused_data !=
NULL) {
1071 tcp_active_pcbs_changed = 0;
1072 tcp_process_refused_data(pcb);
1073 if (tcp_active_pcbs_changed) {
1075 goto tcp_fasttmr_start;
1085tcp_process_refused_data(
struct tcp_pcb *pcb)
1088 u8_t refused_flags = pcb->refused_data->flags;
1091 struct pbuf *refused_data = pcb->refused_data;
1092 pcb->refused_data =
NULL;
1095 TCP_EVENT_RECV(pcb, refused_data,
ERR_OK, err);
1101 if (pcb->rcv_wnd !=
TCP_WND) {
1104 TCP_EVENT_CLOSED(pcb, err);
1117 pcb->refused_data = refused_data;
1128tcp_segs_free(
struct tcp_seg *seg)
1130 while (seg !=
NULL) {
1143tcp_seg_free(
struct tcp_seg *seg)
1146 if (seg->p !=
NULL) {
1163tcp_setprio(
struct tcp_pcb *pcb,
u8_t prio)
1177tcp_seg_copy(
struct tcp_seg *seg)
1179 struct tcp_seg *cseg;
1181 cseg = (
struct tcp_seg *)
memp_malloc(MEMP_TCP_SEG);
1191#if LWIP_CALLBACK_API
1197tcp_recv_null(
void *arg,
struct tcp_pcb *pcb,
struct pbuf *p,
err_t err)
1203 }
else if (err ==
ERR_OK) {
1204 return tcp_close(pcb);
1217tcp_kill_prio(
u8_t prio)
1219 struct tcp_pcb *pcb, *inactive;
1224 mprio = TCP_PRIO_MAX;
1229 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
1230 if (pcb->prio <= prio &&
1231 pcb->prio <= mprio &&
1232 (
u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
1233 inactivity = tcp_ticks - pcb->tmr;
1238 if (inactive !=
NULL) {
1240 (
void *)inactive, inactivity));
1241 tcp_abort(inactive);
1250tcp_kill_timewait(
void)
1252 struct tcp_pcb *pcb, *inactive;
1258 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
1259 if ((
u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
1260 inactivity = tcp_ticks - pcb->tmr;
1264 if (inactive !=
NULL) {
1266 (
void *)inactive, inactivity));
1267 tcp_abort(inactive);
1280 struct tcp_pcb *pcb;
1283 pcb = (
struct tcp_pcb *)
memp_malloc(MEMP_TCP_PCB);
1287 tcp_kill_timewait();
1289 pcb = (
struct tcp_pcb *)
memp_malloc(MEMP_TCP_PCB);
1293 tcp_kill_prio(prio);
1295 pcb = (
struct tcp_pcb *)
memp_malloc(MEMP_TCP_PCB);
1307 memset(pcb, 0,
sizeof(
struct tcp_pcb));
1310 pcb->snd_queuelen = 0;
1318 pcb->rto = 3000 / TCP_SLOW_INTERVAL;
1320 pcb->sv = 3000 / TCP_SLOW_INTERVAL;
1323 iss = tcp_next_iss();
1328 pcb->tmr = tcp_ticks;
1329 pcb->last_timer = tcp_timer_ctr;
1333#if LWIP_CALLBACK_API
1334 pcb->recv = tcp_recv_null;
1338 pcb->keep_idle = TCP_KEEPIDLE_DEFAULT;
1340#if LWIP_TCP_KEEPALIVE
1341 pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT;
1342 pcb->keep_cnt = TCP_KEEPCNT_DEFAULT;
1345 pcb->keep_cnt_sent = 0;
1365 return tcp_alloc(TCP_PRIO_NORMAL);
1376tcp_arg(
struct tcp_pcb *pcb,
void *arg)
1380 pcb->callback_arg = arg;
1382#if LWIP_CALLBACK_API
1392tcp_recv(
struct tcp_pcb *pcb, tcp_recv_fn recv)
1394 LWIP_ASSERT(
"invalid socket state for recv callback", pcb->state != LISTEN);
1406tcp_sent(
struct tcp_pcb *pcb, tcp_sent_fn sent)
1408 LWIP_ASSERT(
"invalid socket state for sent callback", pcb->state != LISTEN);
1421tcp_err(
struct tcp_pcb *pcb, tcp_err_fn err)
1423 LWIP_ASSERT(
"invalid socket state for err callback", pcb->state != LISTEN);
1436tcp_accept(
struct tcp_pcb *pcb, tcp_accept_fn accept)
1440 pcb->accept = accept;
1452tcp_poll(
struct tcp_pcb *pcb, tcp_poll_fn poll,
u8_t interval)
1454 LWIP_ASSERT(
"invalid socket state for poll", pcb->state != LISTEN);
1455#if LWIP_CALLBACK_API
1460 pcb->pollinterval = interval;
1470tcp_pcb_purge(
struct tcp_pcb *pcb)
1472 if (pcb->state != CLOSED &&
1473 pcb->state != TIME_WAIT &&
1474 pcb->state != LISTEN) {
1478#if TCP_LISTEN_BACKLOG
1479 if (pcb->state == SYN_RCVD) {
1481 struct tcp_pcb_listen *lpcb;
1482 LWIP_ASSERT(
"tcp_pcb_purge: pcb->state == SYN_RCVD but tcp_listen_pcbs is NULL",
1483 tcp_listen_pcbs.listen_pcbs !=
NULL);
1484 for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb !=
NULL; lpcb = lpcb->next) {
1485 if ((lpcb->local_port == pcb->local_port) &&
1489 LWIP_ASSERT(
"tcp_pcb_purge: listen pcb does not have accepts pending",
1490 lpcb->accepts_pending > 0);
1491 lpcb->accepts_pending--;
1499 if (pcb->refused_data !=
NULL) {
1502 pcb->refused_data =
NULL;
1504 if (pcb->unsent !=
NULL) {
1507 if (pcb->unacked !=
NULL) {
1511 if (pcb->ooseq !=
NULL) {
1514 tcp_segs_free(pcb->ooseq);
1522 tcp_segs_free(pcb->unsent);
1523 tcp_segs_free(pcb->unacked);
1524 pcb->unacked = pcb->unsent =
NULL;
1526 pcb->unsent_oversize = 0;
1538tcp_pcb_remove(
struct tcp_pcb **pcblist,
struct tcp_pcb *pcb)
1540 TCP_RMV(pcblist, pcb);
1545 if (pcb->state != TIME_WAIT &&
1546 pcb->state != LISTEN &&
1547 pcb->flags & TF_ACK_DELAY) {
1548 pcb->flags |= TF_ACK_NOW;
1552 if (pcb->state != LISTEN) {
1560 pcb->state = CLOSED;
1562 LWIP_ASSERT(
"tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
1573 static u32_t iss = 6510;
1579#if TCP_CALCULATE_EFF_SEND_MSS
1589 struct netif *outif;
1592 if ((outif !=
NULL) && (outif->
mtu != 0)) {
1598 sendmss =
LWIP_MIN(sendmss, mss_s);
1605tcp_debug_state_str(
enum tcp_state s)
1607 return tcp_state_str[s];
1610#if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG
1617tcp_debug_print(
struct tcp_hdr *
tcphdr)
1632 TCPH_FLAGS(
tcphdr) >> 5 & 1,
1633 TCPH_FLAGS(
tcphdr) >> 4 & 1,
1634 TCPH_FLAGS(
tcphdr) >> 3 & 1,
1635 TCPH_FLAGS(
tcphdr) >> 2 & 1,
1636 TCPH_FLAGS(
tcphdr) >> 1 & 1,
1639 tcp_debug_print_flags(TCPH_FLAGS(
tcphdr));
1653tcp_debug_print_state(
enum tcp_state s)
1666 if (
flags & TCP_FIN) {
1669 if (
flags & TCP_SYN) {
1672 if (
flags & TCP_RST) {
1675 if (
flags & TCP_PSH) {
1678 if (
flags & TCP_ACK) {
1681 if (
flags & TCP_URG) {
1684 if (
flags & TCP_ECE) {
1687 if (
flags & TCP_CWR) {
1697tcp_debug_print_pcbs(
void)
1699 struct tcp_pcb *pcb;
1701 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
1703 pcb->local_port, pcb->remote_port,
1704 pcb->snd_nxt, pcb->rcv_nxt));
1705 tcp_debug_print_state(pcb->state);
1708 for(pcb = (
struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb !=
NULL; pcb = pcb->next) {
1710 pcb->local_port, pcb->remote_port,
1711 pcb->snd_nxt, pcb->rcv_nxt));
1712 tcp_debug_print_state(pcb->state);
1715 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
1717 pcb->local_port, pcb->remote_port,
1718 pcb->snd_nxt, pcb->rcv_nxt));
1719 tcp_debug_print_state(pcb->state);
1729 struct tcp_pcb *pcb;
1730 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
1731 LWIP_ASSERT(
"tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED);
1732 LWIP_ASSERT(
"tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN);
1733 LWIP_ASSERT(
"tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
1735 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
1736 LWIP_ASSERT(
"tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
#define LWIP_UNUSED_ARG(x)
#define LWIP_DEBUGF(debug, message)
#define LWIP_ERROR(message, expression, handler)
#define LWIP_ASSERT(message, assertion)
struct netif * ip_route(ip_addr_t *dest)
#define ip_set_option(pcb, opt)
#define ip_get_option(pcb, opt)
#define ip_addr_cmp(addr1, addr2)
#define ip_addr_isany(addr1)
#define ip4_addr1_16(ipaddr)
#define ip4_addr2_16(ipaddr)
#define ip_addr_copy(dest, src)
typedefPACK_STRUCT_END struct ip_addr ip_addr_t
#define ip4_addr3_16(ipaddr)
#define ip4_addr4_16(ipaddr)
void * memp_malloc(memp_t type)
void memp_free(memp_t type, void *mem)
#define TCP_WND_UPDATE_THRESHOLD
#define SMEMCPY(dst, src, len)
void pbuf_ref(struct pbuf *p)
u8_t pbuf_free(struct pbuf *p)
#define PBUF_FLAG_TCP_FIN
#define snmp_inc_tcpattemptfails()
#define snmp_inc_tcpestabresets()
#define snmp_inc_tcpactiveopens()
#define MEMP_STATS_DEC(x, i)