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

/** @file\r
  TCP output 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
UINT8  mTcpOutFlag[] = {\r
  0,                          // TCP_CLOSED\r
  0,                          // TCP_LISTEN\r
  TCP_FLG_SYN,                // TCP_SYN_SENT\r
  TCP_FLG_SYN | TCP_FLG_ACK,  // TCP_SYN_RCVD\r
  TCP_FLG_ACK,                // TCP_ESTABLISHED\r
  TCP_FLG_FIN | TCP_FLG_ACK,  // TCP_FIN_WAIT_1\r
  TCP_FLG_ACK,                // TCP_FIN_WAIT_2\r
  TCP_FLG_ACK | TCP_FLG_FIN,  // TCP_CLOSING\r
  TCP_FLG_ACK,                // TCP_TIME_WAIT\r
  TCP_FLG_ACK,                // TCP_CLOSE_WAIT\r
  TCP_FLG_FIN | TCP_FLG_ACK   // TCP_LAST_ACK\r
};\r
\r
/**\r
  Compute the sequence space left in the old receive window.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
\r
  @return The sequence space left in the old receive window.\r
\r
**/\r
UINT32\r
TcpRcvWinOld (\r
  IN TCP_CB *Tcb\r
  )\r
{\r
  UINT32  OldWin;\r
\r
  OldWin = 0;\r
\r
  if (TCP_SEQ_GT (Tcb->RcvWl2 + Tcb->RcvWnd, Tcb->RcvNxt)) {\r
\r
    OldWin = TCP_SUB_SEQ (\r
              Tcb->RcvWl2 + Tcb->RcvWnd,\r
              Tcb->RcvNxt\r
              );\r
  }\r
\r
  return OldWin;\r
}\r
\r
/**\r
  Compute the current receive window.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
\r
  @return The size of the current receive window, in bytes.\r
\r
**/\r
UINT32\r
TcpRcvWinNow (\r
  IN TCP_CB *Tcb\r
  )\r
{\r
  SOCKET  *Sk;\r
  UINT32  Win;\r
  UINT32  Increase;\r
  UINT32  OldWin;\r
\r
  Sk = Tcb->Sk;\r
  ASSERT (Sk != NULL);\r
\r
  OldWin    = TcpRcvWinOld (Tcb);\r
\r
  Win       = SockGetFreeSpace (Sk, SOCK_RCV_BUF);\r
\r
  Increase  = 0;\r
  if (Win > OldWin) {\r
    Increase = Win - OldWin;\r
  }\r
\r
  //\r
  // Receiver's SWS: don't advertise a bigger window\r
  // unless it can be increased by at least one Mss or\r
  // half of the receive buffer.\r
  //\r
  if ((Increase > Tcb->SndMss) || (2 * Increase >= GET_RCV_BUFFSIZE (Sk))) {\r
\r
    return Win;\r
  }\r
\r
  return OldWin;\r
}\r
\r
/**\r
  Compute the value to fill in the window size field of the outgoing segment.\r
\r
  @param[in, out]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]       Syn     The flag to indicate whether the outgoing segment\r
                           is a SYN segment.\r
\r
  @return The value of the local receive window size used to fill the outgoing segment.\r
\r
**/\r
UINT16\r
TcpComputeWnd (\r
  IN OUT TCP_CB  *Tcb,\r
  IN     BOOLEAN Syn\r
  )\r
{\r
  UINT32  Wnd;\r
\r
  //\r
  // RFC requires that initial window not be scaled\r
  //\r
  if (Syn) {\r
\r
    Wnd = GET_RCV_BUFFSIZE (Tcb->Sk);\r
  } else {\r
\r
    Wnd         = TcpRcvWinNow (Tcb);\r
\r
    Tcb->RcvWnd = Wnd;\r
  }\r
\r
  Wnd = MIN (Wnd >> Tcb->RcvWndScale, 0xffff);\r
  return NTOHS ((UINT16) Wnd);\r
}\r
\r
/**\r
  Get the maximum SndNxt.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
\r
  @return The sequence number of the maximum SndNxt.\r
\r
**/\r
TCP_SEQNO\r
TcpGetMaxSndNxt (\r
  IN TCP_CB *Tcb\r
  )\r
{\r
  LIST_ENTRY      *Entry;\r
  NET_BUF         *Nbuf;\r
\r
  if (IsListEmpty (&Tcb->SndQue)) {\r
    return Tcb->SndNxt;\r
  }\r
\r
  Entry = Tcb->SndQue.BackLink;\r
  Nbuf  = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
\r
  ASSERT (TCP_SEQ_GEQ (TCPSEG_NETBUF (Nbuf)->End, Tcb->SndNxt));\r
  return TCPSEG_NETBUF (Nbuf)->End;\r
}\r
\r
/**\r
  Compute how much data to send.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Force   If TRUE, to ignore the sender's SWS avoidance algorithm and send\r
                      out data by force.\r
\r
  @return The length of the data can be sent. If 0, no data can be sent.\r
\r
**/\r
UINT32\r
TcpDataToSend (\r
  IN TCP_CB *Tcb,\r
  IN INTN   Force\r
  )\r
{\r
  SOCKET  *Sk;\r
  UINT32  Win;\r
  UINT32  Len;\r
  UINT32  Left;\r
  UINT32  Limit;\r
\r
  Sk = Tcb->Sk;\r
  ASSERT (Sk != NULL);\r
\r
  //\r
  // TCP should NOT send data beyond the send window\r
  // and congestion window. The right edge of send\r
  // window is defined as SND.WL2 + SND.WND. The right\r
  // edge of congestion window is defined as SND.UNA +\r
  // CWND.\r
  //\r
  Win   = 0;\r
  Limit = Tcb->SndWl2 + Tcb->SndWnd;\r
\r
  if (TCP_SEQ_GT (Limit, Tcb->SndUna + Tcb->CWnd)) {\r
\r
    Limit = Tcb->SndUna + Tcb->CWnd;\r
  }\r
\r
  if (TCP_SEQ_GT (Limit, Tcb->SndNxt)) {\r
    Win = TCP_SUB_SEQ (Limit, Tcb->SndNxt);\r
  }\r
\r
  //\r
  // The data to send contains two parts: the data on the\r
  // socket send queue, and the data on the TCB's send\r
  // buffer. The later can be non-zero if the peer shrinks\r
  // its advertised window.\r
  //\r
  Left  = GET_SND_DATASIZE (Sk) + TCP_SUB_SEQ (TcpGetMaxSndNxt (Tcb), Tcb->SndNxt);\r
\r
  Len   = MIN (Win, Left);\r
\r
  if (Len > Tcb->SndMss) {\r
    Len = Tcb->SndMss;\r
  }\r
\r
  if ((Force != 0)|| (Len == 0 && Left == 0)) {\r
    return Len;\r
  }\r
\r
  if (Len == 0 && Left != 0) {\r
    goto SetPersistTimer;\r
  }\r
\r
  //\r
  // Sender's SWS avoidance: Don't send a small segment unless\r
  // a)A full-sized segment can be sent,\r
  // b)At least one-half of the maximum sized windows that\r
  // the other end has ever advertised.\r
  // c)It can send everything it has, and either it isn't\r
  // expecting an ACK, or the Nagle algorithm is disabled.\r
  //\r
  if ((Len == Tcb->SndMss) || (2 * Len >= Tcb->SndWndMax)) {\r
\r
    return Len;\r
  }\r
\r
  if ((Len == Left) &&\r
      ((Tcb->SndNxt == Tcb->SndUna) || TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE))\r
      ) {\r
\r
    return Len;\r
  }\r
