[mirror_edk2.git] / NetworkPkg / TcpDxe / TcpInput.c

/** @file\r
  TCP input process routines.\r
\r
  Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "TcpMain.h"\r
\r
/**\r
  Check whether the sequence number of the incoming segment is acceptable.\r
\r
  @param[in]  Tcb Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Seg Pointer to the incoming segment.\r
\r
  @retval 1       The sequence number is acceptable.\r
  @retval 0       The sequence number is not acceptable.\r
\r
**/\r
INTN\r
TcpSeqAcceptable (\r
  IN TCP_CB   *Tcb,\r
  IN TCP_SEG  *Seg\r
  )\r
{\r
  return (TCP_SEQ_LEQ (Tcb->RcvNxt, Seg->End) &&\r
          TCP_SEQ_LT (Seg->Seq, Tcb->RcvWl2 + Tcb->RcvWnd));\r
}\r
\r
/**\r
  NewReno fast recovery defined in RFC3782.\r
\r
  @param[in, out]  Tcb      Pointer to the TCP_CB of this TCP instance.\r
  @param[in]       Seg      Segment that triggers the fast recovery.\r
\r
**/\r
VOID\r
TcpFastRecover (\r
  IN OUT TCP_CB   *Tcb,\r
  IN     TCP_SEG  *Seg\r
  )\r
{\r
  UINT32  FlightSize;\r
  UINT32  Acked;\r
\r
  //\r
  // Step 1: Three duplicate ACKs and not in fast recovery\r
  //\r
  if (Tcb->CongestState != TCP_CONGEST_RECOVER) {\r
    //\r
    // Step 1A: Invoking fast retransmission.\r
    //\r
    FlightSize = TCP_SUB_SEQ (Tcb->SndNxt, Tcb->SndUna);\r
\r
    Tcb->Ssthresh = MAX (FlightSize >> 1, (UINT32)(2 * Tcb->SndMss));\r
    Tcb->Recover  = Tcb->SndNxt;\r
\r
    Tcb->CongestState = TCP_CONGEST_RECOVER;\r
    TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_RTT_ON);\r
\r
    //\r
    // Step 2: Entering fast retransmission\r
    //\r
    TcpRetransmit (Tcb, Tcb->SndUna);\r
    Tcb->CWnd = Tcb->Ssthresh + 3 * Tcb->SndMss;\r
\r
    DEBUG (\r
      (DEBUG_NET,\r
       "TcpFastRecover: enter fast retransmission for TCB %p, recover point is %d\n",\r
       Tcb,\r
       Tcb->Recover)\r
      );\r
    return;\r
  }\r
\r
  //\r
  // During fast recovery, execute Step 3, 4, 5 of RFC3782\r
  //\r
  if (Seg->Ack == Tcb->SndUna) {\r
    //\r
    // Step 3: Fast Recovery,\r
    // If this is a duplicated ACK, increse Cwnd by SMSS.\r
    //\r
\r
    // Step 4 is skipped here only to be executed later\r
    // by TcpToSendData\r
    //\r
    Tcb->CWnd += Tcb->SndMss;\r
    DEBUG (\r
      (DEBUG_NET,\r
       "TcpFastRecover: received another duplicated ACK (%d) for TCB %p\n",\r
       Seg->Ack,\r
       Tcb)\r
      );\r
  } else {\r
    //\r
    // New data is ACKed, check whether it is a\r
    // full ACK or partial ACK\r
    //\r
    if (TCP_SEQ_GEQ (Seg->Ack, Tcb->Recover)) {\r
      //\r
      // Step 5 - Full ACK:\r
      // deflate the congestion window, and exit fast recovery\r
      //\r
      FlightSize = TCP_SUB_SEQ (Tcb->SndNxt, Tcb->SndUna);\r
\r
      Tcb->CWnd = MIN (Tcb->Ssthresh, FlightSize + Tcb->SndMss);\r
\r
      Tcb->CongestState = TCP_CONGEST_OPEN;\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpFastRecover: received a full ACK(%d) for TCB %p, exit fast recovery\n",\r
         Seg->Ack,\r
         Tcb)\r
        );\r
    } else {\r
      //\r
      // Step 5 - Partial ACK:\r
      // fast retransmit the first unacknowledge field\r
      // , then deflate the CWnd\r
      //\r
      TcpRetransmit (Tcb, Seg->Ack);\r
      Acked = TCP_SUB_SEQ (Seg->Ack, Tcb->SndUna);\r
\r
      //\r
      // Deflate the CWnd by the amount of new data\r
      // ACKed by SEG.ACK. If more than one SMSS data\r
      // is ACKed, add back SMSS byte to CWnd after\r
      //\r
      if (Acked >= Tcb->SndMss) {\r
        Acked -= Tcb->SndMss;\r
      }\r
\r
      Tcb->CWnd -= Acked;\r
\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpFastRecover: received a partial ACK(%d) for TCB %p\n",\r
         Seg->Ack,\r
         Tcb)\r
        );\r
    }\r
  }\r
}\r
\r
/**\r
  NewReno fast loss recovery defined in RFC3792.\r
\r
  @param[in, out]  Tcb      Pointer to the TCP_CB of this TCP instance.\r
  @param[in]       Seg      Segment that triggers the fast loss recovery.\r
\r
**/\r
VOID\r
TcpFastLossRecover (\r
  IN OUT TCP_CB   *Tcb,\r
  IN     TCP_SEG  *Seg\r
  )\r
{\r
  if (TCP_SEQ_GT (Seg->Ack, Tcb->SndUna)) {\r
    //\r
    // New data is ACKed, check whether it is a\r
    // full ACK or partial ACK\r
    //\r
    if (TCP_SEQ_GEQ (Seg->Ack, Tcb->LossRecover)) {\r
      //\r
      // Full ACK: exit the loss recovery.\r
      //\r
      Tcb->LossTimes    = 0;\r
      Tcb->CongestState = TCP_CONGEST_OPEN;\r
\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpFastLossRecover: received a full ACK(%d) for TCB %p\n",\r
         Seg->Ack,\r
         Tcb)\r
        );\r
    } else {\r
      //\r
      // Partial ACK:\r
      // fast retransmit the first unacknowledge field.\r
      //\r
      TcpRetransmit (Tcb, Seg->Ack);\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpFastLossRecover: received a partial ACK(%d) for TCB %p\n",\r
         Seg->Ack,\r
         Tcb)\r
        );\r
    }\r
  }\r
}\r
\r
/**\r
  Compute the RTT as specified in RFC2988.\r
\r
  @param[in, out]  Tcb      Pointer to the TCP_CB of this TCP instance.\r
  @param[in]       Measure  Currently measured RTT in heartbeats.\r
\r
**/\r
VOID\r
TcpComputeRtt (\r
  IN OUT TCP_CB  *Tcb,\r
  IN     UINT32  Measure\r
  )\r
{\r
  INT32  Var;\r
\r
  //\r
  // Step 2.3: Compute the RTO for subsequent RTT measurement.\r
  //\r
  if (Tcb->SRtt != 0) {\r
    Var = Tcb->SRtt - (Measure << TCP_RTT_SHIFT);\r
\r
    if (Var < 0) {\r
      Var = -Var;\r
    }\r
\r
    Tcb->RttVar = (3 * Tcb->RttVar + Var) >> 2;\r
    Tcb->SRtt   = 7 * (Tcb->SRtt >> 3) + Measure;\r
  } else {\r
    //\r
    // Step 2.2: compute the first RTT measure\r
    //\r
    Tcb->SRtt   = Measure << TCP_RTT_SHIFT;\r
    Tcb->RttVar = Measure << (TCP_RTT_SHIFT - 1);\r
  }\r
\r
  Tcb->Rto = (Tcb->SRtt + MAX (8, 4 * Tcb->RttVar)) >> TCP_RTT_SHIFT;\r
\r
  //\r
  // Step 2.4: Limit the RTO to at least 1 second\r
  // Step 2.5: Limit the RTO to a maximum value that\r
  // is at least 60 second\r
  //\r
  if (Tcb->Rto < TCP_RTO_MIN) {\r
    Tcb->Rto = TCP_RTO_MIN;\r
  } else if (Tcb->Rto > TCP_RTO_MAX) {\r
    Tcb->Rto = TCP_RTO_MAX;\r
  }\r
\r
  DEBUG (\r
    (DEBUG_NET,\r
     "TcpComputeRtt: new RTT for TCB %p computed SRTT: %d RTTVAR: %d RTO: %d\n",\r
     Tcb,\r
     Tcb->SRtt,\r
     Tcb->RttVar,\r
     Tcb->Rto)\r
    );\r
}\r
\r
/**\r
  Trim the data; SYN and FIN to fit into the window defined by Left and Right.\r
\r
  @param[in]  Nbuf     The buffer that contains a received TCP segment without an IP header.\r
  @param[in]  Left     The sequence number of the window's left edge.\r
  @param[in]  Right    The sequence number of the window's right edge.\r
\r
  @retval     0        The segment is broken.\r
  @retval     1        The segment is in good shape.\r
\r
**/\r
INTN\r
TcpTrimSegment (\r
  IN NET_BUF    *Nbuf,\r
  IN TCP_SEQNO  Left,\r
  IN TCP_SEQNO  Right\r
  )\r
{\r
  TCP_SEG    *Seg;\r
  TCP_SEQNO  Urg;\r
  UINT32     Drop;\r
\r
  Seg = TCPSEG_NETBUF (Nbuf);\r
\r
  //\r
  // If the segment is completely out of window,\r
  // truncate every thing, include SYN and FIN.\r
  //\r
  if (TCP_SEQ_LEQ (Seg->End, Left) || TCP_SEQ_LEQ (Right, Seg->Seq)) {\r
    TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_SYN);\r
    TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_FIN);\r
