]>
git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Input.c
2 TCP input process routines.
4 Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php<BR>
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20 Check whether the sequence number of the incoming segment is acceptable.
22 @param Tcb Pointer to the TCP_CB of this TCP instance.
23 @param Seg Pointer to the incoming segment.
25 @retval 1 The sequence number is acceptable.
26 @retval 0 The sequence number is not acceptable.
35 return (TCP_SEQ_LEQ (Tcb
->RcvNxt
, Seg
->End
) &&
36 TCP_SEQ_LT (Seg
->Seq
, Tcb
->RcvWl2
+ Tcb
->RcvWnd
));
41 NewReno fast recovery, RFC3782.
43 @param Tcb Pointer to the TCP_CB of this TCP instance.
44 @param Seg Segment that triggers the fast recovery.
57 // Step 1: Three duplicate ACKs and not in fast recovery
59 if (Tcb
->CongestState
!= TCP_CONGEST_RECOVER
) {
62 // Step 1A: Invoking fast retransmission.
64 FlightSize
= TCP_SUB_SEQ (Tcb
->SndNxt
, Tcb
->SndUna
);
66 Tcb
->Ssthresh
= MAX (FlightSize
>> 1, (UINT32
) (2 * Tcb
->SndMss
));
67 Tcb
->Recover
= Tcb
->SndNxt
;
69 Tcb
->CongestState
= TCP_CONGEST_RECOVER
;
70 TCP_CLEAR_FLG (Tcb
->CtrlFlag
, TCP_CTRL_RTT_ON
);
73 // Step 2: Entering fast retransmission
75 TcpRetransmit (Tcb
, Tcb
->SndUna
);
76 Tcb
->CWnd
= Tcb
->Ssthresh
+ 3 * Tcb
->SndMss
;
78 DEBUG ((EFI_D_NET
, "TcpFastRecover: enter fast retransmission"
79 " for TCB %p, recover point is %d\n", Tcb
, Tcb
->Recover
));
84 // During fast recovery, execute Step 3, 4, 5 of RFC3782
86 if (Seg
->Ack
== Tcb
->SndUna
) {
89 // Step 3: Fast Recovery,
90 // If this is a duplicated ACK, increse Cwnd by SMSS.
93 // Step 4 is skipped here only to be executed later
96 Tcb
->CWnd
+= Tcb
->SndMss
;
97 DEBUG ((EFI_D_NET
, "TcpFastRecover: received another"
98 " duplicated ACK (%d) for TCB %p\n", Seg
->Ack
, Tcb
));
103 // New data is ACKed, check whether it is a
104 // full ACK or partial ACK
106 if (TCP_SEQ_GEQ (Seg
->Ack
, Tcb
->Recover
)) {
109 // Step 5 - Full ACK:
110 // deflate the congestion window, and exit fast recovery
112 FlightSize
= TCP_SUB_SEQ (Tcb
->SndNxt
, Tcb
->SndUna
);
114 Tcb
->CWnd
= MIN (Tcb
->Ssthresh
, FlightSize
+ Tcb
->SndMss
);
116 Tcb
->CongestState
= TCP_CONGEST_OPEN
;
117 DEBUG ((EFI_D_NET
, "TcpFastRecover: received a full ACK(%d)"
118 " for TCB %p, exit fast recovery\n", Seg
->Ack
, Tcb
));
123 // Step 5 - Partial ACK:
124 // fast retransmit the first unacknowledge field
125 // , then deflate the CWnd
127 TcpRetransmit (Tcb
, Seg
->Ack
);
128 Acked
= TCP_SUB_SEQ (Seg
->Ack
, Tcb
->SndUna
);
131 // Deflate the CWnd by the amount of new data
132 // ACKed by SEG.ACK. If more than one SMSS data
133 // is ACKed, add back SMSS byte to CWnd after
135 if (Acked
>= Tcb
->SndMss
) {
136 Acked
-= Tcb
->SndMss
;
142 DEBUG ((EFI_D_NET
, "TcpFastRecover: received a partial"
143 " ACK(%d) for TCB %p\n", Seg
->Ack
, Tcb
));
151 NewReno fast loss recovery, RFC3792.
153 @param Tcb Pointer to the TCP_CB of this TCP instance.
154 @param Seg Segment that triggers the fast loss recovery.
163 if (TCP_SEQ_GT (Seg
->Ack
, Tcb
->SndUna
)) {
166 // New data is ACKed, check whether it is a
167 // full ACK or partial ACK
169 if (TCP_SEQ_GEQ (Seg
->Ack
, Tcb
->LossRecover
)) {
172 // Full ACK: exit the loss recovery.
175 Tcb
->CongestState
= TCP_CONGEST_OPEN
;
177 DEBUG ((EFI_D_NET
, "TcpFastLossRecover: received a "
178 "full ACK(%d) for TCB %p\n", Seg
->Ack
, Tcb
));
184 // fast retransmit the first unacknowledge field.
186 TcpRetransmit (Tcb
, Seg
->Ack
);
187 DEBUG ((EFI_D_NET
, "TcpFastLossRecover: received a "
188 "partial ACK(%d) for TCB %p\n", Seg
->Ack
, Tcb
));
195 Compute the RTT as specified in RFC2988.
197 @param Tcb Pointer to the TCP_CB of this TCP instance.
198 @param Measure Currently measured RTT in heart beats.
210 // Step 2.3: Compute the RTO for subsequent RTT measurement.
212 if (Tcb
->SRtt
!= 0) {
214 Var
= Tcb
->SRtt
- (Measure
<< TCP_RTT_SHIFT
);
220 Tcb
->RttVar
= (3 * Tcb
->RttVar
+ Var
) >> 2;
221 Tcb
->SRtt
= 7 * (Tcb
->SRtt
>> 3) + Measure
;
225 // Step 2.2: compute the first RTT measure
227 Tcb
->SRtt
= Measure
<< TCP_RTT_SHIFT
;
228 Tcb
->RttVar
= Measure
<< (TCP_RTT_SHIFT
- 1);
231 Tcb
->Rto
= (Tcb
->SRtt
+ MAX (8, 4 * Tcb
->RttVar
)) >> TCP_RTT_SHIFT
;
234 // Step 2.4: Limit the RTO to at least 1 second
235 // Step 2.5: Limit the RTO to a maxium value that
236 // is at least 60 second
238 if (Tcb
->Rto
< TCP_RTO_MIN
) {
239 Tcb
->Rto
= TCP_RTO_MIN
;
241 } else if (Tcb
->Rto
> TCP_RTO_MAX
) {
242 Tcb
->Rto
= TCP_RTO_MAX
;
246 DEBUG ((EFI_D_NET
, "TcpComputeRtt: new RTT for TCB %p"
247 " computed SRTT: %d RTTVAR: %d RTO: %d\n",
248 Tcb
, Tcb
->SRtt
, Tcb
->RttVar
, Tcb
->Rto
));
254 Trim the data, SYN and FIN to fit into the window defined by Left and Right.
256 @param Nbuf Buffer that contains received TCP segment without IP header.
257 @param Left The sequence number of the window's left edge.
258 @param Right The sequence number of the window's right edge.
272 Seg
= TCPSEG_NETBUF (Nbuf
);
275 // If the segment is completely out of window,
276 // truncate every thing, include SYN and FIN.
278 if (TCP_SEQ_LEQ (Seg
->End
, Left
) || TCP_SEQ_LEQ (Right
, Seg
->Seq
)) {
280 TCP_CLEAR_FLG (Seg
->Flag
, TCP_FLG_SYN
);
281 TCP_CLEAR_FLG (Seg
->Flag
, TCP_FLG_FIN
);
284 NetbufTrim (Nbuf
, Nbuf
->TotalSize
, NET_BUF_HEAD
);
289 // Adjust the buffer header
291 if (TCP_SEQ_LT (Seg
->Seq
, Left
)) {
293 Drop
= TCP_SUB_SEQ (Left
, Seg
->Seq
);
294 Urg
= Seg
->Seq
+ Seg
->Urg
;
297 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_SYN
)) {
298 TCP_CLEAR_FLG (Seg
->Flag
, TCP_FLG_SYN
);
303 // Adjust the urgent point
305 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_URG
)) {
307 if (TCP_SEQ_LT (Urg
, Seg
->Seq
)) {
309 TCP_CLEAR_FLG (Seg
->Flag
, TCP_FLG_URG
);
311 Seg
->Urg
= (UINT16
) TCP_SUB_SEQ (Urg
, Seg
->Seq
);
316 NetbufTrim (Nbuf
, Drop
, NET_BUF_HEAD
);
321 // Adjust the buffer tail
323 if (TCP_SEQ_GT (Seg
->End
, Right
)) {
325 Drop
= TCP_SUB_SEQ (Seg
->End
, Right
);
328 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_FIN
)) {
329 TCP_CLEAR_FLG (Seg
->Flag
, TCP_FLG_FIN
);
334 NetbufTrim (Nbuf
, Drop
, NET_BUF_TAIL
);
338 ASSERT (TcpVerifySegment (Nbuf
) != 0);
343 Trim off the data outside the tcb's receive window.
345 @param Tcb Pointer to the TCP_CB of this TCP instance.
346 @param Nbuf Pointer to the NET_BUF containing the received tcp segment.
355 TcpTrimSegment (Nbuf
, Tcb
->RcvNxt
, Tcb
->RcvWl2
+ Tcb
->RcvWnd
);
360 Process the data and FIN flag, check whether to deliver
361 data to the socket layer.
363 @param Tcb Pointer to the TCP_CB of this TCP instance.
365 @retval 0 No error occurred to deliver data.
366 @retval -1 Error condition occurred. Proper response is to reset the
381 ASSERT ((Tcb
!= NULL
) && (Tcb
->Sk
!= NULL
));
384 // make sure there is some data queued,
385 // and TCP is in a proper state
387 if (IsListEmpty (&Tcb
->RcvQue
) || !TCP_CONNECTED (Tcb
->State
)) {
393 // Deliver data to the socket layer
395 Entry
= Tcb
->RcvQue
.ForwardLink
;
398 while (Entry
!= &Tcb
->RcvQue
) {
399 Nbuf
= NET_LIST_USER_STRUCT (Entry
, NET_BUF
, List
);
400 Seg
= TCPSEG_NETBUF (Nbuf
);
402 ASSERT (TcpVerifySegment (Nbuf
) != 0);
403 ASSERT (Nbuf
->Tcp
== NULL
);
405 if (TCP_SEQ_GT (Seg
->Seq
, Seq
)) {
409 Entry
= Entry
->ForwardLink
;
413 RemoveEntryList (&Nbuf
->List
);
416 // RFC793 Eighth step: process FIN in sequence
418 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_FIN
)) {
421 // The peer sends to us junky data after FIN,
422 // reset the connection.
424 if (!IsListEmpty (&Tcb
->RcvQue
)) {
425 DEBUG ((EFI_D_ERROR
, "TcpDeliverData: data received after"
426 " FIN from peer of TCB %p, reset connection\n", Tcb
));
432 DEBUG ((EFI_D_NET
, "TcpDeliverData: processing FIN "
433 "from peer of TCB %p\n", Tcb
));
435 switch (Tcb
->State
) {
437 case TCP_ESTABLISHED
:
439 TcpSetState (Tcb
, TCP_CLOSE_WAIT
);
444 if (!TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_FIN_ACKED
)) {
446 TcpSetState (Tcb
, TCP_CLOSING
);
455 TcpSetState (Tcb
, TCP_TIME_WAIT
);
456 TcpClearAllTimer (Tcb
);
458 if (Tcb
->TimeWaitTimeout
!= 0) {
460 TcpSetTimer (Tcb
, TCP_TIMER_2MSL
, Tcb
->TimeWaitTimeout
);
463 DEBUG ((EFI_D_WARN
, "Connection closed immediately "
464 "because app disables TIME_WAIT timer for %p\n", Tcb
));
476 // The peer sends to us junk FIN byte. Discard
477 // the buffer then reset the connection
485 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
);
491 // Don't delay the ack if PUSH flag is on.
493 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_PSH
)) {
495 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
);
498 if (Nbuf
->TotalSize
!= 0) {
501 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_RCVD_URG
) &&
502 TCP_SEQ_LEQ (Seg
->Seq
, Tcb
->RcvUp
)) {
504 if (TCP_SEQ_LEQ (Seg
->End
, Tcb
->RcvUp
)) {
505 Urgent
= Nbuf
->TotalSize
;
507 Urgent
= TCP_SUB_SEQ (Tcb
->RcvUp
, Seg
->Seq
) + 1;
511 SockDataRcvd (Tcb
->Sk
, Nbuf
, Urgent
);
514 if (TCP_FIN_RCVD (Tcb
->State
)) {
516 SockNoMoreData (Tcb
->Sk
);
527 Store the data into the reassemble queue.
529 @param Tcb Pointer to the TCP_CB of this TCP instance.
530 @param Nbuf Pointer to the buffer containing the data to be queued.
545 ASSERT ((Tcb
!= NULL
) && (Nbuf
!= NULL
) && (Nbuf
->Tcp
== NULL
));
549 Seg
= TCPSEG_NETBUF (Nbuf
);
553 // Fast path to process normal case. That is,
554 // no out-of-order segments are received.
556 if (IsListEmpty (Head
)) {
558 InsertTailList (Head
, &Nbuf
->List
);
563 // Find the point to insert the buffer
565 for (Prev
= Head
, Cur
= Head
->ForwardLink
;
567 Prev
= Cur
, Cur
= Cur
->ForwardLink
) {
569 Node
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
571 if (TCP_SEQ_LT (Seg
->Seq
, TCPSEG_NETBUF (Node
)->Seq
)) {
577 // Check whether the current segment overlaps with the
581 Node
= NET_LIST_USER_STRUCT (Prev
, NET_BUF
, List
);
583 if (TCP_SEQ_LT (Seg
->Seq
, TCPSEG_NETBUF (Node
)->End
)) {
585 if (TCP_SEQ_LEQ (Seg
->End
, TCPSEG_NETBUF (Node
)->End
)) {
591 TcpTrimSegment (Nbuf
, TCPSEG_NETBUF (Node
)->End
, Seg
->End
);
595 InsertHeadList (Prev
, &Nbuf
->List
);
597 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
);
600 // Check the segments after the insert point.
602 while (Cur
!= Head
) {
603 Node
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
605 if (TCP_SEQ_LEQ (TCPSEG_NETBUF (Node
)->End
, Seg
->End
)) {
607 Cur
= Cur
->ForwardLink
;
609 RemoveEntryList (&Node
->List
);
614 if (TCP_SEQ_LT (TCPSEG_NETBUF (Node
)->Seq
, Seg
->End
)) {
616 if (TCP_SEQ_LEQ (TCPSEG_NETBUF (Node
)->Seq
, Seg
->Seq
)) {
618 RemoveEntryList (&Nbuf
->List
);
623 TcpTrimSegment (Nbuf
, Seg
->Seq
, TCPSEG_NETBUF (Node
)->Seq
);
627 Cur
= Cur
->ForwardLink
;
633 Ajust the send queue or the retransmit queue.
635 @param Tcb Pointer to the TCP_CB of this TCP instance.
636 @param Ack The acknowledge seuqence number of the received segment.
651 Cur
= Head
->ForwardLink
;
653 while (Cur
!= Head
) {
654 Node
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
655 Seg
= TCPSEG_NETBUF (Node
);
657 if (TCP_SEQ_GEQ (Seg
->Seq
, Ack
)) {
662 // Remove completely ACKed segments
664 if (TCP_SEQ_LEQ (Seg
->End
, Ack
)) {
665 Cur
= Cur
->ForwardLink
;
667 RemoveEntryList (&Node
->List
);
672 TcpTrimSegment (Node
, Ack
, Seg
->End
);
679 Process the received TCP segments.
681 @param Nbuf Buffer that contains received TCP segment without IP header.
682 @param Src Source address of the segment, or the peer's IP address.
683 @param Dst Destination address of the segment, or the local end's IP
686 @retval 0 Segment is processed successfully. It is either accepted or
687 discarded. But no connection is reset by the segment.
688 @retval -1 A connection is reset by the segment.
708 NET_CHECK_SIGNATURE (Nbuf
, NET_BUF_SIGNATURE
);
713 Head
= (TCP_HEAD
*) NetbufGetByte (Nbuf
, 0, NULL
);
714 ASSERT (Head
!= NULL
);
716 if (Nbuf
->TotalSize
< sizeof (TCP_HEAD
)) {
717 DEBUG ((EFI_D_NET
, "TcpInput: received a malformed packet\n"));
721 Len
= Nbuf
->TotalSize
- (Head
->HeadLen
<< 2);
723 if ((Head
->HeadLen
< 5) || (Len
< 0) ||
724 (TcpChecksum (Nbuf
, NetPseudoHeadChecksum (Src
, Dst
, 6, 0)) != 0)) {
726 DEBUG ((EFI_D_NET
, "TcpInput: received a malformed packet\n"));
730 if (TCP_FLG_ON (Head
->Flag
, TCP_FLG_SYN
)) {
734 if (TCP_FLG_ON (Head
->Flag
, TCP_FLG_FIN
)) {
743 (BOOLEAN
) TCP_FLG_ON (Head
->Flag
, TCP_FLG_SYN
)
746 if ((Tcb
== NULL
) || (Tcb
->State
== TCP_CLOSED
)) {
747 DEBUG ((EFI_D_NET
, "TcpInput: send reset because no TCB found\n"));
753 Seg
= TcpFormatNetbuf (Tcb
, Nbuf
);
756 // RFC1122 recommended reaction to illegal option
757 // (in fact, an illegal option length) is reset.
759 if (TcpParseOption (Nbuf
->Tcp
, &Option
) == -1) {
760 DEBUG ((EFI_D_ERROR
, "TcpInput: reset the peer because"
761 " of malformed option for TCB %p\n", Tcb
));
767 // From now on, the segment is headless
769 NetbufTrim (Nbuf
, (Head
->HeadLen
<< 2), NET_BUF_HEAD
);
773 // Process the segment in LISTEN state.
775 if (Tcb
->State
== TCP_LISTEN
) {
777 // First step: Check RST
779 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_RST
)) {
780 DEBUG ((EFI_D_WARN
, "TcpInput: discard a reset segment "
781 "for TCB %p in listening\n", Tcb
));
787 // Second step: Check ACK.
788 // Any ACK sent to TCP in LISTEN is reseted.
790 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_ACK
)) {
791 DEBUG ((EFI_D_WARN
, "TcpInput: send reset because of"
792 " segment with ACK for TCB %p in listening\n", Tcb
));
798 // Third step: Check SYN
800 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_SYN
)) {
802 // create a child TCB to handle the data
806 Tcb
= TcpCloneTcb (Parent
);
808 DEBUG ((EFI_D_ERROR
, "TcpInput: discard a segment because"
809 " failed to clone a child for TCB %p\n", Tcb
));
814 DEBUG ((EFI_D_NET
, "TcpInput: create a child for TCB %p"
815 " in listening\n", Tcb
));
818 // init the TCB structure
820 Tcb
->LocalEnd
.Ip
= Dst
;
821 Tcb
->LocalEnd
.Port
= Head
->DstPort
;
822 Tcb
->RemoteEnd
.Ip
= Src
;
823 Tcb
->RemoteEnd
.Port
= Head
->SrcPort
;
825 TcpInitTcbLocal (Tcb
);
826 TcpInitTcbPeer (Tcb
, Seg
, &Option
);
828 TcpSetState (Tcb
, TCP_SYN_RCVD
);
829 TcpSetTimer (Tcb
, TCP_TIMER_CONNECT
, Tcb
->ConnectTimeout
);
830 TcpTrimInWnd (Tcb
, Nbuf
);
837 } else if (Tcb
->State
== TCP_SYN_SENT
) {
839 // First step: Check ACK bit
841 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_ACK
) && (Seg
->Ack
!= Tcb
->Iss
+ 1)) {
843 DEBUG ((EFI_D_WARN
, "TcpInput: send reset because of "
844 "wrong ACK received for TCB %p in SYN_SENT\n", Tcb
));
850 // Second step: Check RST bit
852 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_RST
)) {
854 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_ACK
)) {
856 DEBUG ((EFI_D_WARN
, "TcpInput: connection reset by"
857 " peer for TCB %p in SYN_SENT\n", Tcb
));
859 SOCK_ERROR (Tcb
->Sk
, EFI_CONNECTION_RESET
);
860 goto DROP_CONNECTION
;
863 DEBUG ((EFI_D_WARN
, "TcpInput: discard a reset segment "
864 "because of no ACK for TCB %p in SYN_SENT\n", Tcb
));
871 // Third step: Check security and precedence. Skipped
875 // Fourth step: Check SYN. Pay attention to simultaneous open
877 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_SYN
)) {
879 TcpInitTcbPeer (Tcb
, Seg
, &Option
);
881 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_ACK
)) {
883 Tcb
->SndUna
= Seg
->Ack
;
886 TcpClearTimer (Tcb
, TCP_TIMER_REXMIT
);
888 if (TCP_SEQ_GT (Tcb
->SndUna
, Tcb
->Iss
)) {
890 TcpSetState (Tcb
, TCP_ESTABLISHED
);
892 TcpClearTimer (Tcb
, TCP_TIMER_CONNECT
);
893 TcpDeliverData (Tcb
);
895 if ((Tcb
->CongestState
== TCP_CONGEST_OPEN
) &&
896 TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_RTT_ON
)) {
898 TcpComputeRtt (Tcb
, Tcb
->RttMeasure
);
899 TCP_CLEAR_FLG (Tcb
->CtrlFlag
, TCP_CTRL_RTT_ON
);
902 TcpTrimInWnd (Tcb
, Nbuf
);
904 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
);
906 DEBUG ((EFI_D_NET
, "TcpInput: connection established"
907 " for TCB %p in SYN_SENT\n", Tcb
));
912 // Received a SYN segment without ACK, simultaneous open.
914 TcpSetState (Tcb
, TCP_SYN_RCVD
);
916 ASSERT (Tcb
->SndNxt
== Tcb
->Iss
+ 1);
917 TcpAdjustSndQue (Tcb
, Tcb
->SndNxt
);
919 TcpTrimInWnd (Tcb
, Nbuf
);
921 DEBUG ((EFI_D_WARN
, "TcpInput: simultaneous open "
922 "for TCB %p in SYN_SENT\n", Tcb
));
932 // Process segment in SYN_RCVD or TCP_CONNECTED states
936 // Clear probe timer since the RecvWindow is opened.
938 if (Tcb
->ProbeTimerOn
&& (Seg
->Wnd
!= 0)) {
939 TcpClearTimer (Tcb
, TCP_TIMER_PROBE
);
940 Tcb
->ProbeTimerOn
= FALSE
;
944 // First step: Check whether SEG.SEQ is acceptable
946 if (TcpSeqAcceptable (Tcb
, Seg
) == 0) {
947 DEBUG ((EFI_D_WARN
, "TcpInput: sequence acceptance"
948 " test failed for segment of TCB %p\n", Tcb
));
950 if (!TCP_FLG_ON (Seg
->Flag
, TCP_FLG_RST
)) {
957 if ((TCP_SEQ_LT (Seg
->Seq
, Tcb
->RcvWl2
)) &&
958 (Tcb
->RcvWl2
== Seg
->End
) &&
959 !TCP_FLG_ON (Seg
->Flag
, TCP_FLG_SYN
| TCP_FLG_FIN
)) {
961 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
);
965 // Second step: Check the RST
967 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_RST
)) {
969 DEBUG ((EFI_D_WARN
, "TcpInput: connection reset for TCB %p\n", Tcb
));
971 if (Tcb
->State
== TCP_SYN_RCVD
) {
973 SOCK_ERROR (Tcb
->Sk
, EFI_CONNECTION_REFUSED
);
976 // This TCB comes from either a LISTEN TCB,
977 // or active open TCB with simultanous open.
978 // Do NOT signal user CONNECTION refused
979 // if it comes from a LISTEN TCB.
981 } else if ((Tcb
->State
== TCP_ESTABLISHED
) ||
982 (Tcb
->State
== TCP_FIN_WAIT_1
) ||
983 (Tcb
->State
== TCP_FIN_WAIT_2
) ||
984 (Tcb
->State
== TCP_CLOSE_WAIT
)) {
986 SOCK_ERROR (Tcb
->Sk
, EFI_CONNECTION_RESET
);
992 goto DROP_CONNECTION
;
996 // Trim the data and flags.
998 TcpTrimInWnd (Tcb
, Nbuf
);
1001 // Third step: Check security and precedence, Ignored
1005 // Fourth step: Check the SYN bit.
1007 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_SYN
)) {
1009 DEBUG ((EFI_D_WARN
, "TcpInput: connection reset "
1010 "because received extra SYN for TCB %p\n", Tcb
));
1012 SOCK_ERROR (Tcb
->Sk
, EFI_CONNECTION_RESET
);
1013 goto RESET_THEN_DROP
;
1017 // Fifth step: Check the ACK
1019 if (!TCP_FLG_ON (Seg
->Flag
, TCP_FLG_ACK
)) {
1020 DEBUG ((EFI_D_WARN
, "TcpInput: segment discard because"
1021 " of no ACK for connected TCB %p\n", Tcb
));
1027 if (Tcb
->State
== TCP_SYN_RCVD
) {
1029 if (TCP_SEQ_LT (Tcb
->SndUna
, Seg
->Ack
) &&
1030 TCP_SEQ_LEQ (Seg
->Ack
, Tcb
->SndNxt
)) {
1032 Tcb
->SndWnd
= Seg
->Wnd
;
1033 Tcb
->SndWndMax
= MAX (Tcb
->SndWnd
, Tcb
->SndWndMax
);
1034 Tcb
->SndWl1
= Seg
->Seq
;
1035 Tcb
->SndWl2
= Seg
->Ack
;
1036 TcpSetState (Tcb
, TCP_ESTABLISHED
);
1038 TcpClearTimer (Tcb
, TCP_TIMER_CONNECT
);
1039 TcpDeliverData (Tcb
);
1041 DEBUG ((EFI_D_NET
, "TcpInput: connection established "
1042 " for TCB %p in SYN_RCVD\n", Tcb
));
1045 // Continue the process as ESTABLISHED state
1048 DEBUG ((EFI_D_WARN
, "TcpInput: send reset because of"
1049 " wrong ACK for TCB %p in SYN_RCVD\n", Tcb
));
1055 if (TCP_SEQ_LT (Seg
->Ack
, Tcb
->SndUna
)) {
1057 DEBUG ((EFI_D_WARN
, "TcpInput: ignore the out-of-data"
1058 " ACK for connected TCB %p\n", Tcb
));
1062 } else if (TCP_SEQ_GT (Seg
->Ack
, Tcb
->SndNxt
)) {
1064 DEBUG ((EFI_D_WARN
, "TcpInput: discard segment for "
1065 "future ACK for connected TCB %p\n", Tcb
));
1072 // From now on: SND.UNA <= SEG.ACK <= SND.NXT.
1074 if (TCP_FLG_ON (Option
.Flag
, TCP_OPTION_RCVD_TS
)) {
1076 // update TsRecent as specified in page 16 RFC1323.
1077 // RcvWl2 equals to the variable "LastAckSent"
1080 if (TCP_SEQ_LEQ (Seg
->Seq
, Tcb
->RcvWl2
) &&
1081 TCP_SEQ_LT (Tcb
->RcvWl2
, Seg
->End
)) {
1083 Tcb
->TsRecent
= Option
.TSVal
;
1084 Tcb
->TsRecentAge
= mTcpTick
;
1087 TcpComputeRtt (Tcb
, TCP_SUB_TIME (mTcpTick
, Option
.TSEcr
));
1089 } else if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_RTT_ON
)) {
1091 ASSERT (Tcb
->CongestState
== TCP_CONGEST_OPEN
);
1093 TcpComputeRtt (Tcb
, Tcb
->RttMeasure
);
1094 TCP_CLEAR_FLG (Tcb
->CtrlFlag
, TCP_CTRL_RTT_ON
);
1097 if (Seg
->Ack
== Tcb
->SndNxt
) {
1099 TcpClearTimer (Tcb
, TCP_TIMER_REXMIT
);
1102 TcpSetTimer (Tcb
, TCP_TIMER_REXMIT
, Tcb
->Rto
);
1106 // Count duplicate acks.
1108 if ((Seg
->Ack
== Tcb
->SndUna
) &&
1109 (Tcb
->SndUna
!= Tcb
->SndNxt
) &&
1110 (Seg
->Wnd
== Tcb
->SndWnd
) &&
1120 // Congestion avoidance, fast recovery and fast retransmission.
1122 if (((Tcb
->CongestState
== TCP_CONGEST_OPEN
) && (Tcb
->DupAck
< 3)) ||
1123 (Tcb
->CongestState
== TCP_CONGEST_LOSS
)) {
1125 if (TCP_SEQ_GT (Seg
->Ack
, Tcb
->SndUna
)) {
1127 if (Tcb
->CWnd
< Tcb
->Ssthresh
) {
1129 Tcb
->CWnd
+= Tcb
->SndMss
;
1132 Tcb
->CWnd
+= MAX (Tcb
->SndMss
* Tcb
->SndMss
/ Tcb
->CWnd
, 1);
1135 Tcb
->CWnd
= MIN (Tcb
->CWnd
, TCP_MAX_WIN
<< Tcb
->SndWndScale
);
1138 if (Tcb
->CongestState
== TCP_CONGEST_LOSS
) {
1139 TcpFastLossRecover (Tcb
, Seg
);
1143 TcpFastRecover (Tcb
, Seg
);
1146 if (TCP_SEQ_GT (Seg
->Ack
, Tcb
->SndUna
)) {
1148 TcpAdjustSndQue (Tcb
, Seg
->Ack
);
1149 Tcb
->SndUna
= Seg
->Ack
;
1151 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_SND_URG
) &&
1152 TCP_SEQ_LT (Tcb
->SndUp
, Seg
->Ack
)) {
1154 TCP_CLEAR_FLG (Tcb
->CtrlFlag
, TCP_CTRL_SND_URG
);
1159 // Update window info
1161 if (TCP_SEQ_LT (Tcb
->SndWl1
, Seg
->Seq
) ||
1162 ((Tcb
->SndWl1
== Seg
->Seq
) && TCP_SEQ_LEQ (Tcb
->SndWl2
, Seg
->Ack
))) {
1164 Right
= Seg
->Ack
+ Seg
->Wnd
;
1166 if (TCP_SEQ_LT (Right
, Tcb
->SndWl2
+ Tcb
->SndWnd
)) {
1168 if ((Tcb
->SndWl1
== Seg
->Seq
) &&
1169 (Tcb
->SndWl2
== Seg
->Ack
) &&
1175 DEBUG ((EFI_D_WARN
, "TcpInput: peer shrinks the"
1176 " window for connected TCB %p\n", Tcb
));
1178 if ((Tcb
->CongestState
== TCP_CONGEST_RECOVER
) &&
1179 (TCP_SEQ_LT (Right
, Tcb
->Recover
))) {
1181 Tcb
->Recover
= Right
;
1184 if ((Tcb
->CongestState
== TCP_CONGEST_LOSS
) &&
1185 (TCP_SEQ_LT (Right
, Tcb
->LossRecover
))) {
1187 Tcb
->LossRecover
= Right
;
1190 if (TCP_SEQ_LT (Right
, Tcb
->SndNxt
)) {
1192 // Check for Window Retraction in RFC7923 section 2.4.
1193 // The lower n bits of the peer's actual receive window is wiped out if TCP
1194 // window scale is enabled, it will look like the peer is shrinking the window.
1195 // Check whether the SndNxt is out of the advertised receive window by more than
1196 // 2^Rcv.Wind.Shift before moving the SndNxt to the left.
1200 "TcpInput: peer advise negative useable window for connected TCB %p\n",
1203 Usable
= TCP_SUB_SEQ (Tcb
->SndNxt
, Right
);
1204 if ((Usable
>> Tcb
->SndWndScale
) > 0) {
1207 "TcpInput: SndNxt is out of window by more than window scale for TCB %p\n",
1210 Tcb
->SndNxt
= Right
;
1212 if (Right
== Tcb
->SndUna
) {
1214 TcpClearTimer (Tcb
, TCP_TIMER_REXMIT
);
1215 TcpSetProbeTimer (Tcb
);
1220 Tcb
->SndWnd
= Seg
->Wnd
;
1221 Tcb
->SndWndMax
= MAX (Tcb
->SndWnd
, Tcb
->SndWndMax
);
1222 Tcb
->SndWl1
= Seg
->Seq
;
1223 Tcb
->SndWl2
= Seg
->Ack
;
1228 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_FIN_SENT
) &&
1229 (Tcb
->SndUna
== Tcb
->SndNxt
)) {
1231 DEBUG ((EFI_D_NET
, "TcpInput: local FIN is ACKed by"
1232 " peer for connected TCB %p\n", Tcb
));
1234 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_FIN_ACKED
);
1238 // Transit the state if proper.
1240 switch (Tcb
->State
) {
1241 case TCP_FIN_WAIT_1
:
1243 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_FIN_ACKED
)) {
1245 TcpSetState (Tcb
, TCP_FIN_WAIT_2
);
1247 TcpClearAllTimer (Tcb
);
1248 TcpSetTimer (Tcb
, TCP_TIMER_FINWAIT2
, Tcb
->FinWait2Timeout
);
1251 case TCP_FIN_WAIT_2
:
1255 case TCP_CLOSE_WAIT
:
1260 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_FIN_ACKED
)) {
1262 TcpSetState (Tcb
, TCP_TIME_WAIT
);
1264 TcpClearAllTimer (Tcb
);
1266 if (Tcb
->TimeWaitTimeout
!= 0) {
1268 TcpSetTimer (Tcb
, TCP_TIMER_2MSL
, Tcb
->TimeWaitTimeout
);
1271 DEBUG ((EFI_D_WARN
, "Connection closed immediately "
1272 "because app disables TIME_WAIT timer for %p\n", Tcb
));
1281 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_FIN_ACKED
)) {
1283 TcpSetState (Tcb
, TCP_CLOSED
);
1292 if (Tcb
->TimeWaitTimeout
!= 0) {
1294 TcpSetTimer (Tcb
, TCP_TIMER_2MSL
, Tcb
->TimeWaitTimeout
);
1297 DEBUG ((EFI_D_WARN
, "Connection closed immediately "
1298 "because app disables TIME_WAIT timer for %p\n", Tcb
));
1309 // Sixth step: Check the URG bit.update the Urg point
1310 // if in TCP_CAN_RECV, otherwise, leave the RcvUp intact.
1315 TcpSetKeepaliveTimer (Tcb
);
1317 if (TCP_FLG_ON (Seg
->Flag
, TCP_FLG_URG
) &&
1318 !TCP_FIN_RCVD (Tcb
->State
))
1321 DEBUG ((EFI_D_NET
, "TcpInput: received urgent data "
1322 "from peer for connected TCB %p\n", Tcb
));
1324 Urg
= Seg
->Seq
+ Seg
->Urg
;
1326 if (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_RCVD_URG
) &&
1327 TCP_SEQ_GT (Urg
, Tcb
->RcvUp
)) {
1333 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_RCVD_URG
);
1338 // Seventh step: Process the segment data
1340 if (Seg
->End
!= Seg
->Seq
) {
1342 if (TCP_FIN_RCVD (Tcb
->State
)) {
1344 DEBUG ((EFI_D_WARN
, "TcpInput: connection reset because"
1345 " data is lost for connected TCB %p\n", Tcb
));
1347 goto RESET_THEN_DROP
;
1350 if (TCP_LOCAL_CLOSED (Tcb
->State
) && (Nbuf
->TotalSize
!= 0)) {
1351 DEBUG ((EFI_D_WARN
, "TcpInput: connection reset because"
1352 " data is lost for connected TCB %p\n", Tcb
));
1354 goto RESET_THEN_DROP
;
1357 TcpQueueData (Tcb
, Nbuf
);
1358 if (TcpDeliverData (Tcb
) == -1) {
1359 goto RESET_THEN_DROP
;
1362 if (!IsListEmpty (&Tcb
->RcvQue
)) {
1363 TCP_SET_FLG (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
);
1368 // Eighth step: check the FIN.
1369 // This step is moved to TcpDeliverData. FIN will be
1370 // processed in sequence there. Check the comments in
1371 // the beginning of the file header for information.
1375 // Tcb is a new child of the listening Parent,
1378 if (Parent
!= NULL
) {
1379 Tcb
->Parent
= Parent
;
1383 if ((Tcb
->State
!= TCP_CLOSED
) &&
1384 (TcpToSendData (Tcb
, 0) == 0) &&
1385 (TCP_FLG_ON (Tcb
->CtrlFlag
, TCP_CTRL_ACK_NOW
) || (Nbuf
->TotalSize
!= 0))) {
1394 TcpSendReset (Tcb
, Head
, Len
, Dst
, Src
);
1397 ASSERT ((Tcb
!= NULL
) && (Tcb
->Sk
!= NULL
));
1406 TcpSendReset (Tcb
, Head
, Len
, Dst
, Src
);
1411 // Tcb is a child of Parent, and it doesn't survive
1413 DEBUG ((EFI_D_WARN
, "Tcp4Input: Discard a packet\n"));
1416 if ((Parent
!= NULL
) && (Tcb
!= NULL
)) {
1418 ASSERT (Tcb
->Sk
!= NULL
);
1427 Process the received ICMP error messages for TCP.
1429 @param Nbuf Buffer that contains part of the TCP segment without IP header
1430 truncated from the ICMP error packet.
1431 @param IcmpErr The ICMP error code interpreted from ICMP error packet.
1432 @param Src Source address of the ICMP error message.
1433 @param Dst Destination address of the ICMP error message.
1447 EFI_STATUS IcmpErrStatus
;
1448 BOOLEAN IcmpErrIsHard
;
1449 BOOLEAN IcmpErrNotify
;
1451 if (Nbuf
->TotalSize
< sizeof (TCP_HEAD
)) {
1455 Head
= (TCP_HEAD
*) NetbufGetByte (Nbuf
, 0, NULL
);
1456 ASSERT (Head
!= NULL
);
1457 Tcb
= TcpLocateTcb (
1464 if (Tcb
== NULL
|| Tcb
->State
== TCP_CLOSED
) {
1470 // Validate the sequence number.
1472 Seq
= NTOHL (Head
->Seq
);
1473 if (!(TCP_SEQ_LEQ (Tcb
->SndUna
, Seq
) && TCP_SEQ_LT (Seq
, Tcb
->SndNxt
))) {
1478 IcmpErrStatus
= IpIoGetIcmpErrStatus (
1485 if (IcmpErrNotify
) {
1487 SOCK_ERROR (Tcb
->Sk
, IcmpErrStatus
);
1490 if (IcmpErrIsHard
) {