50#include "lwip/ip_addr.h"
62static struct tcp_seg inseg;
64static struct ip_hdr *iphdr;
65static u32_t seqno, ackno;
69static u8_t recv_flags;
70static struct pbuf *recv_data;
72struct tcp_pcb *tcp_input_pcb;
75static err_t tcp_process(
struct tcp_pcb *pcb);
76static void tcp_receive(
struct tcp_pcb *pcb);
77static void tcp_parseopt(
struct tcp_pcb *pcb);
79static err_t tcp_listen_input(
struct tcp_pcb_listen *pcb);
80static err_t tcp_timewait_input(
struct tcp_pcb *pcb);
94 struct tcp_pcb *pcb, *prev;
95 struct tcp_pcb_listen *lpcb;
97 struct tcp_pcb *lpcb_prev =
NULL;
98 struct tcp_pcb_listen *lpcb_any =
NULL;
108 iphdr = (
struct ip_hdr *)
p->payload;
130#if CHECKSUM_CHECK_TCP
147 hdrlen = TCPH_HDRLEN(
tcphdr);
163 tcplen =
p->tot_len + ((
flags & (TCP_FIN | TCP_SYN)) ? 1 : 0);
170 for(pcb = tcp_active_pcbs; pcb !=
NULL; pcb = pcb->
next) {
171 LWIP_ASSERT(
"tcp_input: active pcb->state != CLOSED", pcb->state != CLOSED);
172 LWIP_ASSERT(
"tcp_input: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
173 LWIP_ASSERT(
"tcp_input: active pcb->state != LISTEN", pcb->state != LISTEN);
174 if (pcb->remote_port ==
tcphdr->src &&
182 LWIP_ASSERT(
"tcp_input: pcb->next != pcb (before cache)", pcb->next != pcb);
184 prev->next = pcb->next;
185 pcb->next = tcp_active_pcbs;
186 tcp_active_pcbs = pcb;
188 LWIP_ASSERT(
"tcp_input: pcb->next != pcb (after cache)", pcb->next != pcb);
197 for(pcb = tcp_tw_pcbs; pcb !=
NULL; pcb = pcb->
next) {
198 LWIP_ASSERT(
"tcp_input: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
199 if (pcb->remote_port ==
tcphdr->src &&
207 tcp_timewait_input(pcb);
216 for(lpcb = tcp_listen_pcbs.listen_pcbs; lpcb !=
NULL; lpcb = lpcb->
next) {
235 prev = (
struct tcp_pcb *)lpcb;
250 ((
struct tcp_pcb_listen *)prev)->
next = lpcb->next;
252 lpcb->next = tcp_listen_pcbs.listen_pcbs;
254 tcp_listen_pcbs.listen_pcbs = lpcb;
258 tcp_listen_input(lpcb);
266 tcp_debug_print_flags(TCPH_FLAGS(
tcphdr));
275 tcp_debug_print_state(pcb->state);
281 inseg.len =
p->tot_len;
288 if (
flags & TCP_PSH) {
293 if (pcb->refused_data !=
NULL) {
294 if ((tcp_process_refused_data(pcb) ==
ERR_ABRT) ||
295 ((pcb->refused_data !=
NULL) && (tcplen > 0))) {
304 err = tcp_process(pcb);
308 if (recv_flags & TF_RESET) {
313 TCP_EVENT_ERR(pcb->errf, pcb->callback_arg,
ERR_RST);
314 tcp_pcb_remove(&tcp_active_pcbs, pcb);
316 }
else if (recv_flags & TF_CLOSED) {
319 if (!(pcb->flags & TF_RXCLOSED)) {
323 TCP_EVENT_ERR(pcb->errf, pcb->callback_arg,
ERR_CLSD);
325 tcp_pcb_remove(&tcp_active_pcbs, pcb);
332 if (pcb->acked > 0) {
333 TCP_EVENT_SENT(pcb, pcb->acked,
err);
339 if (recv_data !=
NULL) {
341 if (pcb->flags & TF_RXCLOSED) {
350 TCP_EVENT_RECV(pcb, recv_data,
ERR_OK,
err);
357 pcb->refused_data = recv_data;
364 if (recv_flags & TF_GOT_FIN) {
365 if (pcb->refused_data !=
NULL) {
374 TCP_EVENT_CLOSED(pcb,
err);
381 tcp_input_pcb =
NULL;
386 tcp_debug_print_state(pcb->state);
394 tcp_input_pcb =
NULL;
408 if (!(TCPH_FLAGS(
tcphdr) & TCP_RST)) {
411 tcp_rst(ackno, seqno + tcplen,
418 LWIP_ASSERT(
"tcp_input: tcp_pcbs_sane()", tcp_pcbs_sane());
440tcp_listen_input(
struct tcp_pcb_listen *pcb)
442 struct tcp_pcb *npcb;
445 if (
flags & TCP_RST) {
452 if (
flags & TCP_ACK) {
458 }
else if (
flags & TCP_SYN) {
460#if TCP_LISTEN_BACKLOG
461 if (pcb->accepts_pending >= pcb->backlog) {
466 npcb = tcp_alloc(pcb->prio);
475#if TCP_LISTEN_BACKLOG
476 pcb->accepts_pending++;
480 npcb->local_port = pcb->local_port;
482 npcb->remote_port =
tcphdr->src;
483 npcb->state = SYN_RCVD;
484 npcb->rcv_nxt = seqno + 1;
485 npcb->rcv_ann_right_edge = npcb->rcv_nxt;
486 npcb->snd_wnd =
tcphdr->wnd;
487 npcb->snd_wnd_max =
tcphdr->wnd;
488 npcb->ssthresh = npcb->snd_wnd;
489 npcb->snd_wl1 = seqno - 1;
490 npcb->callback_arg = pcb->callback_arg;
492 npcb->accept = pcb->accept;
498 TCP_REG_ACTIVE(npcb);
502#if TCP_CALCULATE_EFF_SEND_MSS
503 npcb->mss = tcp_eff_send_mss(npcb->mss, &(npcb->remote_ip));
509 rc = tcp_enqueue_flags(npcb, TCP_SYN | TCP_ACK);
511 tcp_abandon(npcb, 0);
514 return tcp_output(npcb);
529tcp_timewait_input(
struct tcp_pcb *pcb)
536 if (
flags & TCP_RST) {
540 if (
flags & TCP_SYN) {
543 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt+pcb->rcv_wnd)) {
549 }
else if (
flags & TCP_FIN) {
552 pcb->tmr = tcp_ticks;
557 pcb->flags |= TF_ACK_NOW;
558 return tcp_output(pcb);
575tcp_process(
struct tcp_pcb *pcb)
577 struct tcp_seg *rseg;
584 if (
flags & TCP_RST) {
586 if (pcb->state == SYN_SENT) {
587 if (ackno == pcb->snd_nxt) {
591 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
592 pcb->rcv_nxt+pcb->rcv_wnd)) {
599 LWIP_ASSERT(
"tcp_input: pcb->state != CLOSED", pcb->state != CLOSED);
600 recv_flags |= TF_RESET;
601 pcb->flags &= ~TF_ACK_DELAY;
605 seqno, pcb->rcv_nxt));
607 seqno, pcb->rcv_nxt));
612 if ((
flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) {
618 if ((pcb->flags & TF_RXCLOSED) == 0) {
620 pcb->tmr = tcp_ticks;
622 pcb->keep_cnt_sent = 0;
627 switch (pcb->state) {
630 pcb->snd_nxt,
ntohl(pcb->unacked->tcphdr->seqno)));
633 && ackno ==
ntohl(pcb->unacked->tcphdr->seqno) + 1) {
635 pcb->rcv_nxt = seqno + 1;
636 pcb->rcv_ann_right_edge = pcb->rcv_nxt;
637 pcb->lastack = ackno;
638 pcb->snd_wnd =
tcphdr->wnd;
639 pcb->snd_wnd_max =
tcphdr->wnd;
640 pcb->snd_wl1 = seqno - 1;
641 pcb->state = ESTABLISHED;
643#if TCP_CALCULATE_EFF_SEND_MSS
644 pcb->mss = tcp_eff_send_mss(pcb->mss, &(pcb->remote_ip));
649 pcb->ssthresh = pcb->mss * 10;
651 pcb->cwnd = ((pcb->cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
652 LWIP_ASSERT(
"pcb->snd_queuelen > 0", (pcb->snd_queuelen > 0));
656 pcb->unacked = rseg->next;
661 if(pcb->unacked ==
NULL)
677 else if (
flags & TCP_ACK) {
684 if (
flags & TCP_ACK) {
686 if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)) {
688 pcb->state = ESTABLISHED;
704 old_cwnd = pcb->cwnd;
710 if (pcb->acked != 0) {
714 pcb->cwnd = ((old_cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
716 if (recv_flags & TF_GOT_FIN) {
718 pcb->state = CLOSE_WAIT;
725 }
else if ((
flags & TCP_SYN) && (seqno == pcb->rcv_nxt - 1)) {
734 if (recv_flags & TF_GOT_FIN) {
736 pcb->state = CLOSE_WAIT;
741 if (recv_flags & TF_GOT_FIN) {
742 if ((
flags & TCP_ACK) && (ackno == pcb->snd_nxt)) {
744 (
"TCP connection closed: FIN_WAIT_1 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
748 pcb->state = TIME_WAIT;
749 TCP_REG(&tcp_tw_pcbs, pcb);
752 pcb->state = CLOSING;
754 }
else if ((
flags & TCP_ACK) && (ackno == pcb->snd_nxt)) {
755 pcb->state = FIN_WAIT_2;
760 if (recv_flags & TF_GOT_FIN) {
765 pcb->state = TIME_WAIT;
766 TCP_REG(&tcp_tw_pcbs, pcb);
771 if (
flags & TCP_ACK && ackno == pcb->snd_nxt) {
775 pcb->state = TIME_WAIT;
776 TCP_REG(&tcp_tw_pcbs, pcb);
781 if (
flags & TCP_ACK && ackno == pcb->snd_nxt) {
784 recv_flags |= TF_CLOSED;
800tcp_oos_insert_segment(
struct tcp_seg *cseg,
struct tcp_seg *
next)
802 struct tcp_seg *old_seg;
804 if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) {
813 TCP_SEQ_GEQ((seqno + cseg->len),
814 (
next->tcphdr->seqno +
next->len))) {
816 if (TCPH_FLAGS(
next->tcphdr) & TCP_FIN) {
817 TCPH_SET_FLAG(cseg->tcphdr, TCP_FIN);
821 tcp_seg_free(old_seg);
824 TCP_SEQ_GT(seqno + cseg->len,
next->tcphdr->seqno)) {
826 cseg->len = (
u16_t)(
next->tcphdr->seqno - seqno);
847tcp_receive(
struct tcp_pcb *pcb)
849 struct tcp_seg *
next;
851 struct tcp_seg *prev, *cseg;
856 u32_t right_wnd_edge;
858 int found_dupack = 0;
859#if TCP_OOSEQ_MAX_BYTES || TCP_OOSEQ_MAX_PBUFS
864 LWIP_ASSERT(
"tcp_receive: wrong state", pcb->state >= ESTABLISHED);
866 if (
flags & TCP_ACK) {
867 right_wnd_edge = pcb->snd_wnd + pcb->snd_wl2;
870 if (TCP_SEQ_LT(pcb->snd_wl1, seqno) ||
871 (pcb->snd_wl1 == seqno && TCP_SEQ_LT(pcb->snd_wl2, ackno)) ||
872 (pcb->snd_wl2 == ackno &&
tcphdr->wnd > pcb->snd_wnd)) {
873 pcb->snd_wnd =
tcphdr->wnd;
876 if (pcb->snd_wnd_max <
tcphdr->wnd) {
877 pcb->snd_wnd_max =
tcphdr->wnd;
879 pcb->snd_wl1 = seqno;
880 pcb->snd_wl2 = ackno;
881 if (pcb->snd_wnd == 0) {
882 if (pcb->persist_backoff == 0) {
884 pcb->persist_cnt = 0;
885 pcb->persist_backoff = 1;
887 }
else if (pcb->persist_backoff > 0) {
889 pcb->persist_backoff = 0;
894 if (pcb->snd_wnd !=
tcphdr->wnd) {
896 (
"tcp_receive: no window update lastack %"U32_F" ackno %"
898 pcb->lastack, ackno, pcb->snd_wl1, seqno, pcb->snd_wl2));
924 if (TCP_SEQ_LEQ(ackno, pcb->lastack)) {
929 if (pcb->snd_wl2 + pcb->snd_wnd == right_wnd_edge){
931 if (pcb->rtime >= 0) {
933 if (pcb->lastack == ackno) {
935 if ((
u8_t)(pcb->dupacks + 1) > pcb->dupacks) {
938 if (pcb->dupacks > 3) {
941 if ((
u16_t)(pcb->cwnd + pcb->mss) > pcb->cwnd) {
942 pcb->cwnd += pcb->mss;
944 }
else if (pcb->dupacks == 3) {
946 tcp_rexmit_fast(pcb);
957 }
else if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)){
963 if (pcb->flags & TF_INFR) {
964 pcb->flags &= ~TF_INFR;
965 pcb->cwnd = pcb->ssthresh;
972 pcb->rto = (pcb->sa >> 3) + pcb->sv;
975 pcb->acked = (
u16_t)(ackno - pcb->lastack);
977 pcb->snd_buf += pcb->acked;
981 pcb->lastack = ackno;
985 if (pcb->state >= ESTABLISHED) {
986 if (pcb->cwnd < pcb->ssthresh) {
987 if ((
u16_t)(pcb->cwnd + pcb->mss) > pcb->cwnd) {
988 pcb->cwnd += pcb->mss;
992 u16_t new_cwnd = (pcb->cwnd + pcb->mss * pcb->mss / pcb->cwnd);
993 if (new_cwnd > pcb->cwnd) {
994 pcb->cwnd = new_cwnd;
1001 pcb->unacked !=
NULL?
1002 ntohl(pcb->unacked->tcphdr->seqno): 0,
1003 pcb->unacked !=
NULL?
1004 ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked): 0));
1008 while (pcb->unacked !=
NULL &&
1009 TCP_SEQ_LEQ(
ntohl(pcb->unacked->tcphdr->seqno) +
1010 TCP_TCPLEN(pcb->unacked), ackno)) {
1012 ntohl(pcb->unacked->tcphdr->seqno),
1013 ntohl(pcb->unacked->tcphdr->seqno) +
1014 TCP_TCPLEN(pcb->unacked)));
1016 next = pcb->unacked;
1017 pcb->unacked = pcb->unacked->next;
1022 if ((pcb->acked != 0) && ((TCPH_FLAGS(
next->tcphdr) & TCP_FIN) != 0)) {
1030 if (pcb->snd_queuelen != 0) {
1031 LWIP_ASSERT(
"tcp_receive: valid queue length", pcb->unacked !=
NULL ||
1032 pcb->unsent !=
NULL);
1038 if(pcb->unacked ==
NULL)
1055 while (pcb->unsent !=
NULL &&
1056 TCP_SEQ_BETWEEN(ackno,
ntohl(pcb->unsent->tcphdr->seqno) +
1057 TCP_TCPLEN(pcb->unsent), pcb->snd_nxt)) {
1059 ntohl(pcb->unsent->tcphdr->seqno),
ntohl(pcb->unsent->tcphdr->seqno) +
1060 TCP_TCPLEN(pcb->unsent)));
1063 pcb->unsent = pcb->unsent->next;
1065 if (pcb->unsent ==
NULL) {
1066 pcb->unsent_oversize = 0;
1072 if ((pcb->acked != 0) && ((TCPH_FLAGS(
next->tcphdr) & TCP_FIN) != 0)) {
1078 if (pcb->snd_queuelen != 0) {
1080 pcb->unacked !=
NULL || pcb->unsent !=
NULL);
1086 pcb->rttest, pcb->rtseq, ackno));
1091 if (pcb->rttest && TCP_SEQ_LT(pcb->rtseq, ackno)) {
1094 m = (
s16_t)(tcp_ticks - pcb->rttest);
1097 m,
m * TCP_SLOW_INTERVAL));
1100 m =
m - (pcb->sa >> 3);
1105 m =
m - (pcb->sv >> 2);
1107 pcb->rto = (pcb->sa >> 3) + pcb->sv;
1110 pcb->rto, pcb->rto * TCP_SLOW_INTERVAL));
1120 if ((tcplen > 0) && (pcb->state < CLOSE_WAIT)) {
1151 if (TCP_SEQ_BETWEEN(pcb->rcv_nxt, seqno + 1, seqno + tcplen - 1)){
1172 off = pcb->rcv_nxt - seqno;
1176 if (inseg.p->len < off) {
1178 new_tot_len = (
u16_t)(inseg.p->tot_len - off);
1179 while (
p->len < off) {
1184 p->tot_len = new_tot_len;
1198 inseg.len -= (
u16_t)(pcb->rcv_nxt - seqno);
1199 inseg.tcphdr->seqno = seqno = pcb->rcv_nxt;
1202 if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)){
1214 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
1215 pcb->rcv_nxt + pcb->rcv_wnd - 1)){
1216 if (pcb->rcv_nxt == seqno) {
1220 tcplen = TCP_TCPLEN(&inseg);
1222 if (tcplen > pcb->rcv_wnd) {
1224 (
"tcp_receive: other end overran receive window"
1226 seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
1227 if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
1230 TCPH_FLAGS_SET(inseg.tcphdr, TCPH_FLAGS(inseg.tcphdr) &~ TCP_FIN);
1233 inseg.len = pcb->rcv_wnd;
1234 if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) {
1238 tcplen = TCP_TCPLEN(&inseg);
1239 LWIP_ASSERT(
"tcp_receive: segment not trimmed correctly to rcv_wnd\n",
1240 (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd));
1246 if (pcb->ooseq !=
NULL) {
1247 if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
1249 (
"tcp_receive: received in-order FIN, binning ooseq queue\n"));
1253 while (pcb->ooseq !=
NULL) {
1254 struct tcp_seg *old_ooseq = pcb->ooseq;
1255 pcb->ooseq = pcb->ooseq->next;
1256 tcp_seg_free(old_ooseq);
1263 TCP_SEQ_GEQ(seqno + tcplen,
1264 next->tcphdr->seqno +
next->len)) {
1266 if (TCPH_FLAGS(
next->tcphdr) & TCP_FIN &&
1267 (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) == 0) {
1268 TCPH_SET_FLAG(inseg.tcphdr, TCP_FIN);
1269 tcplen = TCP_TCPLEN(&inseg);
1278 TCP_SEQ_GT(seqno + tcplen,
1279 next->tcphdr->seqno)) {
1281 inseg.len = (
u16_t)(
next->tcphdr->seqno - seqno);
1282 if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) {
1286 tcplen = TCP_TCPLEN(&inseg);
1287 LWIP_ASSERT(
"tcp_receive: segment not trimmed correctly to ooseq queue\n",
1288 (seqno + tcplen) ==
next->tcphdr->seqno);
1295 pcb->rcv_nxt = seqno + tcplen;
1298 LWIP_ASSERT(
"tcp_receive: tcplen > rcv_wnd\n", pcb->rcv_wnd >= tcplen);
1299 pcb->rcv_wnd -= tcplen;
1301 tcp_update_rcv_ann_wnd(pcb);
1312 if (inseg.p->tot_len > 0) {
1313 recv_data = inseg.p;
1319 if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
1321 recv_flags |= TF_GOT_FIN;
1327 while (pcb->ooseq !=
NULL &&
1328 pcb->ooseq->tcphdr->seqno == pcb->rcv_nxt) {
1331 seqno = pcb->ooseq->tcphdr->seqno;
1333 pcb->rcv_nxt += TCP_TCPLEN(cseg);
1334 LWIP_ASSERT(
"tcp_receive: ooseq tcplen > rcv_wnd\n",
1335 pcb->rcv_wnd >= TCP_TCPLEN(cseg));
1336 pcb->rcv_wnd -= TCP_TCPLEN(cseg);
1338 tcp_update_rcv_ann_wnd(pcb);
1340 if (cseg->p->tot_len > 0) {
1346 recv_data = cseg->p;
1350 if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) {
1352 recv_flags |= TF_GOT_FIN;
1353 if (pcb->state == ESTABLISHED) {
1354 pcb->state = CLOSE_WAIT;
1358 pcb->ooseq = cseg->next;
1369 tcp_send_empty_ack(pcb);
1372 if (pcb->ooseq ==
NULL) {
1373 pcb->ooseq = tcp_seg_copy(&inseg);
1389 if (seqno ==
next->tcphdr->seqno) {
1394 if (inseg.len >
next->len) {
1398 cseg = tcp_seg_copy(&inseg);
1405 tcp_oos_insert_segment(cseg,
next);
1416 if (TCP_SEQ_LT(seqno,
next->tcphdr->seqno)) {
1421 cseg = tcp_seg_copy(&inseg);
1424 tcp_oos_insert_segment(cseg,
next);
1431 if (TCP_SEQ_BETWEEN(seqno, prev->tcphdr->seqno+1,
next->tcphdr->seqno-1)) {
1437 cseg = tcp_seg_copy(&inseg);
1439 if (TCP_SEQ_GT(prev->tcphdr->seqno + prev->len, seqno)) {
1441 prev->len = (
u16_t)(seqno - prev->tcphdr->seqno);
1445 tcp_oos_insert_segment(cseg,
next);
1454 TCP_SEQ_GT(seqno,
next->tcphdr->seqno)) {
1455 if (TCPH_FLAGS(
next->tcphdr) & TCP_FIN) {
1459 next->next = tcp_seg_copy(&inseg);
1461 if (TCP_SEQ_GT(
next->tcphdr->seqno +
next->len, seqno)) {
1467 if ((
u32_t)tcplen + seqno > pcb->rcv_nxt + (
u32_t)pcb->rcv_wnd) {
1469 (
"tcp_receive: other end overran receive window"
1471 seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
1472 if (TCPH_FLAGS(
next->next->tcphdr) & TCP_FIN) {
1475 TCPH_FLAGS_SET(
next->next->tcphdr, TCPH_FLAGS(
next->next->tcphdr) &~ TCP_FIN);
1478 next->next->len = pcb->rcv_nxt + pcb->rcv_wnd - seqno;
1480 tcplen = TCP_TCPLEN(
next->next);
1481 LWIP_ASSERT(
"tcp_receive: segment not trimmed correctly to rcv_wnd\n",
1482 (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd));
1491#if TCP_OOSEQ_MAX_BYTES || TCP_OOSEQ_MAX_PBUFS
1499 ooseq_blen +=
p->tot_len;
1504 tcp_segs_free(
next);
1520 tcp_send_empty_ack(pcb);
1527 if(!TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd-1)){
1542tcp_parseopt(
struct tcp_pcb *pcb)
1547#if LWIP_TCP_TIMESTAMPS
1554 if(TCPH_HDRLEN(
tcphdr) > 0x5) {
1555 max_c = (TCPH_HDRLEN(
tcphdr) - 5) << 2;
1556 for (
c = 0;
c < max_c; ) {
1570 if (opts[
c + 1] != 0x04 ||
c + 0x04 > max_c) {
1576 mss = (opts[
c + 2] << 8) | opts[
c + 3];
1582#if LWIP_TCP_TIMESTAMPS
1585 if (opts[
c + 1] != 0x0A ||
c + 0x0A > max_c) {
1591 tsval = (opts[
c+2]) | (opts[
c+3] << 8) |
1592 (opts[
c+4] << 16) | (opts[
c+5] << 24);
1593 if (
flags & TCP_SYN) {
1594 pcb->ts_recent =
ntohl(tsval);
1595 pcb->flags |= TF_TIMESTAMP;
1596 }
else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno+tcplen)) {
1597 pcb->ts_recent =
ntohl(tsval);
1605 if (opts[
c + 1] == 0) {
#define ip_current_src_addr()
#define ip_current_dest_addr()
#define LWIP_DEBUGF(debug, message)
#define LWIP_ASSERT(message, assertion)
#define snmp_inc_tcppassiveopens()
#define snmp_inc_tcpinerrs()
#define snmp_inc_tcpinsegs()
u16_t inet_chksum_pseudo(struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, u8_t proto, u16_t proto_len)
#define ip_addr_cmp(addr1, addr2)
#define ip_addr_isany(addr1)
#define ip_addr_ismulticast(addr1)
#define ip_addr_copy(dest, src)
#define ip_addr_isbroadcast(ipaddr, netif)
ip_addr_t current_iphdr_src
ip_addr_t current_iphdr_dest
void memp_free(memp_t type, void *mem)
#define TCP_OOSEQ_MAX_PBUFS
#define TCP_OOSEQ_MAX_BYTES
u8_t pbuf_header(struct pbuf *p, s16_t header_size_increment)
void pbuf_realloc(struct pbuf *p, u16_t new_len)
void pbuf_cat(struct pbuf *h, struct pbuf *t)
u8_t pbuf_clen(struct pbuf *p)
u8_t pbuf_free(struct pbuf *p)
#define PBUF_FLAG_TCP_FIN
static unsigned __int64 next