\r
    Seg->Seq = Seg->End;\r
    NetbufTrim (Nbuf, Nbuf->TotalSize, NET_BUF_HEAD);\r
    return 1;\r
  }\r
\r
  //\r
  // Adjust the buffer header\r
  //\r
  if (TCP_SEQ_LT (Seg->Seq, Left)) {\r
    Drop     = TCP_SUB_SEQ (Left, Seg->Seq);\r
    Urg      = Seg->Seq + Seg->Urg;\r
    Seg->Seq = Left;\r
\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {\r
      TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_SYN);\r
      Drop--;\r
    }\r
\r
    //\r
    // Adjust the urgent point\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_URG)) {\r
      if (TCP_SEQ_LT (Urg, Seg->Seq)) {\r
        TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_URG);\r
      } else {\r
        Seg->Urg = (UINT16)TCP_SUB_SEQ (Urg, Seg->Seq);\r
      }\r
    }\r
\r
    if (Drop != 0) {\r
      NetbufTrim (Nbuf, Drop, NET_BUF_HEAD);\r
    }\r
  }\r
\r
  //\r
  // Adjust the buffer tail\r
  //\r
  if (TCP_SEQ_GT (Seg->End, Right)) {\r
    Drop     = TCP_SUB_SEQ (Seg->End, Right);\r
    Seg->End = Right;\r
\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_FIN)) {\r
      TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_FIN);\r
      Drop--;\r
    }\r
\r
    if (Drop != 0) {\r
      NetbufTrim (Nbuf, Drop, NET_BUF_TAIL);\r
    }\r
  }\r
\r
  return TcpVerifySegment (Nbuf);\r
}\r
\r
/**\r
  Trim off the data outside the tcb's receive window.\r
\r
  @param[in]  Tcb      Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Nbuf     Pointer to the NET_BUF containing the received tcp segment.\r
\r
  @retval     0        The segment is broken.\r
  @retval     1        The segment is in good shape.\r
\r
**/\r
INTN\r
TcpTrimInWnd (\r
  IN TCP_CB   *Tcb,\r
  IN NET_BUF  *Nbuf\r
  )\r
{\r
  return TcpTrimSegment (Nbuf, Tcb->RcvNxt, Tcb->RcvWl2 + Tcb->RcvWnd);\r
}\r
\r
/**\r
  Process the data and FIN flag, and check whether to deliver\r
  data to the socket layer.\r
\r
  @param[in, out]  Tcb      Pointer to the TCP_CB of this TCP instance.\r
\r
  @retval 0        No error occurred to deliver data.\r
  @retval -1       An error condition occurred. The proper response is to reset the\r
                   connection.\r
\r
**/\r
INTN\r
TcpDeliverData (\r
  IN OUT TCP_CB  *Tcb\r
  )\r
{\r
  LIST_ENTRY  *Entry;\r
  NET_BUF     *Nbuf;\r
  TCP_SEQNO   Seq;\r
  TCP_SEG     *Seg;\r
  UINT32      Urgent;\r
\r
  ASSERT ((Tcb != NULL) && (Tcb->Sk != NULL));\r
\r
  //\r
  // make sure there is some data queued,\r
  // and TCP is in a proper state\r
  //\r
  if (IsListEmpty (&Tcb->RcvQue) || !TCP_CONNECTED (Tcb->State)) {\r
    return 0;\r
  }\r
\r
  //\r
  // Deliver data to the socket layer\r
  //\r
  Entry = Tcb->RcvQue.ForwardLink;\r
  Seq   = Tcb->RcvNxt;\r
\r
  while (Entry != &Tcb->RcvQue) {\r
    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
    Seg  = TCPSEG_NETBUF (Nbuf);\r
\r
    if (TcpVerifySegment (Nbuf) == 0) {\r
      DEBUG (\r
        (DEBUG_ERROR,\r
         "TcpToSendData: discard a broken segment for TCB %p\n",\r
         Tcb)\r
        );\r
      NetbufFree (Nbuf);\r
      return -1;\r
    }\r
\r
    ASSERT (Nbuf->Tcp == NULL);\r
\r
    if (TCP_SEQ_GT (Seg->Seq, Seq)) {\r
      break;\r
    }\r
\r
    Entry       = Entry->ForwardLink;\r
    Seq         = Seg->End;\r
    Tcb->RcvNxt = Seq;\r
\r
    RemoveEntryList (&Nbuf->List);\r
\r
    //\r
    // RFC793 Eighth step: process FIN in sequence\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_FIN)) {\r
      //\r
      // The peer sends to us junky data after FIN,\r
      // reset the connection.\r
      //\r
      if (!IsListEmpty (&Tcb->RcvQue)) {\r
        DEBUG (\r
          (DEBUG_ERROR,\r
           "TcpDeliverData: data received after FIN from peer of TCB %p, reset connection\n",\r
           Tcb)\r
          );\r
\r
        NetbufFree (Nbuf);\r
        return -1;\r
      }\r
\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpDeliverData: processing FIN from peer of TCB %p\n",\r
         Tcb)\r
        );\r
