[mirror_edk2.git] / MdeModulePkg / Universal / Network / Tcp4Dxe / SockImpl.c

/** @file\r
\r
Copyright (c) 2005 - 2006, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module Name:\r
\r
  SockImpl.c\r
\r
Abstract:\r
\r
\r
**/\r
\r
#include "SockImpl.h"\r
\r
STATIC\r
UINT32\r
SockTcpDataToRcv (\r
  IN  SOCK_BUFFER   *SockBuffer,\r
  OUT BOOLEAN       *IsOOB,\r
  IN  UINT32        BufLen\r
  );\r
\r
STATIC\r
VOID\r
SockProcessSndToken (\r
  IN SOCKET *Sock\r
  );\r
\r
VOID\r
SockFreeFoo (\r
  IN EFI_EVENT Event\r
  )\r
{\r
  return ;\r
}\r
\r
\r
/**\r
  Get the length of the data that can be retrieved from the socket\r
  receive buffer.\r
\r
  @param  SockBuffer            Pointer to the socket receive buffer.\r
  @param  IsUrg                 Pointer to a BOOLEAN variable. If TRUE the data is\r
                                OOB.\r
  @param  BufLen                The maximum length of the data buffer to store the\r
                                received data in socket layer.\r
\r
  @return The length of the data can be retreived.\r
\r
**/\r
STATIC\r
UINT32\r
SockTcpDataToRcv (\r
  IN  SOCK_BUFFER    *SockBuffer,\r
  OUT BOOLEAN        *IsUrg,\r
  IN  UINT32         BufLen\r
  )\r
{\r
  NET_BUF       *RcvBufEntry;\r
  UINT32        DataLen;\r
  TCP_RSV_DATA  *TcpRsvData;\r
  BOOLEAN       Urg;\r
\r
  ASSERT (SockBuffer && IsUrg && (BufLen > 0));\r
\r
  RcvBufEntry = SockBufFirst (SockBuffer);\r
  ASSERT (RcvBufEntry);\r
\r
  TcpRsvData  = (TCP_RSV_DATA *) RcvBufEntry->ProtoData;\r
\r
  *IsUrg      = (BOOLEAN) ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);\r
\r
  if (*IsUrg && TcpRsvData->UrgLen < RcvBufEntry->TotalSize) {\r
\r
    DataLen = MIN (TcpRsvData->UrgLen, BufLen);\r
\r
    if (DataLen < TcpRsvData->UrgLen) {\r
      TcpRsvData->UrgLen = TcpRsvData->UrgLen - DataLen;\r
    } else {\r
      TcpRsvData->UrgLen = 0;\r
    }\r
\r
    return DataLen;\r
\r
  }\r
\r
  DataLen     = RcvBufEntry->TotalSize;\r
\r
  RcvBufEntry = SockBufNext (SockBuffer, RcvBufEntry);\r