\r
  //\r
  // RFC1122 suggests to set a timer when SWSA forbids TCP\r
  // sending more data, and combines it with a probe timer.\r
  //\r
SetPersistTimer:\r
  if (!TCP_TIMER_ON (Tcb->EnabledTimer, TCP_TIMER_REXMIT)) {\r
\r
    DEBUG (\r
      (EFI_D_WARN,\r
      "TcpDataToSend: enter persistent state for TCB %p\n",\r
      Tcb)\r
      );\r
\r
    if (!Tcb->ProbeTimerOn) {\r
      TcpSetProbeTimer (Tcb);\r
    }\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
  Build the TCP header of the TCP segment and transmit the segment by IP.\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 segment to be\r
                           sent out.\r
\r
  @retval 0       The segment was sent out successfully.\r
  @retval -1      An error condition occurred.\r
\r
**/\r
INTN\r
TcpTransmitSegment (\r
  IN OUT TCP_CB  *Tcb,\r
  IN     NET_BUF *Nbuf\r
  )\r
{\r
  UINT16    Len;\r
  TCP_HEAD  *Head;\r
  TCP_SEG   *Seg;\r
  BOOLEAN   Syn;\r
  UINT32    DataLen;\r
\r
  ASSERT ((Nbuf != NULL) && (Nbuf->Tcp == NULL));\r
\r
  if (TcpVerifySegment (Nbuf) == 0) {\r
    return -1;\r
  }\r
\r
  DataLen = Nbuf->TotalSize;\r
\r
  Seg     = TCPSEG_NETBUF (Nbuf);\r
  Syn     = TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN);\r
\r
  if (Syn) {\r
\r
    Len = TcpSynBuildOption (Tcb, Nbuf);\r
  } else {\r
\r
    Len = TcpBuildOption (Tcb, Nbuf);\r
  }\r
\r
  ASSERT ((Len % 4 == 0) && (Len <= 40));\r
\r
  Len += sizeof (TCP_HEAD);\r
\r
  Head = (TCP_HEAD *) NetbufAllocSpace (\r
                        Nbuf,\r
                        sizeof (TCP_HEAD),\r
                        NET_BUF_HEAD\r
                        );\r
\r
  ASSERT (Head != NULL);\r
\r
  Nbuf->Tcp       = Head;\r
\r
  Head->SrcPort   = Tcb->LocalEnd.Port;\r
  Head->DstPort   = Tcb->RemoteEnd.Port;\r
  Head->Seq       = NTOHL (Seg->Seq);\r
  Head->Ack       = NTOHL (Tcb->RcvNxt);\r
  Head->HeadLen   = (UINT8) (Len >> 2);\r
  Head->Res       = 0;\r
  Head->Wnd       = TcpComputeWnd (Tcb, Syn);\r
  Head->Checksum  = 0;\r
\r
  //\r
  // Check whether to set the PSH flag.\r
  //\r
  TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_PSH);\r