\r
      switch (Tcb->State) {\r
        case TCP_SYN_RCVD:\r
        case TCP_ESTABLISHED:\r
\r
          TcpSetState (Tcb, TCP_CLOSE_WAIT);\r
          break;\r
\r
        case TCP_FIN_WAIT_1:\r
\r
          if (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_FIN_ACKED)) {\r
            TcpSetState (Tcb, TCP_CLOSING);\r
            break;\r
          }\r
\r
        //\r
        // fall through\r
        //\r
        case TCP_FIN_WAIT_2:\r
\r
          TcpSetState (Tcb, TCP_TIME_WAIT);\r
          TcpClearAllTimer (Tcb);\r
\r
          if (Tcb->TimeWaitTimeout != 0) {\r
            TcpSetTimer (Tcb, TCP_TIMER_2MSL, Tcb->TimeWaitTimeout);\r
          } else {\r
            DEBUG (\r
              (DEBUG_WARN,\r
               "Connection closed immediately because app disables TIME_WAIT timer for %p\n",\r
               Tcb)\r
              );\r
\r
            TcpSendAck (Tcb);\r
            TcpClose (Tcb);\r
          }\r
\r
          break;\r
\r
        case TCP_CLOSE_WAIT:\r
        case TCP_CLOSING:\r
        case TCP_LAST_ACK:\r
        case TCP_TIME_WAIT:\r
          //\r
          // The peer sends to us junk FIN byte. Discard\r
          // the buffer then reset the connection\r
          //\r
          NetbufFree (Nbuf);\r
          return -1;\r
          break;\r
        default:\r
          break;\r
      }\r
\r
      TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
\r
      Seg->End--;\r
    }\r
\r
    //\r
    // Don't delay the ack if PUSH flag is on.\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_PSH)) {\r
      TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
    }\r
\r
    if (Nbuf->TotalSize != 0) {\r
      Urgent = 0;\r
\r
      if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RCVD_URG) &&\r
          TCP_SEQ_LEQ (Seg->Seq, Tcb->RcvUp))\r
      {\r
        if (TCP_SEQ_LEQ (Seg->End, Tcb->RcvUp)) {\r
          Urgent = Nbuf->TotalSize;\r
        } else {\r
          Urgent = TCP_SUB_SEQ (Tcb->RcvUp, Seg->Seq) + 1;\r
        }\r
      }\r
\r
      SockDataRcvd (Tcb->Sk, Nbuf, Urgent);\r
    }\r
\r
    if (TCP_FIN_RCVD (Tcb->State)) {\r
      SockNoMoreData (Tcb->Sk);\r
    }\r
\r
    NetbufFree (Nbuf);\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
  Store the data into the reassemble queue.\r
\r
  @param[in, out]  Tcb   Pointer to the TCP_CB of this TCP instance.\r
  @param[in]       Nbuf  Pointer to the buffer containing the data to be queued.\r
\r
  @retval          0     An error condition occurred.\r
  @retval          1     No error occurred to queue data.\r
\r
**/\r
INTN\r
TcpQueueData (\r
  IN OUT TCP_CB   *Tcb,\r
  IN     NET_BUF  *Nbuf\r
  )\r
{\r
  TCP_SEG     *Seg;\r
  LIST_ENTRY  *Head;\r
  LIST_ENTRY  *Prev;\r
  LIST_ENTRY  *Cur;\r
  NET_BUF     *Node;\r
\r
  ASSERT ((Tcb != NULL) && (Nbuf != NULL) && (Nbuf->Tcp == NULL));\r
\r
  NET_GET_REF (Nbuf);\r
\r
  Seg  = TCPSEG_NETBUF (Nbuf);\r
  Head = &Tcb->RcvQue;\r
\r
  //\r
  // Fast path to process normal case. That is,\r
  // no out-of-order segments are received.\r
  //\r
  if (IsListEmpty (Head)) {\r
    InsertTailList (Head, &Nbuf->List);\r
    return 1;\r
  }\r
\r
  //\r
  // Find the point to insert the buffer\r
  //\r
  for (Prev = Head, Cur = Head->ForwardLink;\r
       Cur != Head;\r
       Prev = Cur, Cur = Cur->ForwardLink)\r
  {\r
    Node = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);\r
\r
    if (TCP_SEQ_LT (Seg->Seq, TCPSEG_NETBUF (Node)->Seq)) {\r
      break;\r
    }\r
  }\r
\r
  //\r
  // Check whether the current segment overlaps with the\r
  // previous segment.\r
  //\r
  if (Prev != Head) {\r
    Node = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);\r
\r
    if (TCP_SEQ_LT (Seg->Seq, TCPSEG_NETBUF (Node)->End)) {\r
      if (TCP_SEQ_LEQ (Seg->End, TCPSEG_NETBUF (Node)->End)) {\r
        return 1;\r
      }\r
\r
      if (TcpTrimSegment (Nbuf, TCPSEG_NETBUF (Node)->End, Seg->End) == 0) {\r
        return 0;\r
      }\r
    }\r
  }\r
\r
  InsertHeadList (Prev, &Nbuf->List);\r
\r
  TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
\r
  //\r
  // Check the segments after the insert point.\r
  //\r
  while (Cur != Head) {\r
    Node = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);\r
\r
    if (TCP_SEQ_LEQ (TCPSEG_NETBUF (Node)->End, Seg->End)) {\r
      Cur = Cur->ForwardLink;\r
\r
      RemoveEntryList (&Node->List);\r
      NetbufFree (Node);\r
      continue;\r
    }\r
