TcpMain.c

Go to the documentation of this file.

 
#include "TcpMain.h"
 
EFI_STATUS
TcpChkDataBuf (
  IN UINT32                  DataLen,
  IN UINT32                  FragmentCount,
  IN EFI_TCP4_FRAGMENT_DATA  *FragmentTable
  )
{
  UINT32  Index;
 
  UINT32  Len;
 
  for (Index = 0, Len = 0; Index < FragmentCount; Index++) {
    if (FragmentTable[Index].FragmentBuffer == NULL) {
      return EFI_INVALID_PARAMETER;
    }
 
    Len = Len + FragmentTable[Index].FragmentLength;
  }
 
  if (DataLen != Len) {
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Tcp4GetModeData (
  IN   EFI_TCP4_PROTOCOL                *This,
  OUT  EFI_TCP4_CONNECTION_STATE        *Tcp4State      OPTIONAL,
  OUT  EFI_TCP4_CONFIG_DATA             *Tcp4ConfigData OPTIONAL,
  OUT  EFI_IP4_MODE_DATA                *Ip4ModeData    OPTIONAL,
  OUT  EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL,
  OUT  EFI_SIMPLE_NETWORK_MODE          *SnpModeData    OPTIONAL
  )
{
  TCP4_MODE_DATA  TcpMode;
  SOCKET          *Sock;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  TcpMode.Tcp4State      = Tcp4State;
  TcpMode.Tcp4ConfigData = Tcp4ConfigData;
  TcpMode.Ip4ModeData    = Ip4ModeData;
  TcpMode.MnpConfigData  = MnpConfigData;
  TcpMode.SnpModeData    = SnpModeData;
 
  return SockGetMode (Sock, &TcpMode);
}
 
EFI_STATUS
EFIAPI
Tcp4Configure (
  IN EFI_TCP4_PROTOCOL     *This,
  IN EFI_TCP4_CONFIG_DATA  *TcpConfigData OPTIONAL
  )
{
  EFI_TCP4_OPTION  *Option;
  SOCKET           *Sock;
  EFI_STATUS       Status;
  IP4_ADDR         Ip;
  IP4_ADDR         SubnetMask;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Tcp protocol related parameter check will be conducted here
  //
  if (NULL != TcpConfigData) {
    CopyMem (&Ip, &TcpConfigData->AccessPoint.RemoteAddress, sizeof (IP4_ADDR));
    if (IP4_IS_LOCAL_BROADCAST (NTOHL (Ip))) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (TcpConfigData->AccessPoint.ActiveFlag && ((0 == TcpConfigData->AccessPoint.RemotePort) || (Ip == 0))) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (!TcpConfigData->AccessPoint.UseDefaultAddress) {
      CopyMem (&Ip, &TcpConfigData->AccessPoint.StationAddress, sizeof (IP4_ADDR));
      CopyMem (&SubnetMask, &TcpConfigData->AccessPoint.SubnetMask, sizeof (IP4_ADDR));
      if (!IP4_IS_VALID_NETMASK (NTOHL (SubnetMask)) ||
          ((SubnetMask != 0) && !NetIp4IsUnicast (NTOHL (Ip), NTOHL (SubnetMask))))
      {
        return EFI_INVALID_PARAMETER;
      }
    }
 
    Option = TcpConfigData->ControlOption;
    if ((NULL != Option) && (Option->EnableSelectiveAck || Option->EnablePathMtuDiscovery)) {
      return EFI_UNSUPPORTED;
    }
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  if (NULL == TcpConfigData) {
    return SockFlush (Sock);
  }
 
  Status = SockConfigure (Sock, TcpConfigData);
 
  if (EFI_NO_MAPPING == Status) {
    Sock->ConfigureState = SO_NO_MAPPING;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
Tcp4Routes (
  IN EFI_TCP4_PROTOCOL  *This,
  IN BOOLEAN            DeleteRoute,
  IN EFI_IPv4_ADDRESS   *SubnetAddress,
  IN EFI_IPv4_ADDRESS   *SubnetMask,
  IN EFI_IPv4_ADDRESS   *GatewayAddress
  )
{
  SOCKET           *Sock;
  TCP4_ROUTE_INFO  RouteInfo;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  RouteInfo.DeleteRoute    = DeleteRoute;
  RouteInfo.SubnetAddress  = SubnetAddress;
  RouteInfo.SubnetMask     = SubnetMask;
  RouteInfo.GatewayAddress = GatewayAddress;
 
  return SockRoute (Sock, &RouteInfo);
}
 
EFI_STATUS
EFIAPI
Tcp4Connect (
  IN EFI_TCP4_PROTOCOL          *This,
  IN EFI_TCP4_CONNECTION_TOKEN  *ConnectionToken
  )
{
  SOCKET  *Sock;
 
  if ((NULL == This) || (NULL == ConnectionToken) || (NULL == ConnectionToken->CompletionToken.Event)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockConnect (Sock, ConnectionToken);
}
 
EFI_STATUS
EFIAPI
Tcp4Accept (
  IN EFI_TCP4_PROTOCOL      *This,
  IN EFI_TCP4_LISTEN_TOKEN  *ListenToken
  )
{
  SOCKET  *Sock;
 
  if ((NULL == This) || (NULL == ListenToken) || (NULL == ListenToken->CompletionToken.Event)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockAccept (Sock, ListenToken);
}
 
EFI_STATUS
EFIAPI
Tcp4Transmit (
  IN EFI_TCP4_PROTOCOL  *This,
  IN EFI_TCP4_IO_TOKEN  *Token
  )
{
  SOCKET      *Sock;
  EFI_STATUS  Status;
 
  if ((NULL == This) ||
      (NULL == Token) ||
      (NULL == Token->CompletionToken.Event) ||
      (NULL == Token->Packet.TxData) ||
      (0 == Token->Packet.TxData->FragmentCount) ||
      (0 == Token->Packet.TxData->DataLength)
      )
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = TcpChkDataBuf (
             Token->Packet.TxData->DataLength,
             Token->Packet.TxData->FragmentCount,
             Token->Packet.TxData->FragmentTable
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockSend (Sock, Token);
}
 
EFI_STATUS
EFIAPI
Tcp4Receive (
  IN EFI_TCP4_PROTOCOL  *This,
  IN EFI_TCP4_IO_TOKEN  *Token
  )
{
  SOCKET      *Sock;
  EFI_STATUS  Status;
 
  if ((NULL == This) ||
      (NULL == Token) ||
      (NULL == Token->CompletionToken.Event) ||
      (NULL == Token->Packet.RxData) ||
      (0 == Token->Packet.RxData->FragmentCount) ||
      (0 == Token->Packet.RxData->DataLength)
      )
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = TcpChkDataBuf (
             Token->Packet.RxData->DataLength,
             Token->Packet.RxData->FragmentCount,
             Token->Packet.RxData->FragmentTable
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockRcv (Sock, Token);
}
 
EFI_STATUS
EFIAPI
Tcp4Close (
  IN EFI_TCP4_PROTOCOL     *This,
  IN EFI_TCP4_CLOSE_TOKEN  *CloseToken
  )
{
  SOCKET  *Sock;
 
  if ((NULL == This) || (NULL == CloseToken) || (NULL == CloseToken->CompletionToken.Event)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockClose (Sock, CloseToken, CloseToken->AbortOnClose);
}
 
EFI_STATUS
EFIAPI
Tcp4Cancel (
  IN EFI_TCP4_PROTOCOL          *This,
  IN EFI_TCP4_COMPLETION_TOKEN  *Token OPTIONAL
  )
{
  SOCKET  *Sock;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockCancel (Sock, Token);
}
 
EFI_STATUS
EFIAPI
Tcp4Poll (
  IN EFI_TCP4_PROTOCOL  *This
  )
{
  SOCKET      *Sock;
  EFI_STATUS  Status;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  Status = Sock->ProtoHandler (Sock, SOCK_POLL, NULL);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
Tcp6GetModeData (
  IN  EFI_TCP6_PROTOCOL                *This,
  OUT EFI_TCP6_CONNECTION_STATE        *Tcp6State      OPTIONAL,
  OUT EFI_TCP6_CONFIG_DATA             *Tcp6ConfigData OPTIONAL,
  OUT EFI_IP6_MODE_DATA                *Ip6ModeData    OPTIONAL,
  OUT EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL,
  OUT EFI_SIMPLE_NETWORK_MODE          *SnpModeData    OPTIONAL
  )
{
  TCP6_MODE_DATA  TcpMode;
  SOCKET          *Sock;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  TcpMode.Tcp6State      = Tcp6State;
  TcpMode.Tcp6ConfigData = Tcp6ConfigData;
  TcpMode.Ip6ModeData    = Ip6ModeData;
  TcpMode.MnpConfigData  = MnpConfigData;
  TcpMode.SnpModeData    = SnpModeData;
 
  return SockGetMode (Sock, &TcpMode);
}
 
EFI_STATUS
EFIAPI
Tcp6Configure (
  IN EFI_TCP6_PROTOCOL     *This,
  IN EFI_TCP6_CONFIG_DATA  *Tcp6ConfigData OPTIONAL
  )
{
  EFI_TCP6_OPTION   *Option;
  SOCKET            *Sock;
  EFI_STATUS        Status;
  EFI_IPv6_ADDRESS  *Ip;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Tcp protocol related parameter check will be conducted here
  //
  if (NULL != Tcp6ConfigData) {
    Ip = &Tcp6ConfigData->AccessPoint.RemoteAddress;
    if (!NetIp6IsUnspecifiedAddr (Ip) && !NetIp6IsValidUnicast (Ip)) {
      return EFI_INVALID_PARAMETER;
    }
 
    if (Tcp6ConfigData->AccessPoint.ActiveFlag &&
        ((0 == Tcp6ConfigData->AccessPoint.RemotePort) || NetIp6IsUnspecifiedAddr (Ip))
        )
    {
      return EFI_INVALID_PARAMETER;
    }
 
    Ip = &Tcp6ConfigData->AccessPoint.StationAddress;
    if (!NetIp6IsUnspecifiedAddr (Ip) && !NetIp6IsValidUnicast (Ip)) {
      return EFI_INVALID_PARAMETER;
    }
 
    Option = Tcp6ConfigData->ControlOption;
    if ((NULL != Option) && (Option->EnableSelectiveAck || Option->EnablePathMtuDiscovery)) {
      return EFI_UNSUPPORTED;
    }
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  if (NULL == Tcp6ConfigData) {
    return SockFlush (Sock);
  }
 
  Status = SockConfigure (Sock, Tcp6ConfigData);
 
  if (EFI_NO_MAPPING == Status) {
    Sock->ConfigureState = SO_NO_MAPPING;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
Tcp6Connect (
  IN EFI_TCP6_PROTOCOL          *This,
  IN EFI_TCP6_CONNECTION_TOKEN  *ConnectionToken
  )
{
  SOCKET  *Sock;
 
  if ((NULL == This) || (NULL == ConnectionToken) || (NULL == ConnectionToken->CompletionToken.Event)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockConnect (Sock, ConnectionToken);
}
 
EFI_STATUS
EFIAPI
Tcp6Accept (
  IN EFI_TCP6_PROTOCOL      *This,
  IN EFI_TCP6_LISTEN_TOKEN  *ListenToken
  )
{
  SOCKET  *Sock;
 
  if ((NULL == This) || (NULL == ListenToken) || (NULL == ListenToken->CompletionToken.Event)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockAccept (Sock, ListenToken);
}
 
EFI_STATUS
EFIAPI
Tcp6Transmit (
  IN EFI_TCP6_PROTOCOL  *This,
  IN EFI_TCP6_IO_TOKEN  *Token
  )
{
  SOCKET      *Sock;
  EFI_STATUS  Status;
 
  if ((NULL == This) ||
      (NULL == Token) ||
      (NULL == Token->CompletionToken.Event) ||
      (NULL == Token->Packet.TxData) ||
      (0 == Token->Packet.TxData->FragmentCount) ||
      (0 == Token->Packet.TxData->DataLength)
      )
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = TcpChkDataBuf (
             Token->Packet.TxData->DataLength,
             Token->Packet.TxData->FragmentCount,
             (EFI_TCP4_FRAGMENT_DATA *)Token->Packet.TxData->FragmentTable
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockSend (Sock, Token);
}
 
EFI_STATUS
EFIAPI
Tcp6Receive (
  IN EFI_TCP6_PROTOCOL  *This,
  IN EFI_TCP6_IO_TOKEN  *Token
  )
{
  SOCKET      *Sock;
  EFI_STATUS  Status;
 
  if ((NULL == This) ||
      (NULL == Token) ||
      (NULL == Token->CompletionToken.Event) ||
      (NULL == Token->Packet.RxData) ||
      (0 == Token->Packet.RxData->FragmentCount) ||
      (0 == Token->Packet.RxData->DataLength)
      )
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = TcpChkDataBuf (
             Token->Packet.RxData->DataLength,
             Token->Packet.RxData->FragmentCount,
             (EFI_TCP4_FRAGMENT_DATA *)Token->Packet.RxData->FragmentTable
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockRcv (Sock, Token);
}
 
EFI_STATUS
EFIAPI
Tcp6Close (
  IN EFI_TCP6_PROTOCOL     *This,
  IN EFI_TCP6_CLOSE_TOKEN  *CloseToken
  )
{
  SOCKET  *Sock;
 
  if ((NULL == This) || (NULL == CloseToken) || (NULL == CloseToken->CompletionToken.Event)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockClose (Sock, CloseToken, CloseToken->AbortOnClose);
}
 
EFI_STATUS
EFIAPI
Tcp6Cancel (
  IN EFI_TCP6_PROTOCOL          *This,
  IN EFI_TCP6_COMPLETION_TOKEN  *Token OPTIONAL
  )
{
  SOCKET  *Sock;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  return SockCancel (Sock, Token);
}
 
EFI_STATUS
EFIAPI
Tcp6Poll (
  IN EFI_TCP6_PROTOCOL  *This
  )
{
  SOCKET      *Sock;
  EFI_STATUS  Status;
 
  if (NULL == This) {
    return EFI_INVALID_PARAMETER;
  }
 
  Sock = SOCK_FROM_THIS (This);
 
  Status = Sock->ProtoHandler (Sock, SOCK_POLL, NULL);
 
  return Status;
}