\r
  if (DataLen != 0) {\r
    if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_SND_PSH) &&\r
        TCP_SEQ_BETWEEN (Seg->Seq, Tcb->SndPsh, Seg->End)\r
        ) {\r
\r
      TCP_SET_FLG (Seg->Flag, TCP_FLG_PSH);\r
      TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_PSH);\r
\r
    } else if ((Seg->End == Tcb->SndNxt) && (GET_SND_DATASIZE (Tcb->Sk) == 0)) {\r
\r
      TCP_SET_FLG (Seg->Flag, TCP_FLG_PSH);\r
    }\r
  }\r
\r
  //\r
  // Check whether to set the URG flag and the urgent pointer.\r
  //\r
  TCP_CLEAR_FLG (Seg->Flag, TCP_FLG_URG);\r
\r
  if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_SND_URG) && TCP_SEQ_LEQ (Seg->Seq, Tcb->SndUp)) {\r
\r
    TCP_SET_FLG (Seg->Flag, TCP_FLG_URG);\r
\r
    if (TCP_SEQ_LT (Tcb->SndUp, Seg->End)) {\r
\r
      Seg->Urg = (UINT16) TCP_SUB_SEQ (Tcb->SndUp, Seg->Seq);\r
    } else {\r
\r
      Seg->Urg = (UINT16) MIN (\r
                            TCP_SUB_SEQ (Tcb->SndUp,\r
                            Seg->Seq),\r
                            0xffff\r
                            );\r
    }\r
  }\r
\r
  Head->Flag      = Seg->Flag;\r
  Head->Urg       = NTOHS (Seg->Urg);\r
  Head->Checksum  = TcpChecksum (Nbuf, Tcb->HeadSum);\r
\r
  //\r
  // Update the TCP session's control information.\r
  //\r
  Tcb->RcvWl2 = Tcb->RcvNxt;\r
  if (Syn) {\r
    Tcb->RcvWnd = NTOHS (Head->Wnd);\r
  }\r
\r
  //\r
  // Clear the delayedack flag.\r
  //\r
  Tcb->DelayedAck = 0;\r
\r
  return TcpSendIpPacket (Tcb, Nbuf, &Tcb->LocalEnd.Ip, &Tcb->RemoteEnd.Ip, Tcb->Sk->IpVersion);\r
}\r
\r
/**\r
  Get a segment from the Tcb's SndQue.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Seq     The sequence number of the segment.\r
  @param[in]  Len     The maximum length of the segment.\r
\r
  @return Pointer to the segment. If NULL, some error occurred.\r
\r
**/\r
NET_BUF *\r
TcpGetSegmentSndQue (\r
  IN TCP_CB    *Tcb,\r
  IN TCP_SEQNO Seq,\r
  IN UINT32    Len\r
  )\r
{\r
  LIST_ENTRY      *Head;\r
  LIST_ENTRY      *Cur;\r
  NET_BUF         *Node;\r
  TCP_SEG         *Seg;\r
  NET_BUF         *Nbuf;\r
  TCP_SEQNO       End;\r
  UINT8           *Data;\r
  UINT8           Flag;\r
  INT32           Offset;\r
  INT32           CopyLen;\r
\r
  ASSERT ((Tcb != NULL) && TCP_SEQ_LEQ (Seq, Tcb->SndNxt) && (Len > 0));\r
\r
  //\r
  // Find the segment that contains the Seq.\r
  //\r
  Head  = &Tcb->SndQue;\r
\r
  Node  = NULL;\r
  Seg   = NULL;\r
\r
  NET_LIST_FOR_EACH (Cur, Head) {\r
    Node  = NET_LIST_USER_STRUCT (Cur, NET_BUF, List);\r
    Seg   = TCPSEG_NETBUF (Node);\r
\r
    if (TCP_SEQ_LT (Seq, Seg->End) && TCP_SEQ_LEQ (Seg->Seq, Seq)) {\r
\r
      break;\r
    }\r
  }\r
\r
  if ((Cur == Head) || (Seg == NULL) || (Node == NULL)) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Return the buffer if it can be returned without\r
  // adjustment:\r
  //\r
  if ((Seg->Seq == Seq) &&\r
      TCP_SEQ_LEQ (Seg->End, Seg->Seq + Len) &&\r
      !NET_BUF_SHARED (Node)\r
      ) {\r
\r
    NET_GET_REF (Node);\r
    return Node;\r
  }\r
\r
  //\r
  // Create a new buffer and copy data there.\r
  //\r
  Nbuf = NetbufAlloc (Len + TCP_MAX_HEAD);\r
\r
  if (Nbuf == NULL) {\r
    return NULL;\r
  }\r
\r
  NetbufReserve (Nbuf, TCP_MAX_HEAD);\r
\r
  Flag  = Seg->Flag;\r
  End   = Seg->End;\r
\r
  if (TCP_SEQ_LT (Seq + Len, Seg->End)) {\r
    End = Seq + Len;\r
  }\r
\r
  CopyLen = TCP_SUB_SEQ (End, Seq);\r
  Offset  = TCP_SUB_SEQ (Seq, Seg->Seq);\r
\r
  //\r
  // If SYN is set and out of the range, clear the flag.\r
  // Becuase the sequence of the first byte is SEG.SEQ+1,\r
  // adjust Offset by -1. If SYN is in the range, copy\r
  // one byte less.\r
  //\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {\r
\r
    if (TCP_SEQ_LT (Seg->Seq, Seq)) {\r
\r
      TCP_CLEAR_FLG (Flag, TCP_FLG_SYN);\r
      Offset--;\r
    } else {\r
\r
      CopyLen--;\r
    }\r
  }\r