\r
    if (TCP_SEQ_LT (TCPSEG_NETBUF (Node)->Seq, Seg->End)) {\r
      if (TCP_SEQ_LEQ (TCPSEG_NETBUF (Node)->Seq, Seg->Seq)) {\r
        RemoveEntryList (&Nbuf->List);\r
        return 1;\r
      }\r
\r
      if (TcpTrimSegment (Nbuf, Seg->Seq, TCPSEG_NETBUF (Node)->Seq) == 0) {\r
        RemoveEntryList (&Nbuf->List);\r
        return 0;\r
      }\r
\r
      break;\r
    }\r
\r
    Cur = Cur->ForwardLink;\r
  }\r
\r
  return 1;\r
}\r
\r
/**\r
  Adjust the send queue or the retransmit queue.\r
\r
  @param[in]  Tcb      Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Ack      The acknowledge sequence number of the received segment.\r
\r
  @retval          0     An error condition occurred.\r
  @retval          1     No error occurred.\r
\r
**/\r
INTN\r
TcpAdjustSndQue (\r
  IN TCP_CB     *Tcb,\r
  IN TCP_SEQNO  Ack\r
  )\r
{\r
  LIST_ENTRY  *Head;\r
  LIST_ENTRY  *Cur;\r
  NET_BUF     *Node;\r
  TCP_SEG     *Seg;\r
\r
  Head = &Tcb->SndQue;\r
  Cur  = Head->ForwardLink;\r
\r
  while (Cur != Head) {\r
    Node = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);\r
    Seg  = TCPSEG_NETBUF (Node);\r
\r
    if (TCP_SEQ_GEQ (Seg->Seq, Ack)) {\r
      break;\r
    }\r
\r
    //\r
    // Remove completely ACKed segments\r
    //\r
    if (TCP_SEQ_LEQ (Seg->End, Ack)) {\r
      Cur = Cur->ForwardLink;\r
\r
      RemoveEntryList (&Node->List);\r
      NetbufFree (Node);\r
      continue;\r
    }\r
\r
    return TcpTrimSegment (Node, Ack, Seg->End);\r
  }\r
\r
  return 1;\r
}\r
\r
/**\r
  Process the received TCP segments.\r
\r
  @param[in]  Nbuf     Buffer that contains received a TCP segment without an IP header.\r
  @param[in]  Src      Source address of the segment, or the peer's IP address.\r
  @param[in]  Dst      Destination address of the segment, or the local end's IP\r
                       address.\r
  @param[in]  Version  IP_VERSION_4 indicates IP4 stack. IP_VERSION_6 indicates\r
                       IP6 stack.\r
\r
  @retval 0        Segment  processed successfully. It is either accepted or\r
                   discarded. However, no connection is reset by the segment.\r
  @retval -1       A connection is reset by the segment.\r
\r
**/\r
INTN\r
TcpInput (\r
  IN NET_BUF         *Nbuf,\r
  IN EFI_IP_ADDRESS  *Src,\r
  IN EFI_IP_ADDRESS  *Dst,\r
  IN UINT8           Version\r
  )\r
{\r
  TCP_CB      *Tcb;\r
  TCP_CB      *Parent;\r
  TCP_OPTION  Option;\r
  TCP_HEAD    *Head;\r
  INT32       Len;\r
  TCP_SEG     *Seg;\r
  TCP_SEQNO   Right;\r
  TCP_SEQNO   Urg;\r
  UINT16      Checksum;\r
  INT32       Usable;\r
\r
  ASSERT ((Version == IP_VERSION_4) || (Version == IP_VERSION_6));\r
\r
  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
  Parent = NULL;\r
  Tcb    = NULL;\r
\r
  Head = (TCP_HEAD *)NetbufGetByte (Nbuf, 0, NULL);\r
  ASSERT (Head != NULL);\r
\r
  if (Nbuf->TotalSize < sizeof (TCP_HEAD)) {\r
    DEBUG ((DEBUG_NET, "TcpInput: received a malformed packet\n"));\r
    goto DISCARD;\r
  }\r
\r
  Len = Nbuf->TotalSize - (Head->HeadLen << 2);\r
\r
  if ((Head->HeadLen < 5) || (Len < 0)) {\r
    DEBUG ((DEBUG_NET, "TcpInput: received a malformed packet\n"));\r
\r
    goto DISCARD;\r
  }\r
\r
  if (Version == IP_VERSION_4) {\r
    Checksum = NetPseudoHeadChecksum (Src->Addr[0], Dst->Addr[0], 6, 0);\r
  } else {\r
    Checksum = NetIp6PseudoHeadChecksum (&Src->v6, &Dst->v6, 6, 0);\r
  }\r
\r
  Checksum = TcpChecksum (Nbuf, Checksum);\r
\r
  if (Checksum != 0) {\r
    DEBUG ((DEBUG_ERROR, "TcpInput: received a checksum error packet\n"));\r
    goto DISCARD;\r
  }\r
\r
  if (TCP_FLG_ON (Head->Flag, TCP_FLG_SYN)) {\r
    Len++;\r
  }\r
\r
  if (TCP_FLG_ON (Head->Flag, TCP_FLG_FIN)) {\r
    Len++;\r
  }\r
\r
  Tcb = TcpLocateTcb (\r
          Head->DstPort,\r
          Dst,\r
          Head->SrcPort,\r
          Src,\r
          Version,\r
          (BOOLEAN)TCP_FLG_ON (Head->Flag, TCP_FLG_SYN)\r
          );\r
\r
  if ((Tcb == NULL) || (Tcb->State == TCP_CLOSED)) {\r
    DEBUG ((DEBUG_NET, "TcpInput: send reset because no TCB found\n"));\r
\r
    Tcb = NULL;\r
    goto SEND_RESET;\r
  }\r
\r
  Seg = TcpFormatNetbuf (Tcb, Nbuf);\r
\r
  //\r
  // RFC1122 recommended reaction to illegal option\r
  // (in fact, an illegal option length) is reset.\r
  //\r
  if (TcpParseOption (Nbuf->Tcp, &Option) == -1) {\r
    DEBUG (\r
      (DEBUG_ERROR,\r
       "TcpInput: reset the peer because of malformed option for TCB %p\n",\r
       Tcb)\r
      );\r
\r
    goto SEND_RESET;\r
  }\r
\r
  //\r
  // From now on, the segment is headless\r
  //\r
  NetbufTrim (Nbuf, (Head->HeadLen << 2), NET_BUF_HEAD);\r
  Nbuf->Tcp = NULL;\r
\r
  //\r
  // Process the segment in LISTEN state.\r
  //\r
  if (Tcb->State == TCP_LISTEN) {\r
    //\r
    // First step: Check RST\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_RST)) {\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: discard a reset segment for TCB %p in listening\n",\r
         Tcb)\r
        );\r
\r
      goto DISCARD;\r
    }\r
\r
    //\r
    // Second step: Check ACK.\r
    // Any ACK sent to TCP in LISTEN is reseted.\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_ACK)) {\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: send reset because of segment with ACK for TCB %p in listening\n",\r
         Tcb)\r
        );\r
