SockImpl.c

Go to the documentation of this file.

 
#include "SockImpl.h"
 
NET_BUF *
SockBufFirst (
  IN SOCK_BUFFER  *Sockbuf
  )
{
  LIST_ENTRY  *NetbufList;
 
  NetbufList = &(Sockbuf->DataQueue->BufList);
 
  if (IsListEmpty (NetbufList)) {
    return NULL;
  }
 
  return NET_LIST_HEAD (NetbufList, NET_BUF, List);
}
 
NET_BUF *
SockBufNext (
  IN SOCK_BUFFER  *Sockbuf,
  IN NET_BUF      *SockEntry
  )
{
  LIST_ENTRY  *NetbufList;
 
  NetbufList = &(Sockbuf->DataQueue->BufList);
 
  if ((SockEntry->List.ForwardLink == NetbufList) ||
      (SockEntry->List.BackLink == &SockEntry->List) ||
      (SockEntry->List.ForwardLink == &SockEntry->List)
      )
  {
    return NULL;
  }
 
  return NET_LIST_USER_STRUCT (SockEntry->List.ForwardLink, NET_BUF, List);
}
 
VOID
EFIAPI
SockFreeFoo (
  IN VOID  *Arg
  )
{
  return;
}
 
UINT32
SockTcpDataToRcv (
  IN  SOCK_BUFFER  *SockBuffer,
  OUT BOOLEAN      *IsUrg,
  IN  UINT32       BufLen
  )
{
  NET_BUF       *RcvBufEntry;
  UINT32        DataLen;
  TCP_RSV_DATA  *TcpRsvData;
  BOOLEAN       Urg;
 
  ASSERT ((SockBuffer != NULL) && (IsUrg != NULL) && (BufLen > 0));
 
  //
  // Get the first socket receive buffer
  //
  RcvBufEntry = SockBufFirst (SockBuffer);
  ASSERT (RcvBufEntry != NULL);
 
  TcpRsvData = (TCP_RSV_DATA *)RcvBufEntry->ProtoData;
 
  //
  // Check whether the receive data is out of bound. If yes, calculate the maximum
  // allowed length of the urgent data and output it.
  //
  *IsUrg = (BOOLEAN)((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);
 
  if (*IsUrg && (TcpRsvData->UrgLen < RcvBufEntry->TotalSize)) {
    DataLen = MIN (TcpRsvData->UrgLen, BufLen);
 
    if (DataLen < TcpRsvData->UrgLen) {
      TcpRsvData->UrgLen = TcpRsvData->UrgLen - DataLen;
    } else {
      TcpRsvData->UrgLen = 0;
    }
 
    return DataLen;
  }
 
  //
  // Process the next socket receive buffer to get the maximum allowed length
  // of the received data.
  //
  DataLen = RcvBufEntry->TotalSize;
 
  RcvBufEntry = SockBufNext (SockBuffer, RcvBufEntry);
 
  while ((BufLen > DataLen) && (RcvBufEntry != NULL)) {
    TcpRsvData = (TCP_RSV_DATA *)RcvBufEntry->ProtoData;
 
    Urg = (BOOLEAN)((TcpRsvData->UrgLen > 0) ? TRUE : FALSE);
 
    if (*IsUrg != Urg) {
      break;
    }
 
    if (*IsUrg && (TcpRsvData->UrgLen < RcvBufEntry->TotalSize)) {
      if (TcpRsvData->UrgLen + DataLen < BufLen) {
        TcpRsvData->UrgLen = 0;
      } else {
        TcpRsvData->UrgLen = TcpRsvData->UrgLen - (BufLen - DataLen);
      }
 
      return MIN (TcpRsvData->UrgLen + DataLen, BufLen);
    }
 
    DataLen += RcvBufEntry->TotalSize;
 
    RcvBufEntry = SockBufNext (SockBuffer, RcvBufEntry);
  }
 
  DataLen = MIN (BufLen, DataLen);
  return DataLen;
}
 
VOID
SockSetTcpRxData (
  IN SOCKET   *Sock,
  IN VOID     *TcpRxData,
  IN UINT32   RcvdBytes,
  IN BOOLEAN  IsUrg
  )
{
  UINT32                  Index;
  UINT32                  CopyBytes;
  UINT32                  OffSet;
  EFI_TCP4_RECEIVE_DATA   *RxData;
  EFI_TCP4_FRAGMENT_DATA  *Fragment;
 
  RxData = (EFI_TCP4_RECEIVE_DATA *)TcpRxData;
 
  OffSet = 0;
 
  ASSERT (RxData->DataLength >= RcvdBytes);
 
  RxData->DataLength = RcvdBytes;
  RxData->UrgentFlag = IsUrg;
 
  //
  // Copy the CopyBytes data from socket receive buffer to RxData.
  //
  for (Index = 0; (Index < RxData->FragmentCount) && (RcvdBytes > 0); Index++) {
    Fragment  = &RxData->FragmentTable[Index];
    CopyBytes = MIN ((UINT32)(Fragment->FragmentLength), RcvdBytes);
 
    NetbufQueCopy (
      Sock->RcvBuffer.DataQueue,
      OffSet,
      CopyBytes,
      Fragment->FragmentBuffer
      );
 
    Fragment->FragmentLength = CopyBytes;
    RcvdBytes               -= CopyBytes;
    OffSet                  += CopyBytes;
  }
}
 
VOID
SockProcessSndToken (
  IN OUT SOCKET  *Sock
  )
{
  UINT32                  FreeSpace;
  SOCK_TOKEN              *SockToken;
  UINT32                  DataLen;
  SOCK_IO_TOKEN           *SndToken;
  EFI_TCP4_TRANSMIT_DATA  *TxData;
  EFI_STATUS              Status;
 
  ASSERT ((Sock != NULL) && (SockStream == Sock->Type));
 
  FreeSpace = SockGetFreeSpace (Sock, SOCK_SND_BUF);
 
  //
  // to determine if process a send token using
  // socket layer flow control policy
  //
  while ((FreeSpace >= Sock->SndBuffer.LowWater) && !IsListEmpty (&Sock->SndTokenList)) {
    SockToken = NET_LIST_HEAD (
                  &(Sock->SndTokenList),
                  SOCK_TOKEN,
                  TokenList
                  );
 
    //
    // process this token
    //
    RemoveEntryList (&(SockToken->TokenList));
    InsertTailList (
      &(Sock->ProcessingSndTokenList),
      &(SockToken->TokenList)
      );
 
    //
    // Process it in the light of SockType
    //
    SndToken = (SOCK_IO_TOKEN *)SockToken->Token;
    TxData   = SndToken->Packet.TxData;
 
    DataLen = TxData->DataLength;
    Status  = SockProcessTcpSndData (Sock, TxData);
 
    if (EFI_ERROR (Status)) {
      goto OnError;
    }
 
    if (DataLen >= FreeSpace) {
      FreeSpace = 0;
    } else {
      FreeSpace -= DataLen;
    }
  }
 
  return;
 
OnError:
 
  RemoveEntryList (&SockToken->TokenList);
  SIGNAL_TOKEN (SockToken->Token, Status);
  FreePool (SockToken);
}
 
UINT32
SockProcessRcvToken (
  IN OUT SOCKET         *Sock,
  IN OUT SOCK_IO_TOKEN  *RcvToken
  )
{
  UINT32                 TokenRcvdBytes;
  EFI_TCP4_RECEIVE_DATA  *RxData;
  BOOLEAN                IsUrg;
 
  ASSERT (Sock != NULL);
 
  ASSERT (SockStream == Sock->Type);
 
  RxData = RcvToken->Packet.RxData;
 
  TokenRcvdBytes = SockTcpDataToRcv (
                     &Sock->RcvBuffer,
                     &IsUrg,
                     RxData->DataLength
                     );
 
  //
  // Copy data from RcvBuffer of socket to user
  // provided RxData and set the fields in TCP RxData
  //
  SockSetTcpRxData (Sock, RxData, TokenRcvdBytes, IsUrg);
 
  NetbufQueTrim (Sock->RcvBuffer.DataQueue, TokenRcvdBytes);
  SIGNAL_TOKEN (&(RcvToken->Token), EFI_SUCCESS);
 
  return TokenRcvdBytes;
}
 
EFI_STATUS
SockProcessTcpSndData (
  IN SOCKET  *Sock,
  IN VOID    *TcpTxData
  )
{
  NET_BUF                 *SndData;
  EFI_STATUS              Status;
  EFI_TCP4_TRANSMIT_DATA  *TxData;
 
  TxData = (EFI_TCP4_TRANSMIT_DATA *)TcpTxData;
 
  //
  // transform this TxData into a NET_BUFFER
  // and insert it into Sock->SndBuffer
  //
  SndData = NetbufFromExt (
              (NET_FRAGMENT *)TxData->FragmentTable,
              TxData->FragmentCount,
              0,
              0,
              SockFreeFoo,
              NULL
              );
 
  if (NULL == SndData) {
    DEBUG (
      (DEBUG_ERROR,
       "SockKProcessSndData: Failed to call NetBufferFromExt\n")
      );
 
    return EFI_OUT_OF_RESOURCES;
  }
 
  NetbufQueAppend (Sock->SndBuffer.DataQueue, SndData);
 
  //
  // notify the low layer protocol to handle this send token
  //
  if (TxData->Urgent) {
    Status = Sock->ProtoHandler (Sock, SOCK_SNDURG, NULL);
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  if (TxData->Push) {
    Status = Sock->ProtoHandler (Sock, SOCK_SNDPUSH, NULL);
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // low layer protocol should really handle the sending
  // process when catching SOCK_SND request
  //
  Status = Sock->ProtoHandler (Sock, SOCK_SND, NULL);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
VOID
SockFlushPendingToken (
  IN     SOCKET      *Sock,
  IN OUT LIST_ENTRY  *PendingTokenList
  )
{
  SOCK_TOKEN             *SockToken;
  SOCK_COMPLETION_TOKEN  *Token;
 
  ASSERT ((Sock != NULL) && (PendingTokenList != NULL));
 
  while (!IsListEmpty (PendingTokenList)) {
    SockToken = NET_LIST_HEAD (
                  PendingTokenList,
                  SOCK_TOKEN,
                  TokenList
                  );
 
    Token = SockToken->Token;
    SIGNAL_TOKEN (Token, Sock->SockError);
 
    RemoveEntryList (&(SockToken->TokenList));
    FreePool (SockToken);
  }
}
 
VOID
SockWakeConnToken (
  IN OUT SOCKET  *Sock
  )
{
  ASSERT (Sock->ConnectionToken != NULL);
 
  SIGNAL_TOKEN (Sock->ConnectionToken, EFI_SUCCESS);
  Sock->ConnectionToken = NULL;
 
  //
  // check to see if some pending send token existed?
  //
  SockProcessSndToken (Sock);
}
 
VOID
SockWakeListenToken (
  IN OUT SOCKET  *Sock
  )
{
  SOCKET                 *Parent;
  SOCK_TOKEN             *SockToken;
  EFI_TCP4_LISTEN_TOKEN  *ListenToken;
 
  Parent = Sock->Parent;
 
  ASSERT ((Parent != NULL) && SOCK_IS_LISTENING (Parent) && SOCK_IS_CONNECTED (Sock));
 
  if (!IsListEmpty (&Parent->ListenTokenList)) {
    SockToken = NET_LIST_HEAD (
                  &Parent->ListenTokenList,
                  SOCK_TOKEN,
                  TokenList
                  );
 
    ListenToken                 = (EFI_TCP4_LISTEN_TOKEN *)SockToken->Token;
    ListenToken->NewChildHandle = Sock->SockHandle;
 
    SIGNAL_TOKEN (&(ListenToken->CompletionToken), EFI_SUCCESS);
 
    RemoveEntryList (&SockToken->TokenList);
    FreePool (SockToken);
 
    RemoveEntryList (&Sock->ConnectionList);
 
    Parent->ConnCnt--;
    DEBUG (
      (DEBUG_NET,
       "SockWakeListenToken: accept a socket, now conncnt is %d",
       Parent->ConnCnt)
      );
 
    Sock->Parent = NULL;
  }
}
 
VOID
SockWakeRcvToken (
  IN OUT SOCKET  *Sock
  )
{
  UINT32         RcvdBytes;
  UINT32         TokenRcvdBytes;
  SOCK_TOKEN     *SockToken;
  SOCK_IO_TOKEN  *RcvToken;
 
  ASSERT (Sock->RcvBuffer.DataQueue != NULL);
 
  RcvdBytes = (Sock->RcvBuffer.DataQueue)->BufSize;
 
  ASSERT (RcvdBytes > 0);
 
  while (RcvdBytes > 0 && !IsListEmpty (&Sock->RcvTokenList)) {
    SockToken = NET_LIST_HEAD (
                  &Sock->RcvTokenList,
                  SOCK_TOKEN,
                  TokenList
                  );
 
    RcvToken       = (SOCK_IO_TOKEN *)SockToken->Token;
    TokenRcvdBytes = SockProcessRcvToken (Sock, RcvToken);
 
    if (0 == TokenRcvdBytes) {
      return;
    }
 
    RemoveEntryList (&(SockToken->TokenList));
    FreePool (SockToken);
    RcvdBytes -= TokenRcvdBytes;
  }
}
 
EFI_STATUS
SockCancelToken (
  IN     SOCK_COMPLETION_TOKEN  *Token,
  IN OUT LIST_ENTRY             *SpecifiedTokenList
  )
{
  EFI_STATUS  Status;
  LIST_ENTRY  *Entry;
  SOCK_TOKEN  *SockToken;
 
  Status    = EFI_SUCCESS;
  Entry     = NULL;
  SockToken = NULL;
 
  if (IsListEmpty (SpecifiedTokenList) && (Token != NULL)) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Iterate through the SpecifiedTokenList.
  //
  Entry = SpecifiedTokenList->ForwardLink;
  while (Entry != SpecifiedTokenList) {
    SockToken = NET_LIST_USER_STRUCT (Entry, SOCK_TOKEN, TokenList);
 
    if (Token == NULL) {
      SIGNAL_TOKEN (SockToken->Token, EFI_ABORTED);
      RemoveEntryList (&SockToken->TokenList);
      FreePool (SockToken);
 
      Entry  = SpecifiedTokenList->ForwardLink;
      Status = EFI_SUCCESS;
    } else {
      if (Token == (VOID *)SockToken->Token) {
        SIGNAL_TOKEN (Token, EFI_ABORTED);
        RemoveEntryList (&(SockToken->TokenList));
        FreePool (SockToken);
 
        return EFI_SUCCESS;
      }
 
      Status = EFI_NOT_FOUND;
 
      Entry = Entry->ForwardLink;
    }
  }
 
  ASSERT (IsListEmpty (SpecifiedTokenList) || Token != NULL);
 
  return Status;
}
 
SOCKET *
SockCreate (
  IN SOCK_INIT_DATA  *SockInitData
  )
{
  SOCKET      *Sock;
  SOCKET      *Parent;
  EFI_STATUS  Status;
  EFI_GUID    *TcpProtocolGuid;
  UINTN       ProtocolLength;
 
  ASSERT ((SockInitData != NULL) && (SockInitData->ProtoHandler != NULL));
  ASSERT (SockInitData->Type == SockStream);
  ASSERT ((SockInitData->ProtoData != NULL) && (SockInitData->DataSize <= PROTO_RESERVED_LEN));
 
  if (SockInitData->IpVersion == IP_VERSION_4) {
    TcpProtocolGuid = &gEfiTcp4ProtocolGuid;
    ProtocolLength  = sizeof (EFI_TCP4_PROTOCOL);
  } else {
    TcpProtocolGuid = &gEfiTcp6ProtocolGuid;
    ProtocolLength  = sizeof (EFI_TCP6_PROTOCOL);
  }
 
  Parent = SockInitData->Parent;
 
  if ((Parent != NULL) && (Parent->ConnCnt == Parent->BackLog)) {
    DEBUG (
      (DEBUG_ERROR,
       "SockCreate: Socket parent has reached its connection limit with %d ConnCnt and %d BackLog\n",
       Parent->ConnCnt,
       Parent->BackLog)
      );
 
    return NULL;
  }
 
  Sock = AllocateZeroPool (sizeof (SOCKET));
  if (NULL == Sock) {
    DEBUG ((DEBUG_ERROR, "SockCreate: No resource to create a new socket\n"));
    return NULL;
  }
 
  InitializeListHead (&Sock->Link);
  InitializeListHead (&Sock->ConnectionList);
  InitializeListHead (&Sock->ListenTokenList);
  InitializeListHead (&Sock->RcvTokenList);
  InitializeListHead (&Sock->SndTokenList);
  InitializeListHead (&Sock->ProcessingSndTokenList);
 
  EfiInitializeLock (&(Sock->Lock), TPL_CALLBACK);
 
  Sock->SndBuffer.DataQueue = NetbufQueAlloc ();
  if (NULL == Sock->SndBuffer.DataQueue) {
    DEBUG (
      (DEBUG_ERROR,
       "SockCreate: No resource to allocate SndBuffer for new socket\n")
      );
 
    goto OnError;
  }
 
  Sock->RcvBuffer.DataQueue = NetbufQueAlloc ();
  if (NULL == Sock->RcvBuffer.DataQueue) {
    DEBUG (
      (DEBUG_ERROR,
       "SockCreate: No resource to allocate RcvBuffer for new socket\n")
      );
 
    goto OnError;
  }
 
  Sock->Signature = SOCK_SIGNATURE;
 
  Sock->Parent              = Parent;
  Sock->BackLog             = SockInitData->BackLog;
  Sock->ProtoHandler        = SockInitData->ProtoHandler;
  Sock->SndBuffer.HighWater = SockInitData->SndBufferSize;
  Sock->RcvBuffer.HighWater = SockInitData->RcvBufferSize;
  Sock->Type                = SockInitData->Type;
  Sock->DriverBinding       = SockInitData->DriverBinding;
  Sock->State               = SockInitData->State;
  Sock->CreateCallback      = SockInitData->CreateCallback;
  Sock->DestroyCallback     = SockInitData->DestroyCallback;
  Sock->Context             = SockInitData->Context;
 
  Sock->SockError          = EFI_ABORTED;
  Sock->SndBuffer.LowWater = SOCK_BUFF_LOW_WATER;
  Sock->RcvBuffer.LowWater = SOCK_BUFF_LOW_WATER;
 
  Sock->IpVersion = SockInitData->IpVersion;
 
  //
  // Install protocol on Sock->SockHandle
  //
  CopyMem (&Sock->NetProtocol, SockInitData->Protocol, ProtocolLength);
 
  //
  // copy the protodata into socket
  //
  CopyMem (Sock->ProtoReserved, SockInitData->ProtoData, SockInitData->DataSize);
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Sock->SockHandle,
                  TcpProtocolGuid,
                  &Sock->NetProtocol,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    DEBUG (
      (DEBUG_ERROR,
       "SockCreate: Install TCP protocol in socket failed with %r\n",
       Status)
      );
 
    goto OnError;
  }
 
  if (Parent != NULL) {
    ASSERT (Parent->BackLog > 0);
    ASSERT (SOCK_IS_LISTENING (Parent));
 
    //
    // need to add it into Parent->ConnectionList
    // if the Parent->ConnCnt < Parent->BackLog
    //
    Parent->ConnCnt++;
 
    DEBUG (
      (DEBUG_NET,
       "SockCreate: Create a new socket and add to parent, now conncnt is %d\n",
       Parent->ConnCnt)
      );
 
    InsertTailList (&Parent->ConnectionList, &Sock->ConnectionList);
  }
 
  if (Sock->CreateCallback != NULL) {
    Status = Sock->CreateCallback (Sock, Sock->Context);
    if (EFI_ERROR (Status)) {
      goto OnError;
    }
  }
 
  return Sock;
 
OnError:
 
  if (Sock->SockHandle != NULL) {
    gBS->UninstallMultipleProtocolInterfaces (
           Sock->SockHandle,
           TcpProtocolGuid,
           &Sock->NetProtocol,
           NULL
           );
  }
 
  if (NULL != Sock->SndBuffer.DataQueue) {
    NetbufQueFree (Sock->SndBuffer.DataQueue);
  }
 
  if (NULL != Sock->RcvBuffer.DataQueue) {
    NetbufQueFree (Sock->RcvBuffer.DataQueue);
  }
 
  FreePool (Sock);
 
  return NULL;
}
 
VOID
SockDestroy (
  IN OUT SOCKET  *Sock
  )
{
  ASSERT (SockStream == Sock->Type);
 
  //
  // Flush the completion token buffered
  // by sock and rcv, snd buffer
  //
  if (!SOCK_IS_UNCONFIGURED (Sock)) {
    SockConnFlush (Sock);
    SockSetState (Sock, SO_CLOSED);
    Sock->ConfigureState = SO_UNCONFIGURED;
  }
 
  //
  // Destroy the RcvBuffer Queue and SendBuffer Queue
  //
  NetbufQueFree (Sock->RcvBuffer.DataQueue);
  NetbufQueFree (Sock->SndBuffer.DataQueue);
 
  //
  // Remove it from parent connection list if needed
  //
  if (Sock->Parent != NULL) {
    RemoveEntryList (&(Sock->ConnectionList));
    (Sock->Parent->ConnCnt)--;
 
    DEBUG (
      (DEBUG_WARN,
       "SockDestroy: Delete a unaccepted socket from parent now conncnt is %d\n",
       Sock->Parent->ConnCnt)
      );
 
    Sock->Parent = NULL;
  }
 
  FreePool (Sock);
}
 
VOID
SockConnFlush (
  IN OUT SOCKET  *Sock
  )
{
  SOCKET  *Child;
 
  ASSERT (Sock != NULL);
 
  //
  // Clear the flag in this socket
  //
  Sock->Flag = 0;
 
  //
  // Flush the SndBuffer and RcvBuffer of Sock
  //
  NetbufQueFlush (Sock->SndBuffer.DataQueue);
  NetbufQueFlush (Sock->RcvBuffer.DataQueue);
 
  //
  // Signal the pending token
  //
  if (Sock->ConnectionToken != NULL) {
    SIGNAL_TOKEN (Sock->ConnectionToken, Sock->SockError);
    Sock->ConnectionToken = NULL;
  }
 
  if (Sock->CloseToken != NULL) {
    SIGNAL_TOKEN (Sock->CloseToken, Sock->SockError);
    Sock->CloseToken = NULL;
  }
 
  SockFlushPendingToken (Sock, &(Sock->ListenTokenList));
  SockFlushPendingToken (Sock, &(Sock->RcvTokenList));
  SockFlushPendingToken (Sock, &(Sock->SndTokenList));
  SockFlushPendingToken (Sock, &(Sock->ProcessingSndTokenList));
 
  //
  // Destroy the pending connection, if it is a listening socket
  //
  if (SOCK_IS_LISTENING (Sock)) {
    while (!IsListEmpty (&Sock->ConnectionList)) {
      Child = NET_LIST_HEAD (
                &Sock->ConnectionList,
                SOCKET,
                ConnectionList
                );
 
      SockDestroyChild (Child);
    }
 
    Sock->ConnCnt = 0;
  }
}
 
VOID
SockSetState (
  IN OUT SOCKET  *Sock,
  IN     UINT8   State
  )
{
  Sock->State = State;
}
 
SOCKET *
SockClone (
  IN SOCKET  *Sock
  )
{
  SOCKET          *ClonedSock;
  SOCK_INIT_DATA  InitData;
 
  InitData.BackLog         = Sock->BackLog;
  InitData.Parent          = Sock;
  InitData.State           = Sock->State;
  InitData.ProtoHandler    = Sock->ProtoHandler;
  InitData.Type            = Sock->Type;
  InitData.RcvBufferSize   = Sock->RcvBuffer.HighWater;
  InitData.SndBufferSize   = Sock->SndBuffer.HighWater;
  InitData.DriverBinding   = Sock->DriverBinding;
  InitData.IpVersion       = Sock->IpVersion;
  InitData.Protocol        = &(Sock->NetProtocol);
  InitData.CreateCallback  = Sock->CreateCallback;
  InitData.DestroyCallback = Sock->DestroyCallback;
  InitData.Context         = Sock->Context;
  InitData.ProtoData       = Sock->ProtoReserved;
  InitData.DataSize        = sizeof (Sock->ProtoReserved);
 
  ClonedSock = SockCreate (&InitData);
 
  if (NULL == ClonedSock) {
    DEBUG ((DEBUG_ERROR, "SockClone: no resource to create a cloned sock\n"));
    return NULL;
  }
 
  SockSetState (ClonedSock, SO_CONNECTING);
  ClonedSock->ConfigureState = Sock->ConfigureState;
 
  return ClonedSock;
}
 
VOID
SockConnEstablished (
  IN OUT SOCKET  *Sock
  )
{
  ASSERT (SO_CONNECTING == Sock->State);
 
  SockSetState (Sock, SO_CONNECTED);
 
  if (NULL == Sock->Parent) {
    SockWakeConnToken (Sock);
  } else {
    SockWakeListenToken (Sock);
  }
}
 
VOID
SockConnClosed (
  IN OUT SOCKET  *Sock
  )
{
  if (Sock->CloseToken != NULL) {
    SIGNAL_TOKEN (Sock->CloseToken, EFI_SUCCESS);
    Sock->CloseToken = NULL;
  }
 
  SockConnFlush (Sock);
  SockSetState (Sock, SO_CLOSED);
 
  if (Sock->Parent != NULL) {
    SockDestroyChild (Sock);
  }
}
 
VOID
SockDataSent (
  IN OUT SOCKET  *Sock,
  IN     UINT32  Count
  )
{
  SOCK_TOKEN             *SockToken;
  SOCK_COMPLETION_TOKEN  *SndToken;
 
  ASSERT (!IsListEmpty (&Sock->ProcessingSndTokenList));
  ASSERT (Count <= (Sock->SndBuffer.DataQueue)->BufSize);
 
  NetbufQueTrim (Sock->SndBuffer.DataQueue, Count);
 
  //
  // To check if we can signal some snd token in this socket
  //
  while (Count > 0) {
    SockToken = NET_LIST_HEAD (
                  &(Sock->ProcessingSndTokenList),
                  SOCK_TOKEN,
                  TokenList
                  );
 
    SndToken = SockToken->Token;
 
    if (SockToken->RemainDataLen <= Count) {
      RemoveEntryList (&(SockToken->TokenList));
      SIGNAL_TOKEN (SndToken, EFI_SUCCESS);
      Count -= SockToken->RemainDataLen;
      FreePool (SockToken);
    } else {
      SockToken->RemainDataLen -= Count;
      Count                     = 0;
    }
  }
 
  //
  // to judge if we can process some send token in
  // Sock->SndTokenList, if so process those send token
  //
  SockProcessSndToken (Sock);
}
 
UINT32
SockGetDataToSend (
  IN  SOCKET  *Sock,
  IN  UINT32  Offset,
  IN  UINT32  Len,
  OUT UINT8   *Dest
  )
{
  ASSERT ((Sock != NULL) && SockStream == Sock->Type);
 
  return NetbufQueCopy (
           Sock->SndBuffer.DataQueue,
           Offset,
           Len,
           Dest
           );
}
 
VOID
SockDataRcvd (
  IN OUT SOCKET   *Sock,
  IN OUT NET_BUF  *NetBuffer,
  IN     UINT32   UrgLen
  )
{
  ASSERT (
    (Sock != NULL) && (Sock->RcvBuffer.DataQueue != NULL) &&
    UrgLen <= NetBuffer->TotalSize
    );
 
  NET_GET_REF (NetBuffer);
 
  ((TCP_RSV_DATA *)(NetBuffer->ProtoData))->UrgLen = UrgLen;
 
  NetbufQueAppend (Sock->RcvBuffer.DataQueue, NetBuffer);
 
  SockWakeRcvToken (Sock);
}
 
UINT32
SockGetFreeSpace (
  IN SOCKET  *Sock,
  IN UINT32  Which
  )
{
  UINT32       BufferCC;
  SOCK_BUFFER  *SockBuffer;
 
  ASSERT (Sock != NULL && ((SOCK_SND_BUF == Which) || (SOCK_RCV_BUF == Which)));
 
  if (SOCK_SND_BUF == Which) {
    SockBuffer = &(Sock->SndBuffer);
  } else {
    SockBuffer = &(Sock->RcvBuffer);
  }
 
  BufferCC = (SockBuffer->DataQueue)->BufSize;
 
  if (BufferCC >= SockBuffer->HighWater) {
    return 0;
  }
 
  return SockBuffer->HighWater - BufferCC;
}
 
VOID
SockNoMoreData (
  IN OUT SOCKET  *Sock
  )
{
  EFI_STATUS  Err;
 
  SOCK_NO_MORE_DATA (Sock);
 
  if (!IsListEmpty (&Sock->RcvTokenList)) {
    ASSERT (0 == GET_RCV_DATASIZE (Sock));
 
    Err = Sock->SockError;
 
    SOCK_ERROR (Sock, EFI_CONNECTION_FIN);
 
    SockFlushPendingToken (Sock, &Sock->RcvTokenList);
 
    SOCK_ERROR (Sock, Err);
  }
}