\r
  //\r
  // If FIN is set and in the range, copy one byte less,\r
  // and if it is out of the range, clear the flag.\r
  //\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_FIN)) {\r
\r
    if (Seg->End == End) {\r
\r
      CopyLen--;\r
    } else {\r
\r
      TCP_CLEAR_FLG (Flag, TCP_FLG_FIN);\r
    }\r
  }\r
\r
  ASSERT (CopyLen >= 0);\r
\r
  //\r
  // Copy data to the segment\r
  //\r
  if (CopyLen != 0) {\r
    Data = NetbufAllocSpace (Nbuf, CopyLen, NET_BUF_TAIL);\r
    ASSERT (Data != NULL);\r
\r
    if ((INT32) NetbufCopy (Node, Offset, CopyLen, Data) != CopyLen) {\r
      goto OnError;\r
    }\r
  }\r
\r
  CopyMem (TCPSEG_NETBUF (Nbuf), Seg, sizeof (TCP_SEG));\r
\r
  TCPSEG_NETBUF (Nbuf)->Seq   = Seq;\r
  TCPSEG_NETBUF (Nbuf)->End   = End;\r
  TCPSEG_NETBUF (Nbuf)->Flag  = Flag;\r
\r
  return Nbuf;\r
\r
OnError:\r
  NetbufFree (Nbuf);\r
  return NULL;\r
}\r
\r
/**\r
  Get a segment from the Tcb's socket buffer.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Seq     The sequence number of the segment.\r
  @param[in]  Len     The maximum length of the segment.\r
\r
  @return Pointer to the segment. If NULL, some error occurred.\r
\r
**/\r
NET_BUF *\r
TcpGetSegmentSock (\r
  IN TCP_CB    *Tcb,\r
  IN TCP_SEQNO Seq,\r
  IN UINT32    Len\r
  )\r
{\r
  NET_BUF *Nbuf;\r
  UINT8   *Data;\r
  UINT32  DataGet;\r
\r
  ASSERT ((Tcb != NULL) && (Tcb->Sk != NULL));\r
\r
  Nbuf = NetbufAlloc (Len + TCP_MAX_HEAD);\r
\r
  if (Nbuf == NULL) {\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "TcpGetSegmentSock: failed to allocate a netbuf for TCB %p\n",\r
      Tcb)\r
      );\r
\r
    return NULL;\r
  }\r
\r
  NetbufReserve (Nbuf, TCP_MAX_HEAD);\r
\r
  DataGet = 0;\r
\r
  if (Len != 0) {\r
    //\r
    // copy data to the segment.\r
    //\r
    Data = NetbufAllocSpace (Nbuf, Len, NET_BUF_TAIL);\r
    ASSERT (Data != NULL);\r
\r
    DataGet = SockGetDataToSend (Tcb->Sk, 0, Len, Data);\r
  }\r
\r
  NET_GET_REF (Nbuf);\r
\r
  TCPSEG_NETBUF (Nbuf)->Seq = Seq;\r
  TCPSEG_NETBUF (Nbuf)->End = Seq + Len;\r
\r
  InsertTailList (&(Tcb->SndQue), &(Nbuf->List));\r
\r
  if (DataGet != 0) {\r
\r
    SockDataSent (Tcb->Sk, DataGet);\r
  }\r