\r
      goto SEND_RESET;\r
    }\r
\r
    //\r
    // Third step: Check SYN\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {\r
      //\r
      // create a child TCB to handle the data\r
      //\r
      Parent = Tcb;\r
\r
      Tcb = TcpCloneTcb (Parent);\r
      if (Tcb == NULL) {\r
        DEBUG (\r
          (DEBUG_ERROR,\r
           "TcpInput: discard a segment because failed to clone a child for TCB %p\n",\r
           Tcb)\r
          );\r
\r
        goto DISCARD;\r
      }\r
\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpInput: create a child for TCB %p in listening\n",\r
         Tcb)\r
        );\r
\r
      //\r
      // init the TCB structure\r
      //\r
      IP6_COPY_ADDRESS (&Tcb->LocalEnd.Ip, Dst);\r
      IP6_COPY_ADDRESS (&Tcb->RemoteEnd.Ip, Src);\r
      Tcb->LocalEnd.Port  = Head->DstPort;\r
      Tcb->RemoteEnd.Port = Head->SrcPort;\r
\r
      TcpInitTcbLocal (Tcb);\r
      TcpInitTcbPeer (Tcb, Seg, &Option);\r
\r
      TcpSetState (Tcb, TCP_SYN_RCVD);\r
      TcpSetTimer (Tcb, TCP_TIMER_CONNECT, Tcb->ConnectTimeout);\r
      if (TcpTrimInWnd (Tcb, Nbuf) == 0) {\r
        DEBUG (\r
          (DEBUG_ERROR,\r
           "TcpInput: discard a broken segment for TCB %p\n",\r
           Tcb)\r
          );\r
\r
        goto DISCARD;\r
      }\r
\r
      goto StepSix;\r
    }\r
\r
    goto DISCARD;\r
  } else if (Tcb->State == TCP_SYN_SENT) {\r
    //\r
    // First step: Check ACK bit\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_ACK) && (Seg->Ack != Tcb->Iss + 1)) {\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: send reset because of wrong ACK received for TCB %p in SYN_SENT\n",\r
         Tcb)\r
        );\r
\r
      goto SEND_RESET;\r
    }\r
\r
    //\r
    // Second step: Check RST bit\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_RST)) {\r
      if (TCP_FLG_ON (Seg->Flag, TCP_FLG_ACK)) {\r
        DEBUG (\r
          (DEBUG_WARN,\r
           "TcpInput: connection reset by peer for TCB %p in SYN_SENT\n",\r
           Tcb)\r
          );\r
\r
        SOCK_ERROR (Tcb->Sk, EFI_CONNECTION_RESET);\r
        goto DROP_CONNECTION;\r
      } else {\r
        DEBUG (\r
          (DEBUG_WARN,\r
           "TcpInput: discard a reset segment because of no ACK for TCB %p in SYN_SENT\n",\r
           Tcb)\r
          );\r
\r
        goto DISCARD;\r
      }\r
    }\r
\r
    //\r
    // Third step: Check security and precedence. Skipped\r
    //\r
\r
    //\r
    // Fourth step: Check SYN. Pay attention to simultaneous open\r
    //\r
    if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {\r
      TcpInitTcbPeer (Tcb, Seg, &Option);\r
\r
      if (TCP_FLG_ON (Seg->Flag, TCP_FLG_ACK)) {\r
        Tcb->SndUna = Seg->Ack;\r
      }\r
\r
      TcpClearTimer (Tcb, TCP_TIMER_REXMIT);\r
\r
      if (TCP_SEQ_GT (Tcb->SndUna, Tcb->Iss)) {\r
        TcpSetState (Tcb, TCP_ESTABLISHED);\r
\r
        TcpClearTimer (Tcb, TCP_TIMER_CONNECT);\r
        TcpDeliverData (Tcb);\r
\r
        if ((Tcb->CongestState == TCP_CONGEST_OPEN) &&\r
            TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RTT_ON))\r
        {\r
          TcpComputeRtt (Tcb, Tcb->RttMeasure);\r
          TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_RTT_ON);\r
        }\r
\r
        if (TcpTrimInWnd (Tcb, Nbuf) == 0) {\r
          DEBUG (\r
            (DEBUG_ERROR,\r
             "TcpInput: discard a broken segment for TCB %p\n",\r
             Tcb)\r
            );\r
\r
          goto DISCARD;\r
        }\r
\r
        TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
\r
        DEBUG (\r
          (DEBUG_NET,\r
           "TcpInput: connection established for TCB %p in SYN_SENT\n",\r
           Tcb)\r
          );\r
\r
        goto StepSix;\r
      } else {\r
        //\r
        // Received a SYN segment without ACK, simultaneous open.\r
        //\r
        TcpSetState (Tcb, TCP_SYN_RCVD);\r
\r
        ASSERT (Tcb->SndNxt == Tcb->Iss + 1);\r
\r
        if ((TcpAdjustSndQue (Tcb, Tcb->SndNxt) == 0) || (TcpTrimInWnd (Tcb, Nbuf) == 0)) {\r
          DEBUG (\r
            (DEBUG_ERROR,\r
             "TcpInput: discard a broken segment for TCB %p\n",\r
             Tcb)\r
            );\r
\r
          goto DISCARD;\r
        }\r
\r
        DEBUG (\r
          (DEBUG_WARN,\r
           "TcpInput: simultaneous open for TCB %p in SYN_SENT\n",\r
           Tcb)\r
          );\r
\r
        goto StepSix;\r
      }\r
    }\r
\r
    goto DISCARD;\r
  }\r
\r
  //\r
  // Process segment in SYN_RCVD or TCP_CONNECTED states\r
  //\r
\r
  //\r
  // Clear probe timer since the RecvWindow is opened.\r
  //\r
  if (Tcb->ProbeTimerOn && (Seg->Wnd != 0)) {\r
    TcpClearTimer (Tcb, TCP_TIMER_PROBE);\r
    Tcb->ProbeTimerOn = FALSE;\r
  }\r
\r
  //\r
  // First step: Check whether SEG.SEQ is acceptable\r
  //\r
  if (TcpSeqAcceptable (Tcb, Seg) == 0) {\r
    DEBUG (\r
      (DEBUG_WARN,\r
       "TcpInput: sequence acceptance test failed for segment of TCB %p\n",\r
       Tcb)\r
      );\r
\r
    if (!TCP_FLG_ON (Seg->Flag, TCP_FLG_RST)) {\r
      TcpSendAck (Tcb);\r
    }\r
\r
    goto DISCARD;\r
  }\r
\r
  if ((TCP_SEQ_LT (Seg->Seq, Tcb->RcvWl2)) &&\r
      (Tcb->RcvWl2 == Seg->End) &&\r
      !TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN | TCP_FLG_FIN))\r
  {\r
    TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
  }\r
