66 static struct tcp_seg inseg;
67 static struct tcp_hdr *tcphdr;
68 static struct ip_hdr *iphdr;
69 static u32_t seqno, ackno;
73 static u8_t recv_flags;
74 static struct pbuf *recv_data;
76 struct tcp_pcb *tcp_input_pcb;
102 tcp_input(
struct pbuf *p,
struct netif *inp)
104 struct tcp_pcb *pcb, *prev;
105 struct tcp_pcb_listen *lpcb;
107 struct tcp_pcb *lpcb_prev =
NULL;
108 struct tcp_pcb_listen *lpcb_any =
NULL;
128 tcp_debug_print(tcphdr);
152 #if CHECKSUM_CHECK_TCP 160 tcp_debug_print(tcphdr);
172 hdrlen = TCPH_HDRLEN(tcphdr);
184 tcphdr->src =
ntohs(tcphdr->src);
185 tcphdr->dest =
ntohs(tcphdr->dest);
186 seqno = tcphdr->seqno =
ntohl(tcphdr->seqno);
187 ackno = tcphdr->ackno =
ntohl(tcphdr->ackno);
188 tcphdr->wnd =
ntohs(tcphdr->wnd);
190 flags = TCPH_FLAGS(tcphdr);
197 tcplen = p->
tot_len + ((flags & (TCP_FIN | TCP_SYN)) ? 1 : 0);
203 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->next) {
204 LWIP_ASSERT(
"tcp_input: active pcb->state != CLOSED", pcb->state != CLOSED);
205 LWIP_ASSERT(
"tcp_input: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
206 LWIP_ASSERT(
"tcp_input: active pcb->state != LISTEN", pcb->state != LISTEN);
207 if (pcb->remote_port == tcphdr->src &&
208 pcb->local_port == tcphdr->dest &&
215 LWIP_ASSERT(
"tcp_input: pcb->next != pcb (before cache)", pcb->next != pcb);
217 prev->next = pcb->next;
218 pcb->next = tcp_active_pcbs;
219 tcp_active_pcbs = pcb;
221 LWIP_ASSERT(
"tcp_input: pcb->next != pcb (after cache)", pcb->next != pcb);
230 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->next) {
231 LWIP_ASSERT(
"tcp_input: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
232 if (pcb->remote_port == tcphdr->src &&
233 pcb->local_port == tcphdr->dest &&
240 tcp_timewait_input(pcb);
249 for(lpcb = tcp_listen_pcbs.listen_pcbs; lpcb !=
NULL; lpcb = lpcb->next) {
250 if (lpcb->local_port == tcphdr->dest) {
268 prev = (
struct tcp_pcb *)lpcb;
283 ((
struct tcp_pcb_listen *)prev)->next = lpcb->next;
285 lpcb->next = tcp_listen_pcbs.listen_pcbs;
287 tcp_listen_pcbs.listen_pcbs = lpcb;
291 tcp_listen_input(lpcb);
299 tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
308 tcp_debug_print_state(pcb->state);
316 inseg.tcphdr = tcphdr;
322 if (pcb->refused_data !=
NULL) {
325 TCP_EVENT_RECV(pcb, pcb->refused_data,
ERR_OK, err);
327 pcb->refused_data =
NULL;
328 }
else if ((err ==
ERR_ABRT) || (tcplen > 0)) {
340 err = tcp_process(pcb);
344 if (recv_flags & TF_RESET) {
349 TCP_EVENT_ERR(pcb->errf, pcb->callback_arg,
ERR_RST);
350 tcp_pcb_remove(&tcp_active_pcbs, pcb);
352 }
else if (recv_flags & TF_CLOSED) {
355 if (!(pcb->flags & TF_RXCLOSED)) {
359 TCP_EVENT_ERR(pcb->errf, pcb->callback_arg,
ERR_CLSD);
361 tcp_pcb_remove(&tcp_active_pcbs, pcb);
368 if (pcb->acked > 0) {
369 TCP_EVENT_SENT(pcb, pcb->acked, err);
375 if (recv_data !=
NULL) {
377 if (pcb->flags & TF_RXCLOSED) {
389 if (flags & TCP_PSH) {
394 TCP_EVENT_RECV(pcb, recv_data,
ERR_OK, err);
401 pcb->refused_data = recv_data;
408 if (recv_flags & TF_GOT_FIN) {
415 TCP_EVENT_CLOSED(pcb, err);
421 tcp_input_pcb =
NULL;
426 tcp_debug_print_state(pcb->state);
434 tcp_input_pcb =
NULL;
446 extern char RxNodeNum(
void);
447 if (RxNodeNum() < 2){
448 extern void pbuf_free_ooseq_new(
void* arg);
450 pbuf_free_ooseq_new(
NULL);
458 if (!(TCPH_FLAGS(tcphdr) & TCP_RST)) {
461 tcp_rst(ackno, seqno + tcplen,
463 tcphdr->dest, tcphdr->src);
468 LWIP_ASSERT(
"tcp_input: tcp_pcbs_sane()", tcp_pcbs_sane());
490 tcp_listen_input(
struct tcp_pcb_listen *pcb)
492 struct tcp_pcb *npcb;
493 struct tcp_pcb *pactive_pcb;
494 u8_t active_pcb_num = 0;
499 if (flags & TCP_ACK) {
503 tcp_rst(ackno + 1, seqno + tcplen,
505 tcphdr->dest, tcphdr->src);
506 }
else if (flags & TCP_SYN) {
508 #if TCP_LISTEN_BACKLOG 509 if (pcb->accepts_pending >= pcb->backlog) {
514 for(pactive_pcb = tcp_active_pcbs; pactive_pcb !=
NULL; pactive_pcb = pactive_pcb->next)
521 npcb = tcp_alloc(pcb->prio);
531 #if TCP_LISTEN_BACKLOG 532 pcb->accepts_pending++;
537 npcb->local_port = pcb->local_port;
539 npcb->remote_port = tcphdr->src;
542 npcb->state = SYN_RCVD;
543 npcb->rcv_nxt = seqno + 1;
544 npcb->rcv_ann_right_edge = npcb->rcv_nxt;
545 npcb->snd_wnd = tcphdr->wnd;
546 npcb->ssthresh = npcb->snd_wnd;
547 npcb->snd_wl1 = seqno - 1;
548 npcb->callback_arg = pcb->callback_arg;
549 #if LWIP_CALLBACK_API 550 npcb->accept = pcb->accept;
556 TCP_REG(&tcp_active_pcbs, npcb);
560 #if TCP_CALCULATE_EFF_SEND_MSS 561 npcb->mss = tcp_eff_send_mss(npcb->mss, &(npcb->remote_ip));
567 rc = tcp_enqueue_flags(npcb, TCP_SYN | TCP_ACK);
569 tcp_abandon(npcb, 0);
572 return tcp_output(npcb);
593 tcp_timewait_input(
struct tcp_pcb *pcb)
596 if (flags & TCP_RST) {
600 if (flags & TCP_SYN) {
602 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt+pcb->rcv_wnd)) {
605 tcphdr->dest, tcphdr->src);
608 }
else if (flags & TCP_FIN) {
610 pcb->tmr = tcp_ticks;
614 pcb->flags |= TF_ACK_NOW;
615 return tcp_output(pcb);
632 tcp_process(
struct tcp_pcb *pcb)
634 struct tcp_seg *rseg;
641 if (flags & TCP_RST) {
643 if (pcb->state == SYN_SENT) {
644 if (ackno == pcb->snd_nxt) {
648 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
649 pcb->rcv_nxt+pcb->rcv_wnd)) {
656 LWIP_ASSERT(
"tcp_input: pcb->state != CLOSED", pcb->state != CLOSED);
657 recv_flags |= TF_RESET;
658 pcb->flags &= ~TF_ACK_DELAY;
662 seqno, pcb->rcv_nxt));
664 seqno, pcb->rcv_nxt));
669 if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) {
675 if ((pcb->flags & TF_RXCLOSED) == 0) {
677 pcb->tmr = tcp_ticks;
679 pcb->keep_cnt_sent = 0;
684 switch (pcb->state) {
687 pcb->snd_nxt,
ntohl(pcb->unacked->tcphdr->seqno)));
689 if ((flags & TCP_ACK) && (flags & TCP_SYN)
690 && ackno ==
ntohl(pcb->unacked->tcphdr->seqno) + 1) {
692 pcb->rcv_nxt = seqno + 1;
693 pcb->rcv_ann_right_edge = pcb->rcv_nxt;
694 pcb->lastack = ackno;
695 pcb->snd_wnd = tcphdr->wnd;
696 pcb->snd_wl1 = seqno - 1;
697 pcb->state = ESTABLISHED;
699 #if TCP_CALCULATE_EFF_SEND_MSS 700 pcb->mss = tcp_eff_send_mss(pcb->mss, &(pcb->remote_ip));
705 pcb->ssthresh = pcb->mss * 10;
707 pcb->cwnd = ((pcb->cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
708 LWIP_ASSERT(
"pcb->snd_queuelen > 0", (pcb->snd_queuelen > 0));
712 pcb->unacked = rseg->next;
716 if(pcb->unacked ==
NULL)
727 TCP_EVENT_CONNECTED(pcb,
ERR_OK, err);
734 else if (flags & TCP_ACK) {
737 tcphdr->dest, tcphdr->src);
741 if (flags & TCP_ACK) {
743 if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)) {
745 pcb->state = ESTABLISHED;
747 #if LWIP_CALLBACK_API 751 TCP_EVENT_ACCEPT(pcb,
ERR_OK, err);
761 old_cwnd = pcb->cwnd;
767 if (pcb->acked != 0) {
771 pcb->cwnd = ((old_cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
773 if (recv_flags & TF_GOT_FIN) {
775 pcb->state = CLOSE_WAIT;
780 tcphdr->dest, tcphdr->src);
782 }
else if ((flags & TCP_SYN) && (seqno == pcb->rcv_nxt - 1)) {
791 if (recv_flags & TF_GOT_FIN) {
793 pcb->state = CLOSE_WAIT;
798 if (recv_flags & TF_GOT_FIN) {
799 if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt)) {
801 (
"TCP connection closed: FIN_WAIT_1 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
804 TCP_RMV(&tcp_active_pcbs, pcb);
805 pcb->state = TIME_WAIT;
806 TCP_REG(&tcp_tw_pcbs, pcb);
809 pcb->state = CLOSING;
811 }
else if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt)) {
812 pcb->state = FIN_WAIT_2;
817 if (recv_flags & TF_GOT_FIN) {
821 TCP_RMV(&tcp_active_pcbs, pcb);
822 pcb->state = TIME_WAIT;
823 TCP_REG(&tcp_tw_pcbs, pcb);
828 if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
831 TCP_RMV(&tcp_active_pcbs, pcb);
832 pcb->state = TIME_WAIT;
833 TCP_REG(&tcp_tw_pcbs, pcb);
838 if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
841 recv_flags |= TF_CLOSED;
857 tcp_oos_insert_segment(
struct tcp_seg *cseg,
struct tcp_seg *next)
859 struct tcp_seg *old_seg;
861 if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) {
870 TCP_SEQ_GEQ((seqno + cseg->len),
871 (next->tcphdr->seqno + next->len))) {
873 if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) {
874 TCPH_SET_FLAG(cseg->tcphdr, TCP_FIN);
878 tcp_seg_free(old_seg);
881 TCP_SEQ_GT(seqno + cseg->len, next->tcphdr->seqno)) {
883 cseg->len = (
u16_t)(next->tcphdr->seqno - seqno);
904 tcp_receive(
struct tcp_pcb *pcb)
906 struct tcp_seg *next;
908 struct tcp_seg *prev, *cseg;
913 u32_t right_wnd_edge;
915 int found_dupack = 0;
917 if (
flags & TCP_ACK) {
918 right_wnd_edge = pcb->snd_wnd + pcb->snd_wl2;
925 if (TCP_SEQ_LT(pcb->snd_wl1, seqno) ||
926 (pcb->snd_wl1 == seqno && TCP_SEQ_LT(pcb->snd_wl2, ackno)) ||
927 (pcb->snd_wl2 == ackno && tcphdr->wnd > pcb->snd_wnd)) {
928 pcb->snd_wnd = tcphdr->wnd;
929 pcb->snd_wl1 = seqno;
930 pcb->snd_wl2 = ackno;
931 if (pcb->snd_wnd > 0 && pcb->persist_backoff > 0) {
932 pcb->persist_backoff = 0;
937 if (pcb->snd_wnd != tcphdr->wnd) {
939 (
"tcp_receive: no window update lastack %"U32_F
" ackno %" 940 U32_F
" wl1 %"U32_F
" seqno %"U32_F
" wl2 %"U32_F
"\n",
941 pcb->lastack, ackno, pcb->snd_wl1, seqno, pcb->snd_wl2));
967 if (TCP_SEQ_LEQ(ackno, pcb->lastack)) {
972 if (pcb->snd_wl2 + pcb->snd_wnd == right_wnd_edge){
974 if (pcb->rtime >= 0) {
976 if (pcb->lastack == ackno) {
978 if (pcb->dupacks + 1 > pcb->dupacks)
980 if (pcb->dupacks > 3) {
983 if ((
u16_t)(pcb->cwnd + pcb->mss) > pcb->cwnd) {
984 pcb->cwnd += pcb->mss;
986 }
else if (pcb->dupacks == 3) {
988 tcp_rexmit_fast(pcb);
999 }
else if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)){
1002 if (pcb->flags & TF_INFR) {
1003 pcb->flags &= ~TF_INFR;
1004 pcb->cwnd = pcb->ssthresh;
1011 pcb->rto = (pcb->sa >> 3) + pcb->sv;
1014 pcb->acked = (
u16_t)(ackno - pcb->lastack);
1016 pcb->snd_buf += pcb->acked;
1020 pcb->lastack = ackno;
1024 if (pcb->state >= ESTABLISHED) {
1025 if (pcb->cwnd < pcb->ssthresh) {
1026 if ((
u16_t)(pcb->cwnd + pcb->mss) > pcb->cwnd) {
1027 pcb->cwnd += pcb->mss;
1031 u16_t new_cwnd = (pcb->cwnd + pcb->mss * pcb->mss / pcb->cwnd);
1032 if (new_cwnd > pcb->cwnd) {
1033 pcb->cwnd = new_cwnd;
1040 pcb->unacked !=
NULL?
1041 ntohl(pcb->unacked->tcphdr->seqno): 0,
1042 pcb->unacked !=
NULL?
1043 ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked): 0));
1049 while (pcb->unacked !=
NULL &&
1050 TCP_SEQ_LEQ(
ntohl(pcb->unacked->tcphdr->seqno) +
1051 TCP_TCPLEN(pcb->unacked), ackno)) {
1053 ntohl(pcb->unacked->tcphdr->seqno),
1054 ntohl(pcb->unacked->tcphdr->seqno) +
1055 TCP_TCPLEN(pcb->unacked)));
1057 next = pcb->unacked;
1058 pcb->unacked = pcb->unacked->next;
1061 LWIP_ASSERT(
"pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >=
pbuf_clen(next->p)));
1063 if ((pcb->acked != 0) && ((TCPH_FLAGS(next->tcphdr) & TCP_FIN) != 0)) {
1067 pcb->snd_queuelen -=
pbuf_clen(next->p);
1071 if (pcb->snd_queuelen != 0) {
1072 LWIP_ASSERT(
"tcp_receive: valid queue length", pcb->unacked !=
NULL ||
1073 pcb->unsent !=
NULL);
1079 if(pcb->unacked ==
NULL)
1097 while (pcb->unsent !=
NULL &&
1098 TCP_SEQ_BETWEEN(ackno,
ntohl(pcb->unsent->tcphdr->seqno) +
1099 TCP_TCPLEN(pcb->unsent), pcb->snd_nxt)) {
1101 ntohl(pcb->unsent->tcphdr->seqno),
ntohl(pcb->unsent->tcphdr->seqno) +
1102 TCP_TCPLEN(pcb->unsent)));
1105 pcb->unsent = pcb->unsent->next;
1107 LWIP_ASSERT(
"pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >=
pbuf_clen(next->p)));
1109 if ((pcb->acked != 0) && ((TCPH_FLAGS(next->tcphdr) & TCP_FIN) != 0)) {
1112 pcb->snd_queuelen -=
pbuf_clen(next->p);
1115 if (pcb->snd_queuelen != 0) {
1117 pcb->unacked !=
NULL || pcb->unsent !=
NULL);
1123 pcb->rttest, pcb->rtseq, ackno));
1128 if (pcb->rttest && TCP_SEQ_LT(pcb->rtseq, ackno)) {
1131 m = (
s16_t)(tcp_ticks - pcb->rttest);
1134 m, m * TCP_SLOW_INTERVAL));
1137 m = m - (pcb->sa >> 3);
1142 m = m - (pcb->sv >> 2);
1144 pcb->rto = (pcb->sa >> 3) + pcb->sv;
1147 pcb->rto, pcb->rto * TCP_SLOW_INTERVAL));
1186 if (TCP_SEQ_BETWEEN(pcb->rcv_nxt, seqno + 1, seqno + tcplen - 1)){
1207 off = pcb->rcv_nxt - seqno;
1211 if (inseg.p->len < off) {
1213 new_tot_len = (
u16_t)(inseg.p->tot_len - off);
1214 while (p->
len < off) {
1233 inseg.len -= (
u16_t)(pcb->rcv_nxt - seqno);
1234 inseg.tcphdr->seqno = seqno = pcb->rcv_nxt;
1237 if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)){
1251 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
1252 pcb->rcv_nxt + pcb->rcv_wnd - 1)){
1253 if (pcb->rcv_nxt == seqno) {
1257 tcplen = TCP_TCPLEN(&inseg);
1259 if (tcplen > pcb->rcv_wnd) {
1261 (
"tcp_receive: other end overran receive window" 1262 "seqno %"U32_F
" len %"U16_F" right edge %"U32_F
"\n",
1263 seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
1264 if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
1267 TCPH_FLAGS_SET(inseg.tcphdr, TCPH_FLAGS(inseg.tcphdr) &~ TCP_FIN);
1270 inseg.len = pcb->rcv_wnd;
1271 if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) {
1275 tcplen = TCP_TCPLEN(&inseg);
1276 LWIP_ASSERT(
"tcp_receive: segment not trimmed correctly to rcv_wnd\n",
1277 (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd));
1283 if (pcb->ooseq !=
NULL) {
1284 if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
1286 (
"tcp_receive: received in-order FIN, binning ooseq queue\n"));
1290 while (pcb->ooseq !=
NULL) {
1291 struct tcp_seg *old_ooseq = pcb->ooseq;
1292 pcb->ooseq = pcb->ooseq->next;
1293 tcp_seg_free(old_ooseq);
1301 TCP_SEQ_GEQ(seqno + tcplen,
1302 next->tcphdr->seqno + next->len)) {
1304 if (TCPH_FLAGS(next->tcphdr) & TCP_FIN &&
1305 (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) == 0) {
1306 TCPH_SET_FLAG(inseg.tcphdr, TCP_FIN);
1307 tcplen = TCP_TCPLEN(&inseg);
1316 TCP_SEQ_GT(seqno + tcplen,
1317 next->tcphdr->seqno)) {
1319 inseg.len = (
u16_t)(next->tcphdr->seqno - seqno);
1320 if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) {
1324 tcplen = TCP_TCPLEN(&inseg);
1325 LWIP_ASSERT(
"tcp_receive: segment not trimmed correctly to ooseq queue\n",
1326 (seqno + tcplen) == next->tcphdr->seqno);
1333 pcb->rcv_nxt = seqno + tcplen;
1336 LWIP_ASSERT(
"tcp_receive: tcplen > rcv_wnd\n", pcb->rcv_wnd >= tcplen);
1337 pcb->rcv_wnd -= tcplen;
1339 tcp_update_rcv_ann_wnd(pcb);
1350 if (inseg.p->tot_len > 0) {
1351 recv_data = inseg.p;
1357 if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
1359 recv_flags |= TF_GOT_FIN;
1365 while (pcb->ooseq !=
NULL &&
1366 pcb->ooseq->tcphdr->seqno == pcb->rcv_nxt) {
1369 seqno = pcb->ooseq->tcphdr->seqno;
1371 pcb->rcv_nxt += TCP_TCPLEN(cseg);
1372 LWIP_ASSERT(
"tcp_receive: ooseq tcplen > rcv_wnd\n",
1373 pcb->rcv_wnd >= TCP_TCPLEN(cseg));
1374 pcb->rcv_wnd -= TCP_TCPLEN(cseg);
1376 tcp_update_rcv_ann_wnd(pcb);
1378 if (cseg->p->tot_len > 0) {
1384 recv_data = cseg->p;
1388 if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) {
1390 recv_flags |= TF_GOT_FIN;
1391 if (pcb->state == ESTABLISHED) {
1392 pcb->state = CLOSE_WAIT;
1396 pcb->ooseq = cseg->next;
1407 tcp_send_empty_ack(pcb);
1410 if (pcb->ooseq ==
NULL) {
1411 pcb->ooseq = tcp_seg_copy(&inseg);
1426 for(next = pcb->ooseq; next !=
NULL; next = next->next) {
1427 if (seqno == next->tcphdr->seqno) {
1432 if (inseg.len > next->len) {
1436 cseg = tcp_seg_copy(&inseg);
1443 tcp_oos_insert_segment(cseg, next);
1454 if (TCP_SEQ_LT(seqno, next->tcphdr->seqno)) {
1459 cseg = tcp_seg_copy(&inseg);
1462 tcp_oos_insert_segment(cseg, next);
1469 if (TCP_SEQ_BETWEEN(seqno, prev->tcphdr->seqno+1, next->tcphdr->seqno-1)) {
1475 cseg = tcp_seg_copy(&inseg);
1477 if (TCP_SEQ_GT(prev->tcphdr->seqno + prev->len, seqno)) {
1479 prev->len = (
u16_t)(seqno - prev->tcphdr->seqno);
1483 tcp_oos_insert_segment(cseg, next);
1491 if (next->next ==
NULL &&
1492 TCP_SEQ_GT(seqno, next->tcphdr->seqno)) {
1493 if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) {
1497 next->next = tcp_seg_copy(&inseg);
1498 if (next->next !=
NULL) {
1499 if (TCP_SEQ_GT(next->tcphdr->seqno + next->len, seqno)) {
1501 next->len = (
u16_t)(seqno - next->tcphdr->seqno);
1505 if ((
u32_t)tcplen + seqno > pcb->rcv_nxt + (
u32_t)pcb->rcv_wnd) {
1507 (
"tcp_receive: other end overran receive window" 1508 "seqno %"U32_F
" len %"U16_F" right edge %"U32_F
"\n",
1509 seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
1510 if (TCPH_FLAGS(next->next->tcphdr) & TCP_FIN) {
1513 TCPH_FLAGS_SET(next->next->tcphdr, TCPH_FLAGS(next->next->tcphdr) &~ TCP_FIN);
1516 next->next->len = pcb->rcv_nxt + pcb->rcv_wnd - seqno;
1518 tcplen = TCP_TCPLEN(next->next);
1519 LWIP_ASSERT(
"tcp_receive: segment not trimmed correctly to rcv_wnd\n",
1520 (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd));
1534 tcp_send_empty_ack(pcb);
1541 if(!TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd-1)){
1556 tcp_parseopt(
struct tcp_pcb *pcb)
1561 #if LWIP_TCP_TIMESTAMPS 1565 opts = (
u8_t *)tcphdr + TCP_HLEN;
1568 if(TCPH_HDRLEN(tcphdr) > 0x5) {
1569 max_c = (TCPH_HDRLEN(tcphdr) - 5) << 2;
1570 for (c = 0; c < max_c; ) {
1584 if (opts[c + 1] != 0x04 || c + 0x04 > max_c) {
1590 mss = (opts[c + 2] << 8) | opts[c + 3];
1596 #if LWIP_TCP_TIMESTAMPS 1599 if (opts[c + 1] != 0x0A || c + 0x0A > max_c) {
1605 tsval = (opts[c+2]) | (opts[c+3] << 8) |
1606 (opts[c+4] << 16) | (opts[c+5] << 24);
1607 if (flags & TCP_SYN) {
1608 pcb->ts_recent =
ntohl(tsval);
1609 pcb->flags |= TF_TIMESTAMP;
1610 }
else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno+tcplen)) {
1611 pcb->ts_recent =
ntohl(tsval);
1619 if (opts[c + 1] == 0) {
void memp_free(memp_t type, void *mem) ICACHE_FLASH_ATTR
#define snmp_inc_tcpinsegs()
#define ip_current_src_addr()
#define snmp_inc_tcpinerrs()
ip_addr_t current_iphdr_dest
const ip_addr_t ip_addr_any ICACHE_RODATA_ATTR
#define ICACHE_FLASH_ATTR
#define ip_current_dest_addr()
void pbuf_cat(struct pbuf *head, struct pbuf *tail) ICACHE_FLASH_ATTR
#define LWIP_DEBUGF(debug, message)
#define ip_addr_cmp(addr1, addr2)
#define ip_addr_copy(dest, src)
ip_addr_t current_iphdr_src
#define ip_addr_isany(addr1)
u8_t pbuf_free(struct pbuf *p) ICACHE_FLASH_ATTR
u16_t inet_chksum_pseudo(struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, u8_t proto, u16_t proto_len) ICACHE_FLASH_ATTR
#define ip_addr_isbroadcast(ipaddr, netif)
u8_t pbuf_header(struct pbuf *p, s16_t header_size) ICACHE_FLASH_ATTR
#define LWIP_ASSERT(message, assertion)
void pbuf_realloc(struct pbuf *p, u16_t size) ICACHE_FLASH_ATTR
#define ip_addr_ismulticast(addr1)
#define snmp_inc_tcppassiveopens()
u8_t pbuf_clen(struct pbuf *p) ICACHE_FLASH_ATTR