\r
  return Nbuf;\r
}\r
\r
/**\r
  Get a segment starting from sequence Seq of a maximum\r
  length of Len.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Seq     The sequence number of the segment.\r
  @param[in]  Len     The maximum length of the segment.\r
\r
  @return Pointer to the segment. If NULL, some error occurred.\r
\r
**/\r
NET_BUF *\r
TcpGetSegment (\r
  IN TCP_CB    *Tcb,\r
  IN TCP_SEQNO Seq,\r
  IN UINT32    Len\r
  )\r
{\r
  NET_BUF *Nbuf;\r
\r
  ASSERT (Tcb != NULL);\r
\r
  //\r
  // Compare the SndNxt with the max sequence number sent.\r
  //\r
  if ((Len != 0) && TCP_SEQ_LT (Seq, TcpGetMaxSndNxt (Tcb))) {\r
\r
    Nbuf = TcpGetSegmentSndQue (Tcb, Seq, Len);\r
  } else {\r
\r
    Nbuf = TcpGetSegmentSock (Tcb, Seq, Len);\r
  }\r
\r
  if (TcpVerifySegment (Nbuf) == 0) {\r
    NetbufFree (Nbuf);\r
    return NULL;\r
  }\r
\r
  return Nbuf;\r
}\r
\r
/**\r
  Retransmit the segment from sequence Seq.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]  Seq     The sequence number of the segment to be retransmitted.\r
\r
  @retval 0       Retransmission succeeded.\r
  @retval -1      Error condition occurred.\r
\r
**/\r
INTN\r
TcpRetransmit (\r
  IN TCP_CB    *Tcb,\r
  IN TCP_SEQNO Seq\r
  )\r
{\r
  NET_BUF *Nbuf;\r
  UINT32  Len;\r
\r
  //\r
  // Compute the maxium length of retransmission. It is\r
  // limited by three factors:\r
  // 1. Less than SndMss\r
  // 2. Must in the current send window\r
  // 3. Will not change the boundaries of queued segments.\r
  //\r
\r
  //\r
  // Handle the Window Retraction if TCP window scale is enabled according to RFC7323:\r
  //   On first retransmission, or if the sequence number is out of\r
  //   window by less than 2^Rcv.Wind.Shift, then do normal\r
  //   retransmission(s) without regard to the receiver window as long\r
  //   as the original segment was in window when it was sent.\r
  //\r
  if ((Tcb->SndWndScale != 0) &&\r
      (TCP_SEQ_GT (Seq, Tcb->RetxmitSeqMax) || TCP_SEQ_BETWEEN (Tcb->SndWl2 + Tcb->SndWnd, Seq, Tcb->SndWl2 + Tcb->SndWnd + (1 << Tcb->SndWndScale)))) {\r
    Len = TCP_SUB_SEQ (Tcb->SndNxt, Seq);\r
    DEBUG (\r
      (EFI_D_WARN,\r
      "TcpRetransmit: retransmission without regard to the receiver window for TCB %p\n",\r
      Tcb)\r
      );\r
\r
  } else if (TCP_SEQ_GEQ (Tcb->SndWl2 + Tcb->SndWnd, Seq)) {\r
    Len = TCP_SUB_SEQ (Tcb->SndWl2 + Tcb->SndWnd, Seq);\r
\r
  } else {\r
    DEBUG (\r
      (EFI_D_WARN,\r
      "TcpRetransmit: retransmission cancelled because send window too small for TCB %p\n",\r
      Tcb)\r
      );\r
\r
    return 0;\r
  }\r
\r
  Len = MIN (Len, Tcb->SndMss);\r
\r
  Nbuf = TcpGetSegmentSndQue (Tcb, Seq, Len);\r
  if (Nbuf == NULL) {\r
    return -1;\r
  }\r
\r
  if (TcpVerifySegment (Nbuf) == 0) {\r
    goto OnError;\r
  }\r
\r
  if (TcpTransmitSegment (Tcb, Nbuf) != 0) {\r
    goto OnError;\r
  }\r
\r
  if (TCP_SEQ_GT (Seq, Tcb->RetxmitSeqMax)) {\r
    Tcb->RetxmitSeqMax = Seq;\r
  }\r
\r
  //\r
  // The retransmitted buffer may be on the SndQue,\r
  // trim TCP head because all the buffers on SndQue\r
  // are headless.\r
  //\r
  ASSERT (Nbuf->Tcp != NULL);\r
  NetbufTrim (Nbuf, (Nbuf->Tcp->HeadLen << 2), NET_BUF_HEAD);\r
  Nbuf->Tcp = NULL;\r
\r
  NetbufFree (Nbuf);\r
  return 0;\r
\r
OnError:\r
  if (Nbuf != NULL) {\r
    NetbufFree (Nbuf);\r
  }\r
\r
  return -1;\r
}\r
\r
/**\r
  Verify that all the segments in SndQue are in good shape.\r
\r
  @param[in]  Head    Pointer to the head node of the SndQue.\r
\r
  @retval     0       At least one segment is broken.\r
  @retval     1       All segments in the specific queue are in good shape.\r
\r
**/\r
INTN\r
TcpCheckSndQue (\r
  IN LIST_ENTRY     *Head\r
  )\r
{\r
  LIST_ENTRY      *Entry;\r
  NET_BUF         *Nbuf;\r
  TCP_SEQNO       Seq;\r
\r
  if (IsListEmpty (Head)) {\r
    return 1;\r
  }\r
  //\r
  // Initialize the Seq.\r
  //\r
  Entry = Head->ForwardLink;\r
  Nbuf  = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
  Seq   = TCPSEG_NETBUF (Nbuf)->Seq;\r
\r
  NET_LIST_FOR_EACH (Entry, Head) {\r
    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
\r
    if (TcpVerifySegment (Nbuf) == 0) {\r
      return 0;\r
    }\r
\r
    //\r
    // All the node in the SndQue should has:\r
    // SEG.SEQ = LAST_SEG.END\r
    //\r
    if (Seq != TCPSEG_NETBUF (Nbuf)->Seq) {\r
      return 0;\r
    }\r
\r
    Seq = TCPSEG_NETBUF (Nbuf)->End;\r
  }\r
\r
  return 1;\r
}\r
\r
/**\r
  Check whether to send data/SYN/FIN and piggyback an ACK.\r
\r
  @param[in, out]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
  @param[in]       Force   If TRUE, ignore the sender's SWS avoidance algorithm\r
                           and send out data by force.\r
\r
  @return The number of bytes sent.\r
\r
**/\r
INTN\r
TcpToSendData (\r
  IN OUT TCP_CB *Tcb,\r
  IN     INTN   Force\r
  )\r
{\r
  UINT32    Len;\r
  INTN      Sent;\r
  UINT8     Flag;\r
  NET_BUF   *Nbuf;\r
  TCP_SEG   *Seg;\r
  TCP_SEQNO Seq;\r
  TCP_SEQNO End;\r
\r
  ASSERT ((Tcb != NULL) && (Tcb->Sk != NULL) && (Tcb->State != TCP_LISTEN));\r
\r
  Sent = 0;\r
\r
  if ((Tcb->State == TCP_CLOSED) || TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_FIN_SENT)) {\r
\r
    return 0;\r
  }\r