\r
  //\r
  // Second step: Check the RST\r
  //\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_RST)) {\r
    DEBUG ((DEBUG_WARN, "TcpInput: connection reset for TCB %p\n", Tcb));\r
\r
    if (Tcb->State == TCP_SYN_RCVD) {\r
      SOCK_ERROR (Tcb->Sk, EFI_CONNECTION_REFUSED);\r
\r
      //\r
      // This TCB comes from either a LISTEN TCB,\r
      // or active open TCB with simultaneous open.\r
      // Do NOT signal user CONNECTION refused\r
      // if it comes from a LISTEN TCB.\r
      //\r
    } else if ((Tcb->State == TCP_ESTABLISHED) ||\r
               (Tcb->State == TCP_FIN_WAIT_1) ||\r
               (Tcb->State == TCP_FIN_WAIT_2) ||\r
               (Tcb->State == TCP_CLOSE_WAIT))\r
    {\r
      SOCK_ERROR (Tcb->Sk, EFI_CONNECTION_RESET);\r
    } else {\r
    }\r
\r
    goto DROP_CONNECTION;\r
  }\r
\r
  //\r
  // Trim the data and flags.\r
  //\r
  if (TcpTrimInWnd (Tcb, Nbuf) == 0) {\r
    DEBUG (\r
      (DEBUG_ERROR,\r
       "TcpInput: discard a broken segment for TCB %p\n",\r
       Tcb)\r
      );\r
\r
    goto DISCARD;\r
  }\r
\r
  //\r
  // Third step: Check security and precedence, Ignored\r
  //\r
\r
  //\r
  // Fourth step: Check the SYN bit.\r
  //\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {\r
    DEBUG (\r
      (DEBUG_WARN,\r
       "TcpInput: connection reset because received extra SYN for TCB %p\n",\r
       Tcb)\r
      );\r
\r
    SOCK_ERROR (Tcb->Sk, EFI_CONNECTION_RESET);\r
    goto RESET_THEN_DROP;\r
  }\r
\r
  //\r
  // Fifth step: Check the ACK\r
  //\r
  if (!TCP_FLG_ON (Seg->Flag, TCP_FLG_ACK)) {\r
    DEBUG (\r
      (DEBUG_WARN,\r
       "TcpInput: segment discard because of no ACK for connected TCB %p\n",\r
       Tcb)\r
      );\r
\r
    goto DISCARD;\r
  } else {\r
    if ((Tcb->IpInfo->IpVersion == IP_VERSION_6) && (Tcb->Tick == 0)) {\r
      Tcp6RefreshNeighbor (Tcb, Src, TCP6_KEEP_NEIGHBOR_TIME * TICKS_PER_SECOND);\r
      Tcb->Tick = TCP6_REFRESH_NEIGHBOR_TICK;\r
    }\r
  }\r
\r
  if (Tcb->State == TCP_SYN_RCVD) {\r
    if (TCP_SEQ_LT (Tcb->SndUna, Seg->Ack) &&\r
        TCP_SEQ_LEQ (Seg->Ack, Tcb->SndNxt))\r
    {\r
      Tcb->SndWnd    = Seg->Wnd;\r
      Tcb->SndWndMax = MAX (Tcb->SndWnd, Tcb->SndWndMax);\r
      Tcb->SndWl1    = Seg->Seq;\r
      Tcb->SndWl2    = Seg->Ack;\r
      TcpSetState (Tcb, TCP_ESTABLISHED);\r
\r
      TcpClearTimer (Tcb, TCP_TIMER_CONNECT);\r
      TcpDeliverData (Tcb);\r
\r
      DEBUG (\r
        (DEBUG_NET,\r
         "TcpInput: connection established for TCB %p in SYN_RCVD\n",\r
         Tcb)\r
        );\r
\r
      //\r
      // Continue the process as ESTABLISHED state\r
      //\r
    } else {\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: send reset because of wrong ACK for TCB %p in SYN_RCVD\n",\r
         Tcb)\r
        );\r
\r
      goto SEND_RESET;\r
    }\r
  }\r
\r
  if (TCP_SEQ_LT (Seg->Ack, Tcb->SndUna)) {\r
    DEBUG (\r
      (DEBUG_WARN,\r
       "TcpInput: ignore the out-of-data ACK for connected TCB %p\n",\r
       Tcb)\r
      );\r
\r
    goto StepSix;\r
  } else if (TCP_SEQ_GT (Seg->Ack, Tcb->SndNxt)) {\r
    DEBUG (\r
      (DEBUG_WARN,\r
       "TcpInput: discard segment for future ACK for connected TCB %p\n",\r
       Tcb)\r
      );\r
\r
    TcpSendAck (Tcb);\r
    goto DISCARD;\r
  }\r
\r
  //\r
  // From now on: SND.UNA <= SEG.ACK <= SND.NXT.\r
  //\r
  if (TCP_FLG_ON (Option.Flag, TCP_OPTION_RCVD_TS)) {\r
    //\r
    // update TsRecent as specified in page 16 RFC1323.\r
    // RcvWl2 equals to the variable "LastAckSent"\r
    // defined there.\r
    //\r
    if (TCP_SEQ_LEQ (Seg->Seq, Tcb->RcvWl2) &&\r
        TCP_SEQ_LT (Tcb->RcvWl2, Seg->End))\r
    {\r
      Tcb->TsRecent    = Option.TSVal;\r
      Tcb->TsRecentAge = mTcpTick;\r
    }\r
\r
    TcpComputeRtt (Tcb, TCP_SUB_TIME (mTcpTick, Option.TSEcr));\r
  } else if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RTT_ON)) {\r
    ASSERT (Tcb->CongestState == TCP_CONGEST_OPEN);\r
\r
    TcpComputeRtt (Tcb, Tcb->RttMeasure);\r
    TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_RTT_ON);\r
  }\r
\r
  if (Seg->Ack == Tcb->SndNxt) {\r
    TcpClearTimer (Tcb, TCP_TIMER_REXMIT);\r
  } else {\r
    TcpSetTimer (Tcb, TCP_TIMER_REXMIT, Tcb->Rto);\r
  }\r
\r
  //\r
  // Count duplicate acks.\r
  //\r
  if ((Seg->Ack == Tcb->SndUna) &&\r
      (Tcb->SndUna != Tcb->SndNxt) &&\r
      (Seg->Wnd == Tcb->SndWnd) &&\r
      (0 == Len))\r
  {\r
    Tcb->DupAck++;\r
  } else {\r
    Tcb->DupAck = 0;\r
  }\r
