83 { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};
90 struct tcp_pcb *tcp_bound_pcbs;
92 union tcp_listen_pcbs_t tcp_listen_pcbs;
95 struct tcp_pcb *tcp_active_pcbs;
97 struct tcp_pcb *tcp_tw_pcbs;
99 #define NUM_TCP_PCB_LISTS 4 100 #define NUM_TCP_PCB_LISTS_NO_TIME_WAIT 3 103 &tcp_active_pcbs, &tcp_tw_pcbs};
106 struct tcp_pcb *tcp_tmp_pcb;
109 static u8_t tcp_timer;
110 static u16_t tcp_new_port(
void);
122 if (++tcp_timer & 1) {
146 tcp_close_shutdown(
struct tcp_pcb *pcb,
u8_t rst_on_unacked_data)
150 if (rst_on_unacked_data && (pcb->state != LISTEN)) {
151 if ((pcb->refused_data !=
NULL) || (pcb->rcv_wnd !=
TCP_WND)) {
154 LWIP_ASSERT(
"pcb->flags & TF_RXCLOSED", pcb->flags & TF_RXCLOSED);
158 tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
159 pcb->local_port, pcb->remote_port);
166 TCP_RMV(&tcp_active_pcbs, pcb);
167 pcb->state = TIME_WAIT;
168 TCP_REG(&tcp_tw_pcbs, pcb);
174 switch (pcb->state) {
189 if (pcb->local_port != 0) {
190 TCP_RMV(&tcp_bound_pcbs, pcb);
197 tcp_pcb_remove(&tcp_listen_pcbs.pcbs, pcb);
203 tcp_pcb_remove(&tcp_active_pcbs, pcb);
209 err = tcp_send_fin(pcb);
212 pcb->state = FIN_WAIT_1;
216 err = tcp_send_fin(pcb);
219 pcb->state = FIN_WAIT_1;
223 err = tcp_send_fin(pcb);
226 pcb->state = LAST_ACK;
273 tcp_close(
struct tcp_pcb *pcb)
275 #if TCP_DEBUG //TCP debug��Ϣ����ӡpcb��״̬ 277 tcp_debug_print_state(pcb->state);
280 if (pcb->state != LISTEN) {
282 pcb->flags |= TF_RXCLOSED;
285 return tcp_close_shutdown(pcb, 1);
299 tcp_shutdown(
struct tcp_pcb *pcb,
int shut_rx,
int shut_tx)
301 if (pcb->state == LISTEN) {
306 if (pcb->refused_data !=
NULL) {
308 pcb->refused_data =
NULL;
311 pcb->flags |= TF_RXCLOSED;
316 switch (pcb->state) {
320 return tcp_close_shutdown(pcb, 0);
339 tcp_abandon(
struct tcp_pcb *pcb,
int reset)
342 u16_t remote_port, local_port;
344 #if LWIP_CALLBACK_API 350 LWIP_ASSERT(
"don't call tcp_abort/tcp_abandon for listen-pcbs",
351 pcb->state != LISTEN);
355 if (pcb->state == TIME_WAIT) {
356 tcp_pcb_remove(&tcp_tw_pcbs, pcb);
359 seqno = pcb->snd_nxt;
360 ackno = pcb->rcv_nxt;
363 local_port = pcb->local_port;
364 remote_port = pcb->remote_port;
365 #if LWIP_CALLBACK_API 368 errf_arg = pcb->callback_arg;
369 tcp_pcb_remove(&tcp_active_pcbs, pcb);
370 if (pcb->unacked !=
NULL) {
371 tcp_segs_free(pcb->unacked);
373 if (pcb->unsent !=
NULL) {
374 tcp_segs_free(pcb->unsent);
377 if (pcb->ooseq !=
NULL) {
378 tcp_segs_free(pcb->ooseq);
383 tcp_rst(seqno, ackno, &local_ip, &remote_ip, local_port, remote_port);
385 TCP_EVENT_ERR(errf, errf_arg,
ERR_ABRT);
401 tcp_abort(
struct tcp_pcb *pcb)
423 int max_pcb_list = NUM_TCP_PCB_LISTS;
424 struct tcp_pcb *cpcb;
435 max_pcb_list = NUM_TCP_PCB_LISTS_NO_TIME_WAIT;
440 port = tcp_new_port();
444 for (i = 0; i < max_pcb_list; i++) {
446 if (cpcb->local_port == port) {
467 pcb->local_ip = *ipaddr;
469 pcb->local_port = port;
470 TCP_REG(&tcp_bound_pcbs, pcb);
474 #if LWIP_CALLBACK_API 479 tcp_accept_null(
void *arg,
struct tcp_pcb *pcb,
err_t err)
504 tcp_listen_with_backlog(
struct tcp_pcb *pcb,
u8_t backlog)
506 struct tcp_pcb_listen *lpcb;
509 LWIP_ERROR(
"tcp_listen: pcb already connected", pcb->state == CLOSED,
return NULL);
512 if (pcb->state == LISTEN) {
520 for(lpcb = tcp_listen_pcbs.listen_pcbs; lpcb !=
NULL; lpcb = lpcb->next) {
521 if (lpcb->local_port == pcb->local_port) {
522 if (
ip_addr_cmp(&lpcb->local_ip, &pcb->local_ip)) {
530 lpcb = (
struct tcp_pcb_listen *)
memp_malloc(MEMP_TCP_PCB_LISTEN);
534 lpcb->callback_arg = pcb->callback_arg;
535 lpcb->local_port = pcb->local_port;
536 lpcb->state = LISTEN;
537 lpcb->prio = pcb->prio;
538 lpcb->so_options = pcb->so_options;
540 lpcb->ttl = pcb->ttl;
541 lpcb->tos = pcb->tos;
543 if (pcb->local_port != 0) {
544 TCP_RMV(&tcp_bound_pcbs, pcb);
547 #if LWIP_CALLBACK_API 548 lpcb->accept = tcp_accept_null;
550 #if TCP_LISTEN_BACKLOG 551 lpcb->accepts_pending = 0;
552 lpcb->backlog = (backlog ? backlog : 1);
554 TCP_REG(&tcp_listen_pcbs.pcbs, (
struct tcp_pcb *)lpcb);
555 return (
struct tcp_pcb *)lpcb;
564 u32_t tcp_update_rcv_ann_wnd(
struct tcp_pcb *pcb)
566 u32_t new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd;
568 if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge +
LWIP_MIN((
TCP_WND / 2), pcb->mss))) {
570 pcb->rcv_ann_wnd = pcb->rcv_wnd;
571 return new_right_edge - pcb->rcv_ann_right_edge;
573 if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) {
576 pcb->rcv_ann_wnd = 0;
579 u32_t new_rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt;
580 LWIP_ASSERT(
"new_rcv_ann_wnd <= 0xffff", new_rcv_ann_wnd <= 0xffff);
581 pcb->rcv_ann_wnd = (
u16_t)new_rcv_ann_wnd;
596 tcp_recved(
struct tcp_pcb *pcb,
u16_t len)
600 LWIP_ASSERT(
"tcp_recved: len would wrap rcv_wnd\n",
601 len <= 0xffff - pcb->rcv_wnd );
608 wnd_inflation = tcp_update_rcv_ann_wnd(pcb);
620 len, pcb->rcv_wnd,
TCP_WND - pcb->rcv_wnd));
634 #ifndef TCP_LOCAL_PORT_RANGE_START 635 #define TCP_LOCAL_PORT_RANGE_START 1024 636 #define TCP_LOCAL_PORT_RANGE_END 0x7fff 638 static u16_t port = TCP_LOCAL_PORT_RANGE_START;
645 port %= TCP_LOCAL_PORT_RANGE_END;
646 if (port < TCP_LOCAL_PORT_RANGE_START)
647 port += TCP_LOCAL_PORT_RANGE_START;
649 for (i = 0; i < NUM_TCP_PCB_LISTS; i++) {
651 if (pcb->local_port == port) {
673 tcp_connected_fn connected)
677 u16_t old_local_port;
679 LWIP_ERROR(
"tcp_connect: can only connected from state CLOSED", pcb->state == CLOSED,
return ERR_ISCONN);
682 if (ipaddr !=
NULL) {
683 pcb->remote_ip = *ipaddr;
687 pcb->remote_port = port;
702 old_local_port = pcb->local_port;
703 if (pcb->local_port == 0) {
704 pcb->local_port = tcp_new_port();
711 struct tcp_pcb *cpcb;
714 for (i = 2; i < NUM_TCP_PCB_LISTS; i++) {
716 if ((cpcb->local_port == pcb->local_port) &&
717 (cpcb->remote_port == port) &&
727 iss = tcp_next_iss();
730 pcb->lastack = iss - 1;
731 pcb->snd_lbb = iss - 1;
734 pcb->rcv_ann_right_edge = pcb->rcv_nxt;
739 #if TCP_CALCULATE_EFF_SEND_MSS 740 pcb->mss = tcp_eff_send_mss(pcb->mss, ipaddr);
743 pcb->ssthresh = pcb->mss * 10;
744 #if LWIP_CALLBACK_API 745 pcb->connected = connected;
751 ret = tcp_enqueue_flags(pcb, TCP_SYN);
754 pcb->state = SYN_SENT;
755 if (old_local_port != 0) {
756 TCP_RMV(&tcp_bound_pcbs, pcb);
758 TCP_REG(&tcp_active_pcbs, pcb);
776 struct tcp_pcb *pcb, *prev;
788 pcb = tcp_active_pcbs;
792 while (pcb !=
NULL) {
794 LWIP_ASSERT(
"tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED);
795 LWIP_ASSERT(
"tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN);
796 LWIP_ASSERT(
"tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT);
809 if (pcb->persist_backoff > 0) {
813 if (pcb->persist_cnt >= system_get_data_of_array_8(tcp_persist_backoff, pcb->persist_backoff-1)) {
814 pcb->persist_cnt = 0;
815 if (pcb->persist_backoff <
sizeof(tcp_persist_backoff)) {
816 pcb->persist_backoff++;
818 tcp_zero_window_probe(pcb);
825 if (pcb->unacked !=
NULL && pcb->rtime >= pcb->rto) {
828 " pcb->rto %"S16_F"\n",
829 pcb->rtime, pcb->rto));
833 if (pcb->state != SYN_SENT) {
834 pcb->rto = ((pcb->sa >> 3) + pcb->sv) << system_get_data_of_array_8(tcp_backoff, pcb->nrtx);
843 eff_wnd =
LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
844 pcb->ssthresh = eff_wnd >> 1;
845 if (pcb->ssthresh < (pcb->mss << 1)) {
846 pcb->ssthresh = (pcb->mss << 1);
848 pcb->cwnd = pcb->mss;
850 " ssthresh %"U16_F"\n",
851 pcb->cwnd, pcb->ssthresh));
860 if (pcb->state == FIN_WAIT_2) {
861 if ((
u32_t)(tcp_ticks - pcb->tmr) >
862 TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
870 ((pcb->state == ESTABLISHED) ||
871 (pcb->state == CLOSE_WAIT))) {
872 #if LWIP_TCP_KEEPALIVE 873 if((
u32_t)(tcp_ticks - pcb->tmr) >
874 (pcb->keep_idle + (pcb->keep_cnt*pcb->keep_intvl))
877 if((
u32_t)(tcp_ticks - pcb->tmr) >
878 (pcb->keep_idle + TCP_MAXIDLE) / TCP_SLOW_INTERVAL)
888 #if LWIP_TCP_KEEPALIVE 889 else if((
u32_t)(tcp_ticks - pcb->tmr) >
890 (pcb->keep_idle + pcb->keep_cnt_sent * pcb->keep_intvl)
893 else if((
u32_t)(tcp_ticks - pcb->tmr) >
894 (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEPINTVL_DEFAULT)
899 pcb->keep_cnt_sent++;
907 if (pcb->ooseq !=
NULL &&
908 (
u32_t)tcp_ticks - pcb->tmr >= pcb->rto * TCP_OOSEQ_TIMEOUT) {
909 tcp_segs_free(pcb->ooseq);
916 if (pcb->state == SYN_RCVD) {
917 if ((
u32_t)(tcp_ticks - pcb->tmr) >
918 TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
925 if (pcb->state == LAST_ACK) {
926 if ((
u32_t)(tcp_ticks - pcb->tmr) > 2 *
TCP_MSL / TCP_SLOW_INTERVAL) {
934 struct tcp_pcb *pcb2;
938 LWIP_ASSERT(
"tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
939 prev->next = pcb->next;
942 LWIP_ASSERT(
"tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
943 tcp_active_pcbs = pcb->next;
947 tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
948 pcb->local_port, pcb->remote_port);
951 TCP_EVENT_ERR(pcb->errf, pcb->callback_arg,
ERR_ABRT);
962 if (prev->polltmr >= prev->pollinterval) {
965 TCP_EVENT_POLL(prev, err);
978 while (pcb !=
NULL) {
979 LWIP_ASSERT(
"tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
983 if ((
u32_t)(tcp_ticks - pcb->tmr) > 2 *
TCP_MSL / TCP_SLOW_INTERVAL) {
991 struct tcp_pcb *pcb2;
995 LWIP_ASSERT(
"tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
996 prev->next = pcb->next;
999 LWIP_ASSERT(
"tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
1000 tcp_tw_pcbs = pcb->next;
1021 struct tcp_pcb *pcb = tcp_active_pcbs;
1023 while(pcb !=
NULL) {
1024 struct tcp_pcb *next = pcb->next;
1026 if (pcb->refused_data !=
NULL) {
1030 TCP_EVENT_RECV(pcb, pcb->refused_data,
ERR_OK, err);
1032 pcb->refused_data =
NULL;
1040 if (pcb && (pcb->flags & TF_ACK_DELAY)) {
1044 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
1057 tcp_segs_free(
struct tcp_seg *seg)
1059 while (seg !=
NULL) {
1060 struct tcp_seg *next = seg->next;
1072 tcp_seg_free(
struct tcp_seg *seg)
1075 if (seg->p !=
NULL) {
1092 tcp_setprio(
struct tcp_pcb *pcb,
u8_t prio)
1106 tcp_seg_copy(
struct tcp_seg *seg)
1108 struct tcp_seg *cseg;
1110 cseg = (
struct tcp_seg *)
memp_malloc(MEMP_TCP_SEG);
1120 #if LWIP_CALLBACK_API 1126 tcp_recv_null(
void *arg,
struct tcp_pcb *pcb,
struct pbuf *p,
err_t err)
1132 }
else if (err ==
ERR_OK) {
1133 return tcp_close(pcb);
1145 tcp_kill_prio(
u8_t prio)
1147 struct tcp_pcb *pcb, *inactive;
1152 mprio = TCP_PRIO_MAX;
1157 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
1158 if (pcb->prio <= prio &&
1159 pcb->prio <= mprio &&
1160 (
u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
1161 inactivity = tcp_ticks - pcb->tmr;
1166 if (inactive !=
NULL) {
1168 (
void *)inactive, inactivity));
1169 tcp_abort(inactive);
1178 tcp_kill_timewait(
void)
1180 struct tcp_pcb *pcb, *inactive;
1186 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
1187 if ((
u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
1188 inactivity = tcp_ticks - pcb->tmr;
1192 if (inactive !=
NULL) {
1194 (
void *)inactive, inactivity));
1195 tcp_abort(inactive);
1206 tcp_alloc(
u8_t prio)
1208 struct tcp_pcb *pcb;
1211 pcb = (
struct tcp_pcb *)
memp_malloc(MEMP_TCP_PCB);
1216 tcp_kill_timewait();
1218 pcb = (
struct tcp_pcb *)
memp_malloc(MEMP_TCP_PCB);
1222 tcp_kill_prio(prio);
1224 pcb = (
struct tcp_pcb *)
memp_malloc(MEMP_TCP_PCB);
1236 os_memset(pcb, 0,
sizeof(
struct tcp_pcb));
1239 pcb->snd_queuelen = 0;
1247 pcb->rto = 1000 / TCP_SLOW_INTERVAL;
1249 pcb->sv = 1000 / TCP_SLOW_INTERVAL;
1252 iss = tcp_next_iss();
1257 pcb->tmr = tcp_ticks;
1261 #if LWIP_CALLBACK_API 1262 pcb->recv = tcp_recv_null;
1266 pcb->keep_idle = TCP_KEEPIDLE_DEFAULT;
1268 #if LWIP_TCP_KEEPALIVE 1269 pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT;
1270 pcb->keep_cnt = TCP_KEEPCNT_DEFAULT;
1273 pcb->keep_cnt_sent = 0;
1293 return tcp_alloc(TCP_PRIO_NORMAL);
1305 tcp_arg(
struct tcp_pcb *pcb,
void *arg)
1307 pcb->callback_arg = arg;
1309 #if LWIP_CALLBACK_API 1319 tcp_recv(
struct tcp_pcb *pcb, tcp_recv_fn recv)
1332 tcp_sent(
struct tcp_pcb *pcb, tcp_sent_fn sent)
1346 tcp_err(
struct tcp_pcb *pcb, tcp_err_fn err)
1360 tcp_accept(
struct tcp_pcb *pcb, tcp_accept_fn accept)
1362 pcb->accept = accept;
1374 tcp_poll(
struct tcp_pcb *pcb, tcp_poll_fn poll,
u8_t interval)
1376 #if LWIP_CALLBACK_API 1381 pcb->pollinterval = interval;
1391 tcp_pcb_purge(
struct tcp_pcb *pcb)
1393 if (pcb->state != CLOSED &&
1394 pcb->state != TIME_WAIT &&
1395 pcb->state != LISTEN) {
1399 #if TCP_LISTEN_BACKLOG 1400 if (pcb->state == SYN_RCVD) {
1402 struct tcp_pcb_listen *lpcb;
1403 LWIP_ASSERT(
"tcp_pcb_purge: pcb->state == SYN_RCVD but tcp_listen_pcbs is NULL",
1404 tcp_listen_pcbs.listen_pcbs !=
NULL);
1405 for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb !=
NULL; lpcb = lpcb->next) {
1406 if ((lpcb->local_port == pcb->local_port) &&
1410 LWIP_ASSERT(
"tcp_pcb_purge: listen pcb does not have accepts pending",
1411 lpcb->accepts_pending > 0);
1412 lpcb->accepts_pending--;
1420 if (pcb->refused_data !=
NULL) {
1423 pcb->refused_data =
NULL;
1425 if (pcb->unsent !=
NULL) {
1428 if (pcb->unacked !=
NULL) {
1432 if (pcb->ooseq !=
NULL) {
1435 tcp_segs_free(pcb->ooseq);
1443 tcp_segs_free(pcb->unsent);
1444 tcp_segs_free(pcb->unacked);
1445 pcb->unacked = pcb->unsent =
NULL;
1447 pcb->unsent_oversize = 0;
1459 tcp_pcb_remove(
struct tcp_pcb **pcblist,
struct tcp_pcb *pcb)
1461 TCP_RMV(pcblist, pcb);
1466 if (pcb->state != TIME_WAIT &&
1467 pcb->state != LISTEN &&
1468 pcb->flags & TF_ACK_DELAY) {
1469 pcb->flags |= TF_ACK_NOW;
1473 if (pcb->state != LISTEN) {
1481 pcb->state = CLOSED;
1483 LWIP_ASSERT(
"tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
1494 static u32_t iss = 6510;
1504 #if TCP_CALCULATE_EFF_SEND_MSS 1514 struct netif *outif;
1517 if ((outif !=
NULL) && (outif->
mtu != 0)) {
1523 sendmss =
LWIP_MIN(sendmss, mss_s);
1531 tcp_debug_state_str(
enum tcp_state s)
1533 system_get_string_from_flash(tcp_state_str_rodata[s], tcp_state_str, 12);
1535 return tcp_state_str;
1541 #undef LWIP_DBG_TYPES_ON 1542 #define LWIP_DBG_TYPES_ON TCP_DEBUG 1544 #define LWIP_DEBUGF(debug, message) DEBUG_printf message 1545 #if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG 1552 tcp_debug_print(
struct tcp_hdr *tcphdr)
1560 ntohl(tcphdr->seqno)));
1563 ntohl(tcphdr->ackno)));
1565 LWIP_DEBUGF(
TCP_DEBUG, (
"| %2"U16_F
" | |%"U16_F
"%"U16_F
"%"U16_F
"%"U16_F
"%"U16_F
"%"U16_F
"| %5"U16_F
" | (hdrlen, flags (",
1566 TCPH_HDRLEN(tcphdr),
1567 TCPH_FLAGS(tcphdr) >> 5 & 1,
1568 TCPH_FLAGS(tcphdr) >> 4 & 1,
1569 TCPH_FLAGS(tcphdr) >> 3 & 1,
1570 TCPH_FLAGS(tcphdr) >> 2 & 1,
1571 TCPH_FLAGS(tcphdr) >> 1 & 1,
1572 TCPH_FLAGS(tcphdr) & 1,
1573 ntohs(tcphdr->wnd)));
1574 tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
1578 ntohs(tcphdr->chksum),
ntohs(tcphdr->urgp)));
1588 tcp_debug_print_state(
enum tcp_state s)
1601 if (flags & TCP_FIN) {
1604 if (flags & TCP_SYN) {
1607 if (flags & TCP_RST) {
1610 if (flags & TCP_PSH) {
1613 if (flags & TCP_ACK) {
1616 if (flags & TCP_URG) {
1619 if (flags & TCP_ECE) {
1622 if (flags & TCP_CWR) {
1632 tcp_debug_print_pcbs(
void)
1634 struct tcp_pcb *pcb;
1636 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
1638 pcb->local_port, pcb->remote_port,
1639 pcb->snd_nxt, pcb->rcv_nxt));
1640 tcp_debug_print_state(pcb->state);
1643 for(pcb = (
struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb !=
NULL; pcb = pcb->next) {
1645 pcb->local_port, pcb->remote_port,
1646 pcb->snd_nxt, pcb->rcv_nxt));
1647 tcp_debug_print_state(pcb->state);
1650 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
1652 pcb->local_port, pcb->remote_port,
1653 pcb->snd_nxt, pcb->rcv_nxt));
1654 tcp_debug_print_state(pcb->state);
1664 struct tcp_pcb *pcb;
1665 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
1666 LWIP_ASSERT(
"tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED);
1667 LWIP_ASSERT(
"tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN);
1668 LWIP_ASSERT(
"tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
1670 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
1671 LWIP_ASSERT(
"tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
#define ip4_addr3_16(ipaddr)
void memp_free(memp_t type, void *mem) ICACHE_FLASH_ATTR
#define SMEMCPY(dst, src, len)
#define snmp_inc_tcpestabresets()
const ip_addr_t ip_addr_any ICACHE_RODATA_ATTR
#define ICACHE_FLASH_ATTR
void * memp_malloc(memp_t type) ICACHE_FLASH_ATTR
#define LWIP_ERROR(message, expression, handler)
struct netif * ip_route(ip_addr_t *dest) ICACHE_FLASH_ATTR
#define snmp_inc_tcpactiveopens()
struct tcp_pcb **const tcp_pcb_lists[]
#define LWIP_DEBUGF(debug, message)
#define ip_addr_cmp(addr1, addr2)
#define ip_addr_copy(dest, src)
unsigned long os_random(void)
typedefPACK_STRUCT_END struct ip_addr ip_addr_t
#define ip4_addr4_16(ipaddr)
#define ip_addr_isany(addr1)
u8_t pbuf_free(struct pbuf *p) ICACHE_FLASH_ATTR
void pbuf_ref(struct pbuf *p) ICACHE_FLASH_ATTR
#define ip4_addr1_16(ipaddr)
#define LWIP_ASSERT(message, assertion)
#define TCP_WND_UPDATE_THRESHOLD
#define MEMP_STATS_DEC(x, i)
#define ip4_addr2_16(ipaddr)
#define snmp_inc_tcpattemptfails()
#define LWIP_UNUSED_ARG(x)