\r
  do {\r
    //\r
    // Compute how much data can be sent\r
    //\r
    Len   = TcpDataToSend (Tcb, Force);\r
    Seq   = Tcb->SndNxt;\r
\r
    ASSERT ((Tcb->State) < (ARRAY_SIZE (mTcpOutFlag)));\r
    Flag  = mTcpOutFlag[Tcb->State];\r
\r
    if ((Flag & TCP_FLG_SYN) != 0) {\r
\r
      Seq = Tcb->Iss;\r
      Len = 0;\r
    }\r
\r
    //\r
    // Only send a segment without data if SYN or\r
    // FIN is set.\r
    //\r
    if ((Len == 0) && ((Flag & (TCP_FLG_SYN | TCP_FLG_FIN)) == 0)) {\r
      return Sent;\r
    }\r
\r
    Nbuf = TcpGetSegment (Tcb, Seq, Len);\r
\r
    if (Nbuf == NULL) {\r
      DEBUG (\r
        (EFI_D_ERROR,\r
        "TcpToSendData: failed to get a segment for TCB %p\n",\r
        Tcb)\r
        );\r
\r
      goto OnError;\r
    }\r
\r
    Seg = TCPSEG_NETBUF (Nbuf);\r
\r
    //\r
    // Set the TcpSeg in Nbuf.\r
    //\r
    Len = Nbuf->TotalSize;\r
    End = Seq + Len;\r
    if (TCP_FLG_ON (Flag, TCP_FLG_SYN)) {\r
      End++;\r
    }\r
\r
    if ((Flag & TCP_FLG_FIN) != 0) {\r
      //\r
      // Send FIN if all data is sent, and FIN is\r
      // in the window\r
      //\r
      if ((TcpGetMaxSndNxt (Tcb) == Tcb->SndNxt) &&\r
          (GET_SND_DATASIZE (Tcb->Sk) == 0) &&\r
          TCP_SEQ_LT (End + 1, Tcb->SndWnd + Tcb->SndWl2)\r
            ) {\r
        DEBUG (\r
          (EFI_D_NET,\r
          "TcpToSendData: send FIN to peer for TCB %p in state %s\n",\r
          Tcb,\r
          mTcpStateName[Tcb->State])\r
          );\r
\r
        End++;\r
      } else {\r
        TCP_CLEAR_FLG (Flag, TCP_FLG_FIN);\r
      }\r
    }\r
\r
    Seg->Seq  = Seq;\r
    Seg->End  = End;\r
    Seg->Flag = Flag;\r
\r
    if (TcpVerifySegment (Nbuf) == 0 || TcpCheckSndQue (&Tcb->SndQue) == 0) {\r
      DEBUG (\r
        (EFI_D_ERROR,\r
        "TcpToSendData: discard a broken segment for TCB %p\n",\r
        Tcb)\r
        );\r
      goto OnError;\r
    }\r
\r
    //\r
    // Don't send an empty segment here.\r
    //\r
    if (Seg->End == Seg->Seq) {\r
      DEBUG (\r
        (EFI_D_WARN,\r
        "TcpToSendData: created a empty segment for TCB %p, free it now\n",\r
        Tcb)\r
        );\r
\r
      goto OnError;\r
    }\r
\r
    if (TcpTransmitSegment (Tcb, Nbuf) != 0) {\r
      NetbufTrim (Nbuf, (Nbuf->Tcp->HeadLen << 2), NET_BUF_HEAD);\r
      Nbuf->Tcp = NULL;\r
\r
      if ((Flag & TCP_FLG_FIN) != 0)  {\r
        TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_FIN_SENT);\r
      }\r
\r
      goto OnError;\r
    }\r
\r
    Sent += TCP_SUB_SEQ (End, Seq);\r
\r
    //\r
    // All the buffers in the SndQue are headless.\r
    //\r
    ASSERT (Nbuf->Tcp != NULL);\r
\r
    NetbufTrim (Nbuf, (Nbuf->Tcp->HeadLen << 2), NET_BUF_HEAD);\r
    Nbuf->Tcp = NULL;\r
\r
    NetbufFree (Nbuf);\r