\r
  //\r
  // Congestion avoidance, fast recovery and fast retransmission.\r
  //\r
  if (((Tcb->CongestState == TCP_CONGEST_OPEN) && (Tcb->DupAck < 3)) ||\r
      (Tcb->CongestState == TCP_CONGEST_LOSS))\r
  {\r
    if (TCP_SEQ_GT (Seg->Ack, Tcb->SndUna)) {\r
      if (Tcb->CWnd < Tcb->Ssthresh) {\r
        Tcb->CWnd += Tcb->SndMss;\r
      } else {\r
        Tcb->CWnd += MAX (Tcb->SndMss * Tcb->SndMss / Tcb->CWnd, 1);\r
      }\r
\r
      Tcb->CWnd = MIN (Tcb->CWnd, TCP_MAX_WIN << Tcb->SndWndScale);\r
    }\r
\r
    if (Tcb->CongestState == TCP_CONGEST_LOSS) {\r
      TcpFastLossRecover (Tcb, Seg);\r
    }\r
  } else {\r
    TcpFastRecover (Tcb, Seg);\r
  }\r
\r
  if (TCP_SEQ_GT (Seg->Ack, Tcb->SndUna)) {\r
    if (TcpAdjustSndQue (Tcb, Seg->Ack) == 0) {\r
      DEBUG (\r
        (DEBUG_ERROR,\r
         "TcpInput: discard a broken segment for TCB %p\n",\r
         Tcb)\r
        );\r
\r
      goto DISCARD;\r
    }\r
\r
    Tcb->SndUna = Seg->Ack;\r
\r
    if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_SND_URG) &&\r
        TCP_SEQ_LT (Tcb->SndUp, Seg->Ack))\r
    {\r
      TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_URG);\r
    }\r
  }\r
\r
  //\r
  // Update window info\r
  //\r
  if (TCP_SEQ_LT (Tcb->SndWl1, Seg->Seq) ||\r
      ((Tcb->SndWl1 == Seg->Seq) && TCP_SEQ_LEQ (Tcb->SndWl2, Seg->Ack)))\r
  {\r
    Right = Seg->Ack + Seg->Wnd;\r
\r
    if (TCP_SEQ_LT (Right, Tcb->SndWl2 + Tcb->SndWnd)) {\r
      if ((Tcb->SndWl1 == Seg->Seq) &&\r
          (Tcb->SndWl2 == Seg->Ack) &&\r
          (Len == 0))\r
      {\r
        goto NO_UPDATE;\r
      }\r
\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: peer shrinks the window for connected TCB %p\n",\r
         Tcb)\r
        );\r
\r
      if ((Tcb->CongestState == TCP_CONGEST_RECOVER) &&\r
          (TCP_SEQ_LT (Right, Tcb->Recover)))\r
      {\r
        Tcb->Recover = Right;\r
      }\r
\r
      if ((Tcb->CongestState == TCP_CONGEST_LOSS) &&\r
          (TCP_SEQ_LT (Right, Tcb->LossRecover)))\r
      {\r
        Tcb->LossRecover = Right;\r
      }\r
\r
      if (TCP_SEQ_LT (Right, Tcb->SndNxt)) {\r
        //\r
        // Check for Window Retraction in RFC7923 section 2.4.\r
        // The lower n bits of the peer's actual receive window is wiped out if TCP\r
        // window scale is enabled, it will look like the peer is shrinking the window.\r
        // Check whether the SndNxt is out of the advertised receive window by more than\r
        // 2^Rcv.Wind.Shift before moving the SndNxt to the left.\r
        //\r
        DEBUG (\r
          (DEBUG_WARN,\r
           "TcpInput: peer advise negative useable window for connected TCB %p\n",\r
           Tcb)\r
          );\r
        Usable = TCP_SUB_SEQ (Tcb->SndNxt, Right);\r
        if ((Usable >> Tcb->SndWndScale) > 0) {\r
          DEBUG (\r
            (DEBUG_WARN,\r
             "TcpInput: SndNxt is out of window by more than window scale for TCB %p\n",\r
             Tcb)\r
            );\r
          Tcb->SndNxt = Right;\r
        }\r
\r
        if (Right == Tcb->SndUna) {\r
          TcpClearTimer (Tcb, TCP_TIMER_REXMIT);\r
          TcpSetProbeTimer (Tcb);\r
        }\r
      }\r
    }\r
\r
    Tcb->SndWnd    = Seg->Wnd;\r
    Tcb->SndWndMax = MAX (Tcb->SndWnd, Tcb->SndWndMax);\r
    Tcb->SndWl1    = Seg->Seq;\r
    Tcb->SndWl2    = Seg->Ack;\r
  }\r
\r
NO_UPDATE:\r
\r
  if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_FIN_SENT) &&\r
      (Tcb->SndUna == Tcb->SndNxt))\r
  {\r
    DEBUG (\r
      (DEBUG_NET,\r
       "TcpInput: local FIN is ACKed by peer for connected TCB %p\n",\r
       Tcb)\r
      );\r
\r
    TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_FIN_ACKED);\r
  }\r
\r
  //\r
  // Transit the state if proper.\r
  //\r
  switch (Tcb->State) {\r
    case TCP_FIN_WAIT_1:\r
\r
      if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_FIN_ACKED)) {\r
        TcpSetState (Tcb, TCP_FIN_WAIT_2);\r
\r
        TcpClearAllTimer (Tcb);\r
        TcpSetTimer (Tcb, TCP_TIMER_FINWAIT2, Tcb->FinWait2Timeout);\r
      }\r
\r
    case TCP_FIN_WAIT_2:\r
\r
      break;\r
\r
    case TCP_CLOSE_WAIT:\r
      break;\r
\r
    case TCP_CLOSING:\r
\r
      if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_FIN_ACKED)) {\r
        TcpSetState (Tcb, TCP_TIME_WAIT);\r
\r
        TcpClearAllTimer (Tcb);\r
\r
        if (Tcb->TimeWaitTimeout != 0) {\r
          TcpSetTimer (Tcb, TCP_TIMER_2MSL, Tcb->TimeWaitTimeout);\r
        } else {\r
          DEBUG (\r
            (DEBUG_WARN,\r
             "Connection closed immediately because app disables TIME_WAIT timer for %p\n",\r
             Tcb)\r
            );\r
\r
          TcpClose (Tcb);\r
        }\r
      }\r
\r
      break;\r
\r
    case TCP_LAST_ACK:\r
\r
      if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_FIN_ACKED)) {\r
        TcpSetState (Tcb, TCP_CLOSED);\r
      }\r
\r
      break;\r
\r
    case TCP_TIME_WAIT:\r
\r
      TcpSendAck (Tcb);\r
\r
      if (Tcb->TimeWaitTimeout != 0) {\r
        TcpSetTimer (Tcb, TCP_TIMER_2MSL, Tcb->TimeWaitTimeout);\r
      } else {\r
        DEBUG (\r
          (DEBUG_WARN,\r
           "Connection closed immediately because app disables TIME_WAIT timer for %p\n",\r
           Tcb)\r
          );\r
\r
        TcpClose (Tcb);\r
      }\r