\r
  while ((BufLen > DataLen) && (RcvBufEntry != NULL)) {\r
\r
    TcpRsvData  = (TCP_RSV_DATA *) RcvBufEntry->ProtoData;\r
\r
    Urg         = (BOOLEAN) ((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);\r
\r
    if (*IsUrg != Urg) {\r
      break;\r
    }\r
\r
    if (*IsUrg && TcpRsvData->UrgLen < RcvBufEntry->TotalSize) {\r
\r
      if (TcpRsvData->UrgLen + DataLen < BufLen) {\r
        TcpRsvData->UrgLen = 0;\r
      } else {\r
        TcpRsvData->UrgLen = TcpRsvData->UrgLen - (BufLen - DataLen);\r
      }\r
\r
      return MIN (TcpRsvData->UrgLen + DataLen, BufLen);\r
\r
    }\r
\r
    DataLen += RcvBufEntry->TotalSize;\r
\r
    RcvBufEntry = SockBufNext (SockBuffer, RcvBufEntry);\r
  }\r
\r
  DataLen = MIN (BufLen, DataLen);\r
  return DataLen;\r
}\r
\r
\r
/**\r
  Copy data from socket buffer to application provided receive buffer.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  TcpRxData             Pointer to the application provided receive buffer.\r
  @param  RcvdBytes             The maximum length of the data can be copied.\r
  @param  IsOOB                 If TURE the data is OOB, else the data is normal.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockSetTcpRxData (\r
  IN SOCKET     *Sock,\r
  IN VOID       *TcpRxData,\r
  IN UINT32     RcvdBytes,\r
  IN BOOLEAN    IsOOB\r
  )\r
{\r
  UINT32                  Index;\r
  UINT32                  CopyBytes;\r
  UINT32                  OffSet;\r
  EFI_TCP4_RECEIVE_DATA   *RxData;\r
  EFI_TCP4_FRAGMENT_DATA  *Fragment;\r
\r
  RxData  = (EFI_TCP4_RECEIVE_DATA *) TcpRxData;\r
\r
  OffSet  = 0;\r
\r
  ASSERT (RxData->DataLength >= RcvdBytes);\r
\r
  RxData->DataLength  = RcvdBytes;\r
  RxData->UrgentFlag  = IsOOB;\r
\r
  for (Index = 0; (Index < RxData->FragmentCount) && (RcvdBytes > 0); Index++) {\r
\r
    Fragment  = &RxData->FragmentTable[Index];\r
    CopyBytes = MIN ((UINT32) (Fragment->FragmentLength), RcvdBytes);\r
\r
    NetbufQueCopy (\r
      Sock->RcvBuffer.DataQueue,\r
      OffSet,\r
      CopyBytes,\r
      Fragment->FragmentBuffer\r
      );\r
\r
    Fragment->FragmentLength = CopyBytes;\r
    RcvdBytes -= CopyBytes;\r
    OffSet += CopyBytes;\r
  }\r
}\r
\r
\r
/**\r
  Get received data from the socket layer to the receive token.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  RcvToken              Pointer to the application provided receive token.\r
\r
  @return The length of data received in this token.\r
\r
**/\r
UINT32\r
SockProcessRcvToken (\r
  IN SOCKET        *Sock,\r
  IN SOCK_IO_TOKEN *RcvToken\r
  )\r
{\r
  UINT32                 TokenRcvdBytes;\r
  EFI_TCP4_RECEIVE_DATA  *RxData;\r
  BOOLEAN                IsUrg;\r
\r
  ASSERT (Sock);\r
\r
  ASSERT (SOCK_STREAM == Sock->Type);\r
\r
  RxData = RcvToken->Packet.RxData;\r
\r
  TokenRcvdBytes = SockTcpDataToRcv (\r
                      &Sock->RcvBuffer,\r
                      &IsUrg,\r
                      (UINT32) RxData->DataLength\r
                      );\r
\r
  //\r
  // Copy data from RcvBuffer of socket to user\r
  // provided RxData and set the fields in TCP RxData\r
  //\r
  SockSetTcpRxData (Sock, RxData, TokenRcvdBytes, IsUrg);\r
\r
  SOCK_TRIM_RCV_BUFF (Sock, TokenRcvdBytes);\r
  SIGNAL_TOKEN (&(RcvToken->Token), EFI_SUCCESS);\r
\r
  return TokenRcvdBytes;\r
}\r
\r
\r
/**\r
  Process the TCP send data, buffer the tcp txdata and append\r
  the buffer to socket send buffer,then try to send it.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  TcpTxData             Pointer to the tcp txdata.\r
\r
  @retval EFI_SUCCESS           The operation is completed successfully.\r
  @retval EFI_OUT_OF_RESOURCES  Failed due to resource limit.\r
\r
**/\r
EFI_STATUS\r
SockProcessTcpSndData (\r
  IN SOCKET   *Sock,\r
  IN VOID     *TcpTxData\r
  )\r
{\r
  NET_BUF                 *SndData;\r
  EFI_STATUS              Status;\r
  EFI_TCP4_TRANSMIT_DATA  *TxData;\r
\r
  TxData = (EFI_TCP4_TRANSMIT_DATA *) TcpTxData;\r
\r
  //\r
  // transform this TxData into a NET_BUFFER\r
  // and insert it into Sock->SndBuffer\r
  //\r
  SndData = NetbufFromExt (\r
              (NET_FRAGMENT *) TxData->FragmentTable,\r
              (UINT32) TxData->FragmentCount,\r
              0,\r
              0,\r
              SockFreeFoo,\r
              NULL\r
              );\r
\r
  if (NULL == SndData) {\r
    DEBUG ((EFI_D_ERROR, "SockKProcessSndData: Failed to"\r
      " call NetBufferFromExt\n"));\r
\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  NetbufQueAppend (Sock->SndBuffer.DataQueue, SndData);\r
\r
  //\r
  // notify the low layer protocol to handle this send token\r
  //\r
  if (TxData->Urgent) {\r
    Status = Sock->ProtoHandler (Sock, SOCK_SNDURG, NULL);\r
\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  if (TxData->Push) {\r
    Status = Sock->ProtoHandler (Sock, SOCK_SNDPUSH, NULL);\r
\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // low layer protocol should really handle the sending\r
  // process when catching SOCK_SND request\r
  //\r
  Status = Sock->ProtoHandler (Sock, SOCK_SND, NULL);\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Flush the tokens in the specific token list.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  PendingTokenList      Pointer to the token list to be flushed.\r
\r
  @return None.\r
\r
**/\r
STATIC\r
VOID\r
SockFlushPendingToken (\r
  IN SOCKET         *Sock,\r
  IN LIST_ENTRY     *PendingTokenList\r
  )\r
{\r
  SOCK_TOKEN            *SockToken;\r
  SOCK_COMPLETION_TOKEN *Token;\r
\r
  ASSERT (Sock && PendingTokenList);\r
\r
  while (!IsListEmpty (PendingTokenList)) {\r
    SockToken = NET_LIST_HEAD (\r
                  PendingTokenList,\r
                  SOCK_TOKEN,\r
                  TokenList\r
                  );\r
\r
    Token = SockToken->Token;\r
    SIGNAL_TOKEN (Token, Sock->SockError);\r
\r
    RemoveEntryList (&(SockToken->TokenList));\r
    gBS->FreePool (SockToken);\r
  }\r
}\r
\r
\r
/**\r
  Wake up the connection token while the connection is\r
  successfully established, then try to process any\r
  pending send token.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
STATIC\r
VOID\r
SockWakeConnToken (\r
  IN SOCKET *Sock\r
  )\r
{\r
  ASSERT (Sock->ConnectionToken != NULL);\r
\r
  SIGNAL_TOKEN (Sock->ConnectionToken, EFI_SUCCESS);\r
  Sock->ConnectionToken = NULL;\r
\r
  //\r
  // check to see if some pending send token existed?\r
  //\r
  SockProcessSndToken (Sock);\r
  return ;\r
}\r
\r
\r
/**\r
  Wake up the listen token while the connection is\r
  established successfully.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
STATIC\r
VOID\r
SockWakeListenToken (\r
  IN SOCKET *Sock\r
  )\r
{\r
  SOCKET                *Parent;\r
  SOCK_TOKEN            *SockToken;\r
  EFI_TCP4_LISTEN_TOKEN *ListenToken;\r
\r
  Parent = Sock->Parent;\r
\r
  ASSERT (Parent && SOCK_IS_LISTENING (Parent) && SOCK_IS_CONNECTED (Sock));\r
\r
  if (!IsListEmpty (&Parent->ListenTokenList)) {\r
    SockToken = NET_LIST_HEAD (\r
                  &Parent->ListenTokenList,\r
                  SOCK_TOKEN,\r
                  TokenList\r
                  );\r
\r
    ListenToken = (EFI_TCP4_LISTEN_TOKEN *) SockToken->Token;\r
    ListenToken->NewChildHandle = Sock->SockHandle;\r
\r
    SIGNAL_TOKEN (&(ListenToken->CompletionToken), EFI_SUCCESS);\r
\r
    RemoveEntryList (&SockToken->TokenList);\r
    gBS->FreePool (SockToken);\r
\r
    RemoveEntryList (&Sock->ConnectionList);\r
\r
    Parent->ConnCnt--;\r
    DEBUG ((EFI_D_WARN, "SockWakeListenToken: accept a socket, now conncnt is %d", Parent->ConnCnt));\r
\r
    Sock->Parent = NULL;\r
  }\r
}\r
\r
\r
/**\r
  Wake up the receive token while some data is received.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
STATIC\r
VOID\r
SockWakeRcvToken (\r
  IN SOCKET *Sock\r
  )\r
{\r
  UINT32        RcvdBytes;\r
  UINT32        TokenRcvdBytes;\r
  SOCK_TOKEN    *SockToken;\r
  SOCK_IO_TOKEN *RcvToken;\r
\r
  ASSERT (Sock->RcvBuffer.DataQueue);\r
\r
  RcvdBytes = (Sock->RcvBuffer.DataQueue)->BufSize;\r
\r
  ASSERT (RcvdBytes > 0);\r
\r
  while (RcvdBytes > 0 && !IsListEmpty (&Sock->RcvTokenList)) {\r
\r
    SockToken = NET_LIST_HEAD (\r
                  &Sock->RcvTokenList,\r
                  SOCK_TOKEN,\r
                  TokenList\r
                  );\r
\r
    RcvToken        = (SOCK_IO_TOKEN *) SockToken->Token;\r
    TokenRcvdBytes  = SockProcessRcvToken (Sock, RcvToken);\r
\r
    if (0 == TokenRcvdBytes) {\r
      return ;\r
    }\r
\r
    RemoveEntryList (&(SockToken->TokenList));\r
    gBS->FreePool (SockToken);\r
    RcvdBytes -= TokenRcvdBytes;\r
  }\r
}\r
\r
\r
/**\r
  Process the send token.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
STATIC\r
VOID\r
SockProcessSndToken (\r
  IN SOCKET *Sock\r
  )\r
{\r
  UINT32                  FreeSpace;\r
  SOCK_TOKEN              *SockToken;\r
  UINT32                  DataLen;\r
  SOCK_IO_TOKEN           *SndToken;\r
  EFI_TCP4_TRANSMIT_DATA  *TxData;\r
  EFI_STATUS              Status;\r
\r
  ASSERT (Sock && (SOCK_STREAM == Sock->Type));\r
\r
  FreeSpace = SockGetFreeSpace (Sock, SOCK_SND_BUF);\r
\r
  //\r
  // to determine if process a send token using\r
  // socket layer flow control policy\r
  //\r
  while ((FreeSpace >= Sock->SndBuffer.LowWater) &&\r
         !IsListEmpty (&Sock->SndTokenList)) {\r
\r
    SockToken = NET_LIST_HEAD (\r
                  &(Sock->SndTokenList),\r
                  SOCK_TOKEN,\r
                  TokenList\r
                  );\r
\r
    //\r
    // process this token\r
    //\r
    RemoveEntryList (&(SockToken->TokenList));\r
    InsertTailList (\r
      &(Sock->ProcessingSndTokenList),\r
      &(SockToken->TokenList)\r
      );\r
\r
    //\r
    // Proceess it in the light of  SockType\r
    //\r
    SndToken  = (SOCK_IO_TOKEN *) SockToken->Token;\r
    TxData    = SndToken->Packet.TxData;\r
\r
    DataLen = (UINT32) TxData->DataLength;\r
    Status  = SockProcessTcpSndData (Sock, TxData);\r
\r
    if (EFI_ERROR (Status)) {\r
      goto OnError;\r
    }\r
\r
    if (DataLen >= FreeSpace) {\r
      FreeSpace = 0;\r
\r
    } else {\r
      FreeSpace -= DataLen;\r
\r
    }\r
  }\r
\r
  return ;\r
\r
OnError:\r
\r
  RemoveEntryList (&SockToken->TokenList);\r
  SIGNAL_TOKEN (SockToken->Token, Status);\r
  gBS->FreePool (SockToken);\r
}\r
\r
\r
/**\r
  Create a socket with initial data SockInitData.\r
\r
  @param  SockInitData          Pointer to the initial data of the socket.\r
\r
  @return Pointer to the newly created socket.\r
\r
**/\r
SOCKET *\r
SockCreate (\r
  IN SOCK_INIT_DATA *SockInitData\r
  )\r
{\r
  SOCKET      *Sock;\r
  SOCKET      *Parent;\r
  EFI_STATUS  Status;\r
\r
  ASSERT (SockInitData && SockInitData->ProtoHandler);\r
  ASSERT (SockInitData->Type == SOCK_STREAM);\r
  ASSERT (SockInitData->ProtoData && (SockInitData->DataSize <= PROTO_RESERVED_LEN));\r
\r
  Parent = SockInitData->Parent;\r
\r
  if (Parent && (Parent->ConnCnt == Parent->BackLog)) {\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "SockCreate: Socket parent has "\r
      "reached its connection limit with %d ConnCnt and %d BackLog\n",\r
      Parent->ConnCnt,\r
      Parent->BackLog)\r
      );\r
\r
    return NULL;\r
  }\r
\r
  Sock = AllocateZeroPool (sizeof (SOCKET));\r
  if (NULL == Sock) {\r
\r
    DEBUG ((EFI_D_ERROR, "SockCreate: No resource to create a new socket\n"));\r
    return NULL;\r
  }\r
\r
  InitializeListHead (&Sock->Link);\r
  InitializeListHead (&Sock->ConnectionList);\r
  InitializeListHead (&Sock->ListenTokenList);\r
  InitializeListHead (&Sock->RcvTokenList);\r
  InitializeListHead (&Sock->SndTokenList);\r
  InitializeListHead (&Sock->ProcessingSndTokenList);\r
\r
  EfiInitializeLock (&(Sock->Lock), TPL_CALLBACK);\r
\r
  Sock->SndBuffer.DataQueue = NetbufQueAlloc ();\r
  if (NULL == Sock->SndBuffer.DataQueue) {\r
    DEBUG ((EFI_D_ERROR, "SockCreate: No resource to allocate"\r
      " SndBuffer for new socket\n"));\r
\r
    goto OnError;\r
  }\r
\r
  Sock->RcvBuffer.DataQueue = NetbufQueAlloc ();\r
  if (NULL == Sock->RcvBuffer.DataQueue) {\r
    DEBUG ((EFI_D_ERROR, "SockCreate: No resource to allocate "\r
      "RcvBuffer for new socket\n"));\r
\r
    goto OnError;\r
  }\r
\r
  Sock->Signature           = SOCK_SIGNATURE;\r
\r
  Sock->Parent              = Parent;\r
  Sock->BackLog             = SockInitData->BackLog;\r
  Sock->ProtoHandler        = SockInitData->ProtoHandler;\r
  Sock->SndBuffer.HighWater = SockInitData->SndBufferSize;\r
  Sock->RcvBuffer.HighWater = SockInitData->RcvBufferSize;\r
  Sock->Type                = SockInitData->Type;\r
  Sock->DriverBinding       = SockInitData->DriverBinding;\r
  Sock->State               = SockInitData->State;\r
  Sock->CreateCallback      = SockInitData->CreateCallback;\r
  Sock->DestroyCallback     = SockInitData->DestroyCallback;\r
  Sock->Context             = SockInitData->Context;\r
\r
  Sock->SockError           = EFI_ABORTED;\r
  Sock->SndBuffer.LowWater  = SOCK_BUFF_LOW_WATER;\r
  Sock->RcvBuffer.LowWater  = SOCK_BUFF_LOW_WATER;\r
\r
  //\r
  // Install protocol on Sock->SockHandle\r
  //\r
  CopyMem (\r
    &(Sock->NetProtocol.TcpProtocol),\r
    SockInitData->Protocol,\r
    sizeof (EFI_TCP4_PROTOCOL)\r
    );\r
\r
  //\r
  // copy the protodata into socket\r
  //\r
  CopyMem (Sock->ProtoReserved, SockInitData->ProtoData, SockInitData->DataSize);\r
\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &Sock->SockHandle,\r
                  &gEfiTcp4ProtocolGuid,\r
                  &(Sock->NetProtocol.TcpProtocol),\r
                  NULL\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "SockCreate: Install TCP protocol in "\r
      "socket failed with %r\n", Status));\r
\r
    goto OnError;\r
  }\r