\r
    //\r
    // Update the status in TCB.\r
    //\r
    Tcb->DelayedAck = 0;\r
\r
    if ((Flag & TCP_FLG_FIN) != 0) {\r
      TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_FIN_SENT);\r
    }\r
\r
    if (TCP_SEQ_GT (End, Tcb->SndNxt)) {\r
      Tcb->SndNxt = End;\r
    }\r
\r
    if (!TCP_TIMER_ON (Tcb->EnabledTimer, TCP_TIMER_REXMIT)) {\r
      TcpSetTimer (Tcb, TCP_TIMER_REXMIT, Tcb->Rto);\r
    }\r
\r
    //\r
    // Enable RTT measurement only if not in retransmit.\r
    // Karn's algorithm requires not to update RTT when in loss.\r
    //\r
    if ((Tcb->CongestState == TCP_CONGEST_OPEN) && !TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RTT_ON)) {\r
\r
      DEBUG (\r
        (EFI_D_NET,\r
        "TcpToSendData: set RTT measure sequence %d for TCB %p\n",\r
        Seq,\r
        Tcb)\r
        );\r
\r
      TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_RTT_ON);\r
      Tcb->RttSeq     = Seq;\r
      Tcb->RttMeasure = 0;\r
    }\r
\r
  } while (Len == Tcb->SndMss);\r
\r
  return Sent;\r
\r
OnError:\r
  if (Nbuf != NULL) {\r
    NetbufFree (Nbuf);\r
  }\r
\r
  return Sent;\r
}\r
\r
/**\r
  Send an ACK immediately.\r
\r
  @param[in, out]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
\r
**/\r
VOID\r
TcpSendAck (\r
  IN OUT TCP_CB *Tcb\r
  )\r
{\r
  NET_BUF *Nbuf;\r
  TCP_SEG *Seg;\r
\r
  Nbuf = NetbufAlloc (TCP_MAX_HEAD);\r
\r
  if (Nbuf == NULL) {\r
    return;\r
  }\r
\r
  NetbufReserve (Nbuf, TCP_MAX_HEAD);\r
\r
  Seg       = TCPSEG_NETBUF (Nbuf);\r
  Seg->Seq  = Tcb->SndNxt;\r
  Seg->End  = Tcb->SndNxt;\r
  Seg->Flag = TCP_FLG_ACK;\r
\r
  if (TcpTransmitSegment (Tcb, Nbuf) == 0) {\r
    TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW);\r
    Tcb->DelayedAck = 0;\r
  }\r
\r
  NetbufFree (Nbuf);\r
}\r
\r
/**\r
  Send a zero probe segment. It can be used by keepalive and zero window probe.\r
\r
  @param[in, out]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
\r
  @retval 0       The zero probe segment was sent out successfully.\r
  @retval other   An error condition occurred.\r
\r
**/\r
INTN\r
TcpSendZeroProbe (\r
  IN OUT TCP_CB *Tcb\r
  )\r
{\r
  NET_BUF *Nbuf;\r
  TCP_SEG *Seg;\r
  INTN     Result;\r
\r
  Nbuf = NetbufAlloc (TCP_MAX_HEAD);\r
\r
  if (Nbuf == NULL) {\r
    return -1;\r
  }\r
\r
  NetbufReserve (Nbuf, TCP_MAX_HEAD);\r
\r
  //\r
  // SndNxt-1 is out of window. The peer should respond\r
  // with an ACK.\r
  //\r
  Seg       = TCPSEG_NETBUF (Nbuf);\r
  Seg->Seq  = Tcb->SndNxt - 1;\r
  Seg->End  = Tcb->SndNxt - 1;\r
  Seg->Flag = TCP_FLG_ACK;\r
\r
  Result    = TcpTransmitSegment (Tcb, Nbuf);\r
  NetbufFree (Nbuf);\r
\r
  return Result;\r
}\r
\r
/**\r
  Check whether to send an ACK or delayed ACK.\r
\r
  @param[in, out]  Tcb     Pointer to the TCP_CB of this TCP instance.\r
\r
**/\r
VOID\r
TcpToSendAck (\r
  IN OUT TCP_CB *Tcb\r
  )\r
{\r
  UINT32 TcpNow;\r
\r
  //\r
  // Generally, TCP should send a delayed ACK unless:\r
  //   1. ACK at least every other FULL sized segment received.\r
  //   2. Packets received out of order.\r
  //   3. Receiving window is open.\r
  //\r
  if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_ACK_NOW) || (Tcb->DelayedAck >= 1)) {\r
    TcpSendAck (Tcb);\r
    return;\r
  }\r
\r
  TcpNow = TcpRcvWinNow (Tcb);\r
\r
  if (TcpNow > TcpRcvWinOld (Tcb)) {\r
    TcpSendAck (Tcb);\r
    return;\r
  }\r
\r
  DEBUG (\r
    (EFI_D_NET,\r
    "TcpToSendAck: scheduled a delayed ACK for TCB %p\n",\r
    Tcb)\r
    );\r