\r
      break;\r
\r
    default:\r
      break;\r
  }\r
\r
  //\r
  // Sixth step: Check the URG bit.update the Urg point\r
  // if in TCP_CAN_RECV, otherwise, leave the RcvUp intact.\r
  //\r
StepSix:\r
\r
  Tcb->Idle = 0;\r
  TcpSetKeepaliveTimer (Tcb);\r
\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_URG) && !TCP_FIN_RCVD (Tcb->State)) {\r
    DEBUG (\r
      (DEBUG_NET,\r
       "TcpInput: received urgent data from peer for connected TCB %p\n",\r
       Tcb)\r
      );\r
\r
    Urg = Seg->Seq + Seg->Urg;\r
\r
    if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RCVD_URG) &&\r
        TCP_SEQ_GT (Urg, Tcb->RcvUp))\r
    {\r
      Tcb->RcvUp = Urg;\r
    } else {\r
      Tcb->RcvUp = Urg;\r
      TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_RCVD_URG);\r
    }\r
  }\r
\r
  //\r
  // Seventh step: Process the segment data\r
  //\r
  if (Seg->End != Seg->Seq) {\r
    if (TCP_FIN_RCVD (Tcb->State)) {\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: connection reset because data is lost for connected TCB %p\n",\r
         Tcb)\r
        );\r
\r
      goto RESET_THEN_DROP;\r
    }\r
\r
    if (TCP_LOCAL_CLOSED (Tcb->State) && (Nbuf->TotalSize != 0)) {\r
      DEBUG (\r
        (DEBUG_WARN,\r
         "TcpInput: connection reset because data is lost for connected TCB %p\n",\r
         Tcb)\r
        );\r
\r
      goto RESET_THEN_DROP;\r
    }\r
\r
    if (TcpQueueData (Tcb, Nbuf) == 0) {\r
      DEBUG (\r
        (DEBUG_ERROR,\r
         "TcpInput: discard a broken segment for TCB %p\n",\r
         Tcb)\r
        );\r
\r
      goto DISCARD;\r
    }\r
\r
    if (TcpDeliverData (Tcb) == -1) {\r
      goto RESET_THEN_DROP;\r
    }\r
\r
    if (!IsListEmpty (&Tcb->RcvQue)) {\r
      TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
    }\r
  }\r
\r
  //\r
  // Eighth step: check the FIN.\r
  // This step is moved to TcpDeliverData. FIN will be\r
  // processed in sequence there. Check the comments in\r
  // the beginning of the file header for information.\r
  //\r
\r
  //\r
  // Tcb is a new child of the listening Parent,\r
  // commit it.\r
  //\r
  if (Parent != NULL) {\r
    Tcb->Parent = Parent;\r
    TcpInsertTcb (Tcb);\r
  }\r
\r
  if ((Tcb->State != TCP_CLOSED) &&\r
      (TcpToSendData (Tcb, 0) == 0) &&\r
      (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW) || (Nbuf->TotalSize != 0)))\r
  {\r
    TcpToSendAck (Tcb);\r
  }\r
\r
  NetbufFree (Nbuf);\r
  return 0;\r
\r
RESET_THEN_DROP:\r
  TcpSendReset (Tcb, Head, Len, Dst, Src, Version);\r
\r
DROP_CONNECTION:\r
  ASSERT ((Tcb != NULL) && (Tcb->Sk != NULL));\r
\r
  NetbufFree (Nbuf);\r
  TcpClose (Tcb);\r
\r
  return -1;\r
\r
SEND_RESET:\r
\r
  TcpSendReset (Tcb, Head, Len, Dst, Src, Version);\r
\r
DISCARD:\r
\r
  //\r
  // Tcb is a child of Parent, and it doesn't survive\r
  //\r
  DEBUG ((DEBUG_WARN, "TcpInput: Discard a packet\n"));\r
  NetbufFree (Nbuf);\r
\r
  if ((Parent != NULL) && (Tcb != NULL)) {\r
    ASSERT (Tcb->Sk != NULL);\r
    TcpClose (Tcb);\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
  Process the received ICMP error messages for TCP.\r
\r
  @param[in]  Nbuf     The buffer that contains part of the TCP segment without an IP header\r
                       truncated from the ICMP error packet.\r
  @param[in]  IcmpErr  The ICMP error code interpreted from an ICMP error packet.\r
  @param[in]  Src      Source address of the ICMP error message.\r
  @param[in]  Dst      Destination address of the ICMP error message.\r
  @param[in]  Version  IP_VERSION_4 indicates IP4 stack. IP_VERSION_6 indicates\r
                       IP6 stack.\r
\r
**/\r
VOID\r
TcpIcmpInput (\r
  IN NET_BUF         *Nbuf,\r
  IN UINT8           IcmpErr,\r
  IN EFI_IP_ADDRESS  *Src,\r
  IN EFI_IP_ADDRESS  *Dst,\r
  IN UINT8           Version\r
  )\r
{\r
  TCP_HEAD    *Head;\r
  TCP_CB      *Tcb;\r
  TCP_SEQNO   Seq;\r
  EFI_STATUS  IcmpErrStatus;\r
  BOOLEAN     IcmpErrIsHard;\r
  BOOLEAN     IcmpErrNotify;\r
\r
  if (Nbuf->TotalSize < sizeof (TCP_HEAD)) {\r
    goto CLEAN_EXIT;\r
  }\r
\r
  Head = (TCP_HEAD *)NetbufGetByte (Nbuf, 0, NULL);\r
  ASSERT (Head != NULL);\r
\r
  Tcb = TcpLocateTcb (\r
          Head->DstPort,\r
          Dst,\r
          Head->SrcPort,\r
          Src,\r
          Version,\r
          FALSE\r
          );\r
  if ((Tcb == NULL) || (Tcb->State == TCP_CLOSED)) {\r
    goto CLEAN_EXIT;\r
  }\r
\r
  //\r
  // Validate the sequence number.\r
  //\r
  Seq = NTOHL (Head->Seq);\r
  if (!(TCP_SEQ_LEQ (Tcb->SndUna, Seq) && TCP_SEQ_LT (Seq, Tcb->SndNxt))) {\r
    goto CLEAN_EXIT;\r
  }\r
\r
  IcmpErrStatus = IpIoGetIcmpErrStatus (\r
                    IcmpErr,\r
                    Tcb->Sk->IpVersion,\r
                    &IcmpErrIsHard,\r
                    &IcmpErrNotify\r
                    );\r
\r
  if (IcmpErrNotify) {\r
    SOCK_ERROR (Tcb->Sk, IcmpErrStatus);\r
  }\r
\r
  if (IcmpErrIsHard) {\r
    TcpClose (Tcb);\r
  }\r
\r
CLEAN_EXIT:\r
\r
  NetbufFree (Nbuf);\r
}\r