\r
  if (Parent != NULL) {\r
    ASSERT (Parent->BackLog > 0);\r
    ASSERT (SOCK_IS_LISTENING (Parent));\r
\r
    //\r
    // need to add it into Parent->ConnectionList\r
    // if the Parent->ConnCnt < Parent->BackLog\r
    //\r
    Parent->ConnCnt++;\r
\r
    DEBUG (\r
      (EFI_D_WARN,\r
      "SockCreate: Create a new socket and add to parent, now conncnt is %d\n",\r
      Parent->ConnCnt)\r
      );\r
\r
    InsertTailList (&Parent->ConnectionList, &Sock->ConnectionList);\r
  }\r
\r
  if (Sock->CreateCallback != NULL) {\r
    Status = Sock->CreateCallback (Sock, Sock->Context);\r
    if (EFI_ERROR (Status)) {\r
      goto OnError;\r
    }\r
  }\r
\r
  return Sock;\r
\r
OnError:\r
\r
  if (Sock->SockHandle != NULL) {\r
    gBS->UninstallMultipleProtocolInterfaces (\r
           Sock->SockHandle,\r
           &gEfiTcp4ProtocolGuid,\r
           &(Sock->NetProtocol.TcpProtocol),\r
           NULL\r
           );\r
  }\r