\r
  //\r
  // Schedule a delayed ACK.\r
  //\r
  Tcb->DelayedAck++;\r
}\r
\r
/**\r
  Send a RESET segment in response to the segment received.\r
\r
  @param[in]  Tcb     Pointer to the TCP_CB of this TCP instance. May be NULL.\r
  @param[in]  Head    TCP header of the segment that triggers the reset.\r
  @param[in]  Len     Length of the segment that triggers the reset.\r
  @param[in]  Local   Local IP address.\r
  @param[in]  Remote  Remote peer's IP address.\r
  @param[in]  Version IP_VERSION_4 indicates TCP is running on IP4 stack,\r
                      IP_VERSION_6 indicates TCP is running on IP6 stack.\r
\r
  @retval     0       A reset was sent or there is no need to send it.\r
  @retval     -1      No reset is sent.\r
\r
**/\r
INTN\r
TcpSendReset (\r
  IN TCP_CB          *Tcb,\r
  IN TCP_HEAD        *Head,\r
  IN INT32           Len,\r
  IN EFI_IP_ADDRESS  *Local,\r
  IN EFI_IP_ADDRESS  *Remote,\r
  IN UINT8           Version\r
  )\r
{\r
  NET_BUF   *Nbuf;\r
  TCP_HEAD  *Nhead;\r
  UINT16    HeadSum;\r
\r
  //\r
  // Don't respond to a Reset with reset.\r
  //\r
  if ((Head->Flag & TCP_FLG_RST) != 0) {\r
    return 0;\r
  }\r
\r
  Nbuf = NetbufAlloc (TCP_MAX_HEAD);\r
\r
  if (Nbuf == NULL) {\r
    return -1;\r
  }\r
\r
  Nhead = (TCP_HEAD *) NetbufAllocSpace (\r
                        Nbuf,\r
                        sizeof (TCP_HEAD),\r
                        NET_BUF_TAIL\r
                        );\r
\r
  ASSERT (Nhead != NULL);\r
\r
  Nbuf->Tcp   = Nhead;\r
  Nhead->Flag = TCP_FLG_RST;\r
\r
  //\r
  // Derive Seq/ACK from the segment if no TCB\r
  // is associated with it, otherwise derive from the Tcb.\r
  //\r
  if (Tcb == NULL) {\r
\r
    if (TCP_FLG_ON (Head->Flag, TCP_FLG_ACK)) {\r
      Nhead->Seq  = Head->Ack;\r
      Nhead->Ack  = 0;\r
    } else {\r
      Nhead->Seq = 0;\r
      TCP_SET_FLG (Nhead->Flag, TCP_FLG_ACK);\r
      Nhead->Ack = HTONL (NTOHL (Head->Seq) + Len);\r
    }\r
  } else {\r
\r
    Nhead->Seq  = HTONL (Tcb->SndNxt);\r
    Nhead->Ack  = HTONL (Tcb->RcvNxt);\r
    TCP_SET_FLG (Nhead->Flag, TCP_FLG_ACK);\r
  }\r
\r
  Nhead->SrcPort  = Head->DstPort;\r
  Nhead->DstPort  = Head->SrcPort;\r
  Nhead->HeadLen  = (UINT8) (sizeof (TCP_HEAD) >> 2);\r
  Nhead->Res      = 0;\r
  Nhead->Wnd      = HTONS (0xFFFF);\r
  Nhead->Checksum = 0;\r
  Nhead->Urg      = 0;\r
\r
  if (Version == IP_VERSION_4) {\r
    HeadSum = NetPseudoHeadChecksum (Local->Addr[0], Remote->Addr[0], 6, 0);\r
  } else {\r
    HeadSum = NetIp6PseudoHeadChecksum (&Local->v6, &Remote->v6, 6, 0);\r
  }\r
\r
  Nhead->Checksum = TcpChecksum (Nbuf, HeadSum);\r
\r
  TcpSendIpPacket (Tcb, Nbuf, Local, Remote, Version);\r
\r
  NetbufFree (Nbuf);\r
\r
  return 0;\r
}\r
\r
/**\r
  Verify that the segment is in good shape.\r
\r
  @param[in]  Nbuf    The buffer that contains the segment to be checked.\r
\r
  @retval     0       The segment is broken.\r
  @retval     1       The segment is in good shape.\r
\r
**/\r
INTN\r
TcpVerifySegment (\r
  IN NET_BUF *Nbuf\r
  )\r
{\r
  TCP_HEAD  *Head;\r
  TCP_SEG   *Seg;\r
  UINT32    Len;\r
\r
  if (Nbuf == NULL) {\r
    return 1;\r
  }\r
\r
  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
  Seg   = TCPSEG_NETBUF (Nbuf);\r
  Len   = Nbuf->TotalSize;\r
  Head  = Nbuf->Tcp;\r
\r
  if (Head != NULL) {\r
    if (Head->Flag != Seg->Flag) {\r
      return 0;\r
    }\r
\r
    Len -= (Head->HeadLen << 2);\r
  }\r
\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_SYN)) {\r
    Len++;\r
  }\r
\r
  if (TCP_FLG_ON (Seg->Flag, TCP_FLG_FIN)) {\r
    Len++;\r
  }\r
\r
  if (Seg->Seq + Len != Seg->End) {\r
    return 0;\r
  }\r
\r
  return 1;\r
}\r
\r