\r
  if (NULL != Sock->SndBuffer.DataQueue) {\r
    NetbufQueFree (Sock->SndBuffer.DataQueue);\r
  }\r
\r
  if (NULL != Sock->RcvBuffer.DataQueue) {\r
    NetbufQueFree (Sock->RcvBuffer.DataQueue);\r
  }\r
\r
  gBS->FreePool (Sock);\r
\r
  return NULL;\r
}\r
\r
\r
/**\r
  Destroy a socket.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockDestroy (\r
  IN SOCKET *Sock\r
  )\r
{\r
  VOID        *SockProtocol;\r
  EFI_GUID    *ProtocolGuid;\r
  EFI_STATUS  Status;\r
\r
  ASSERT (SOCK_STREAM == Sock->Type);\r
\r
  if (Sock->DestroyCallback != NULL) {\r
    Sock->DestroyCallback (Sock, Sock->Context);\r
  }\r
\r
  //\r
  // Flush the completion token buffered\r
  // by sock and rcv, snd buffer\r
  //\r
  if (!SOCK_IS_UNCONFIGURED (Sock)) {\r
\r
    SockConnFlush (Sock);\r
    SockSetState (Sock, SO_CLOSED);\r
    Sock->ConfigureState = SO_UNCONFIGURED;\r
\r
  }\r
  //\r
  // Destory the RcvBuffer Queue and SendBuffer Queue\r
  //\r
  NetbufQueFree (Sock->RcvBuffer.DataQueue);\r
  NetbufQueFree (Sock->SndBuffer.DataQueue);\r
\r
  //\r
  // Remove it from parent connection list if needed\r
  //\r
  if (Sock->Parent) {\r
\r
    RemoveEntryList (&(Sock->ConnectionList));\r
    (Sock->Parent->ConnCnt)--;\r
\r
    DEBUG (\r
      (EFI_D_WARN,\r
      "SockDestory: Delete a unaccepted socket from parent"\r
      "now conncnt is %d\n",\r
      Sock->Parent->ConnCnt)\r
      );\r
\r
    Sock->Parent = NULL;\r
  }\r
\r
  //\r
  // Set the protocol guid and driver binding handle\r
  // in the light of Sock->SockType\r
  //\r
  ProtocolGuid = &gEfiTcp4ProtocolGuid;\r
\r
  //\r
  // Retrieve the protocol installed on this sock\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Sock->SockHandle,\r
                  ProtocolGuid,\r
                  &SockProtocol,\r
                  Sock->DriverBinding,\r
                  Sock->SockHandle,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
\r
    DEBUG ((EFI_D_ERROR, "SockDestroy: Open protocol installed "\r
      "on socket failed with %r\n", Status));\r
\r
    goto FreeSock;\r
  }\r
\r
  //\r
  // Uninstall the protocol installed on this sock\r
  // in the light of Sock->SockType\r
  //\r
  gBS->UninstallMultipleProtocolInterfaces (\r
        Sock->SockHandle,\r
        ProtocolGuid,\r
        SockProtocol,\r
        NULL\r
        );\r
\r
FreeSock:\r
  gBS->FreePool (Sock);\r
  return ;\r
}\r
\r
\r
/**\r
  Flush the socket.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockConnFlush (\r
  IN SOCKET *Sock\r
  )\r
{\r
  SOCKET  *Child;\r
\r
  ASSERT (Sock);\r
\r
  //\r
  // Clear the flag in this socket\r
  //\r
  Sock->Flag = 0;\r
\r
  //\r
  // Flush the SndBuffer and RcvBuffer of Sock\r
  //\r
  NetbufQueFlush (Sock->SndBuffer.DataQueue);\r
  NetbufQueFlush (Sock->RcvBuffer.DataQueue);\r
\r
  //\r
  // Signal the pending token\r
  //\r
  if (Sock->ConnectionToken != NULL) {\r
    SIGNAL_TOKEN (Sock->ConnectionToken, Sock->SockError);\r
    Sock->ConnectionToken = NULL;\r
  }\r
\r
  if (Sock->CloseToken != NULL) {\r
    SIGNAL_TOKEN (Sock->CloseToken, Sock->SockError);\r
    Sock->CloseToken = NULL;\r
  }\r
\r
  SockFlushPendingToken (Sock, &(Sock->ListenTokenList));\r
  SockFlushPendingToken (Sock, &(Sock->RcvTokenList));\r
  SockFlushPendingToken (Sock, &(Sock->SndTokenList));\r
  SockFlushPendingToken (Sock, &(Sock->ProcessingSndTokenList));\r
\r
  //\r
  // Destroy the pending connection, if it is a listening socket\r
  //\r
  if (SOCK_IS_LISTENING (Sock)) {\r
    while (!IsListEmpty (&Sock->ConnectionList)) {\r
      Child = NET_LIST_HEAD (\r
                &Sock->ConnectionList,\r
                SOCKET,\r
                ConnectionList\r
                );\r
\r
      SockDestroyChild (Child);\r
    }\r
\r
    Sock->ConnCnt = 0;\r
  }\r
\r
  return ;\r
}\r
\r
\r
/**\r
  Set the state of the socket.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  State                 The new state to be set.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockSetState (\r
  IN SOCKET     *Sock,\r
  IN SOCK_STATE State\r
  )\r
{\r
  Sock->State = State;\r
}\r
\r
\r
/**\r
  Clone a new socket including its associated protocol control block.\r
\r
  @param  Sock                  Pointer to the socket to be cloned.\r
\r
  @retval *                     Pointer to the newly cloned socket. If NULL, error\r
                                condition occurred.\r
\r
**/\r
SOCKET *\r
SockClone (\r
  IN SOCKET *Sock\r
  )\r
{\r
  SOCKET          *ClonedSock;\r
  SOCK_INIT_DATA  InitData;\r
\r
  InitData.BackLog        = Sock->BackLog;\r
  InitData.Parent         = Sock;\r
  InitData.State          = Sock->State;\r
  InitData.ProtoHandler   = Sock->ProtoHandler;\r
  InitData.Type           = Sock->Type;\r
  InitData.RcvBufferSize  = Sock->RcvBuffer.HighWater;\r
  InitData.SndBufferSize  = Sock->SndBuffer.HighWater;\r
  InitData.DriverBinding  = Sock->DriverBinding;\r
  InitData.Protocol       = &(Sock->NetProtocol);\r
  InitData.CreateCallback  = Sock->CreateCallback;\r
  InitData.DestroyCallback = Sock->DestroyCallback;\r
  InitData.Context         = Sock->Context;\r
  InitData.ProtoData       = Sock->ProtoReserved;\r
  InitData.DataSize        = sizeof (Sock->ProtoReserved);\r
\r
  ClonedSock              = SockCreate (&InitData);\r
\r
  if (NULL == ClonedSock) {\r
    DEBUG ((EFI_D_ERROR, "SockClone: no resource to create a cloned sock\n"));\r
    return NULL;\r
  }\r
\r
  SockSetState (ClonedSock, SO_CONNECTING);\r
  ClonedSock->ConfigureState = Sock->ConfigureState;\r
\r
  return ClonedSock;\r
}\r
\r
\r
/**\r
  Called by the low layer protocol to indicate the socket\r
  a connection is established. This function just changes\r
  the socket's state to SO_CONNECTED and signals the token\r
  used for connection establishment.\r
\r
  @param  Sock                  Pointer to the socket associated with the\r
                                established connection.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockConnEstablished (\r
  IN SOCKET *Sock\r
  )\r
{\r
\r
  ASSERT (SO_CONNECTING == Sock->State);\r
\r
  SockSetState (Sock, SO_CONNECTED);\r
\r
  if (NULL == Sock->Parent) {\r
    SockWakeConnToken (Sock);\r
  } else {\r
    SockWakeListenToken (Sock);\r
  }\r
\r
  return ;\r
}\r
\r
\r
/**\r
  Called by the low layer protocol to indicate the connection\r
  is closed. This function flushes the socket, sets the state\r
  to SO_CLOSED and signals the close token.\r
\r
  @param  Sock                  Pointer to the socket associated with the closed\r
                                connection.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockConnClosed (\r
  IN SOCKET *Sock\r
  )\r
{\r
  if (Sock->CloseToken) {\r
    SIGNAL_TOKEN (Sock->CloseToken, EFI_SUCCESS);\r
    Sock->CloseToken = NULL;\r
  }\r
\r
  SockConnFlush (Sock);\r
  SockSetState (Sock, SO_CLOSED);\r
\r
  if (Sock->Parent != NULL) {\r
    SockDestroyChild (Sock);\r
  }\r
\r
}\r
\r
\r
/**\r
  Called by low layer protocol to indicate that some\r
  data is sent or processed. This function trims the\r
  sent data in the socket send buffer, signals the\r
  data token if proper\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  Count                 The length of the data processed or sent, in bytes.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockDataSent (\r
  IN SOCKET     *Sock,\r
  IN UINT32     Count\r
  )\r
{\r
  SOCK_TOKEN            *SockToken;\r
  SOCK_COMPLETION_TOKEN *SndToken;\r
\r
  ASSERT (!IsListEmpty (&Sock->ProcessingSndTokenList));\r
  ASSERT (Count <= (Sock->SndBuffer.DataQueue)->BufSize);\r
\r
  NetbufQueTrim (Sock->SndBuffer.DataQueue, Count);\r
\r
  //\r
  // To check if we can signal some snd token in this socket\r
  //\r
  while (Count > 0) {\r
    SockToken = NET_LIST_HEAD (\r
                  &(Sock->ProcessingSndTokenList),\r
                  SOCK_TOKEN,\r
                  TokenList\r
                  );\r
\r
    SndToken = SockToken->Token;\r
\r
    if (SockToken->RemainDataLen <= Count) {\r
\r
      RemoveEntryList (&(SockToken->TokenList));\r
      SIGNAL_TOKEN (SndToken, EFI_SUCCESS);\r
      Count -= SockToken->RemainDataLen;\r
      gBS->FreePool (SockToken);\r
    } else {\r
\r
      SockToken->RemainDataLen -= Count;\r
      Count = 0;\r
    }\r
  }\r
\r
  //\r
  // to judge if we can process some send token in\r
  // Sock->SndTokenList, if so process those send token\r
  //\r
  SockProcessSndToken (Sock);\r
  return ;\r
}\r
\r
\r
/**\r
  Called by the low layer protocol to copy some data in socket send\r
  buffer starting from the specific offset to a buffer provided by\r
  the caller.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  Offset                The start point of the data to be copied.\r
  @param  Len                   The length of the data to be copied.\r
  @param  Dest                  Pointer to the destination to copy the data.\r
\r
  @return The data size copied.\r
\r
**/\r
UINT32\r
SockGetDataToSend (\r
  IN SOCKET      *Sock,\r
  IN UINT32      Offset,\r
  IN UINT32      Len,\r
  IN UINT8       *Dest\r
  )\r
{\r
  ASSERT (Sock && SOCK_STREAM == Sock->Type);\r
\r
  return NetbufQueCopy (\r
          Sock->SndBuffer.DataQueue,\r
          Offset,\r
          Len,\r
          Dest\r
          );\r
}\r
\r
\r
/**\r
  Called by the low layer protocol to deliver received data\r
  to socket layer. This function will append the data to the\r
  socket receive buffer, set ther urgent data length and then\r
  check if any receive token can be signaled.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  NetBuffer             Pointer to the buffer that contains the received\r
                                data.\r
  @param  UrgLen                The length of the urgent data in the received data.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockDataRcvd (\r
  IN SOCKET    *Sock,\r
  IN NET_BUF   *NetBuffer,\r
  IN UINT32    UrgLen\r
  )\r
{\r
  ASSERT (Sock && Sock->RcvBuffer.DataQueue &&\r
    UrgLen <= NetBuffer->TotalSize);\r
\r
  NET_GET_REF (NetBuffer);\r
\r
  ((TCP_RSV_DATA *) (NetBuffer->ProtoData))->UrgLen = UrgLen;\r
\r
  NetbufQueAppend (Sock->RcvBuffer.DataQueue, NetBuffer);\r
\r
  SockWakeRcvToken (Sock);\r
  return ;\r
}\r
\r
\r
/**\r
  Get the length of the free space of the specific socket buffer.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  Which                 Flag to indicate which socket buffer to check,\r
                                either send buffer or receive buffer.\r
\r
  @return The length of the free space, in bytes.\r
\r
**/\r
UINT32\r
SockGetFreeSpace (\r
  IN SOCKET  *Sock,\r
  IN UINT32  Which\r
  )\r
{\r
  UINT32      BufferCC;\r
  SOCK_BUFFER *SockBuffer;\r
\r
  ASSERT (Sock && ((SOCK_SND_BUF == Which) || (SOCK_RCV_BUF == Which)));\r
\r
  if (SOCK_SND_BUF == Which) {\r
    SockBuffer = &(Sock->SndBuffer);\r
  } else {\r
    SockBuffer = &(Sock->RcvBuffer);\r
  }\r
\r
  BufferCC = (SockBuffer->DataQueue)->BufSize;\r
\r
  if (BufferCC >= SockBuffer->HighWater) {\r
\r
    return 0;\r
  }\r
\r
  return SockBuffer->HighWater - BufferCC;\r
}\r
\r
\r
/**\r
  Signal the receive token with the specific error or\r
  set socket error code after error is received.\r
\r
  @param  Sock                  Pointer to the socket.\r
  @param  Error                 The error code received.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockRcvdErr (\r
  IN SOCKET       *Sock,\r
  IN EFI_STATUS   Error\r
  )\r
{\r
  SOCK_TOKEN  *SockToken;\r
\r
  if (!IsListEmpty (&Sock->RcvTokenList)) {\r
\r
    SockToken = NET_LIST_HEAD (\r
                  &Sock->RcvTokenList,\r
                  SOCK_TOKEN,\r
                  TokenList\r
                  );\r
\r
    RemoveEntryList (&SockToken->TokenList);\r
\r
    SIGNAL_TOKEN (SockToken->Token, Error);\r
\r
    gBS->FreePool (SockToken);\r
  } else {\r
\r
    SOCK_ERROR (Sock, Error);\r
  }\r
}\r
\r
\r
/**\r
  Called by the low layer protocol to indicate that there\r
  will be no more data from the communication peer. This\r
  function set the socket's state to SO_NO_MORE_DATA and\r
  signal all queued IO tokens with the error status\r
  EFI_CONNECTION_FIN.\r
\r
  @param  Sock                  Pointer to the socket.\r
\r
  @return None.\r
\r
**/\r
VOID\r
SockNoMoreData (\r
  IN SOCKET *Sock\r
  )\r
{\r
  EFI_STATUS  Err;\r
\r
  SOCK_NO_MORE_DATA (Sock);\r
\r
  if (!IsListEmpty (&Sock->RcvTokenList)) {\r
\r
    ASSERT (0 == GET_RCV_DATASIZE (Sock));\r
\r
    Err = Sock->SockError;\r
\r
    SOCK_ERROR (Sock, EFI_CONNECTION_FIN);\r
\r
    SockFlushPendingToken (Sock, &Sock->RcvTokenList);\r
\r
    SOCK_ERROR (Sock, Err);\r
\r
  }\r
\r
}\r
\r
\r
/**\r
  Get the first buffer block in the specific socket buffer.\r
\r
  @param  Sockbuf               Pointer to the socket buffer.\r
\r
  @return Pointer to the first buffer in the queue. NULL if the queue is empty.\r
\r
**/\r
NET_BUF *\r
SockBufFirst (\r
  IN SOCK_BUFFER *Sockbuf\r
  )\r
{\r
  LIST_ENTRY      *NetbufList;\r
\r
  NetbufList = &(Sockbuf->DataQueue->BufList);\r
\r
  if (IsListEmpty (NetbufList)) {\r
    return NULL;\r
  }\r
\r
  return NET_LIST_HEAD (NetbufList, NET_BUF, List);\r
}\r
\r
\r
/**\r
  Get the next buffer block in the specific socket buffer.\r
\r
  @param  Sockbuf               Pointer to the socket buffer.\r
  @param  SockEntry             Pointer to the buffer block prior to the required\r
                                one.\r
\r
  @return Pointer to the buffer block next to SockEntry. NULL if SockEntry is the tail or head entry.\r
\r
**/\r
NET_BUF *\r
SockBufNext (\r
  IN SOCK_BUFFER *Sockbuf,\r
  IN NET_BUF     *SockEntry\r
  )\r
{\r
  LIST_ENTRY      *NetbufList;\r
\r
  NetbufList = &(Sockbuf->DataQueue->BufList);\r
\r
  if ((SockEntry->List.ForwardLink == NetbufList) ||\r
      (SockEntry->List.BackLink == &SockEntry->List) ||\r
      (SockEntry->List.ForwardLink == &SockEntry->List)\r
      ) {\r
\r
    return NULL;\r
  }\r
\r
  return NET_LIST_USER_STRUCT (SockEntry->List.ForwardLink, NET_BUF, List);\r
}\r