DxeUdpIoLib.c

Go to the documentation of this file.

 
#include <Uefi.h>
 
#include <Protocol/Udp4.h>
#include <Protocol/Udp6.h>
 
#include <Library/UdpIoLib.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DpcLib.h>
 
VOID
UdpIoFreeTxToken (
  IN UDP_TX_TOKEN  *TxToken
  )
{
  if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    gBS->CloseEvent (TxToken->Token.Udp4.Event);
  } else if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {
    gBS->CloseEvent (TxToken->Token.Udp6.Event);
  } else {
    ASSERT (FALSE);
  }
 
  FreePool (TxToken);
}
 
VOID
UdpIoFreeRxToken (
  IN UDP_RX_TOKEN  *RxToken
  )
{
  if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    gBS->CloseEvent (RxToken->Token.Udp4.Event);
  } else if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {
    gBS->CloseEvent (RxToken->Token.Udp6.Event);
  } else {
    ASSERT (FALSE);
  }
 
  FreePool (RxToken);
}
 
VOID
EFIAPI
UdpIoOnDgramSentDpc (
  IN VOID  *Context
  )
{
  UDP_TX_TOKEN  *TxToken;
 
  TxToken = (UDP_TX_TOKEN *)Context;
  ASSERT (TxToken->Signature == UDP_IO_TX_SIGNATURE);
  ASSERT (
    (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (TxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  RemoveEntryList (&TxToken->Link);
 
  if (TxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    TxToken->CallBack (TxToken->Packet, NULL, TxToken->Token.Udp4.Status, TxToken->Context);
  } else {
    TxToken->CallBack (TxToken->Packet, NULL, TxToken->Token.Udp6.Status, TxToken->Context);
  }
 
  UdpIoFreeTxToken (TxToken);
}
 
VOID
EFIAPI
UdpIoOnDgramSent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  //
  // Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK
  //
  QueueDpc (TPL_CALLBACK, UdpIoOnDgramSentDpc, Context);
}
 
VOID
EFIAPI
UdpIoRecycleDgram (
  IN VOID  *Context
  )
{
  UDP_RX_TOKEN  *RxToken;
 
  RxToken = (UDP_RX_TOKEN *)Context;
 
  if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    gBS->SignalEvent (RxToken->Token.Udp4.Packet.RxData->RecycleSignal);
  } else if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION) {
    gBS->SignalEvent (RxToken->Token.Udp6.Packet.RxData->RecycleSignal);
  } else {
    ASSERT (FALSE);
  }
 
  UdpIoFreeRxToken (RxToken);
}
 
VOID
EFIAPI
UdpIoOnDgramRcvdDpc (
  IN VOID  *Context
  )
{
  EFI_STATUS     Status;
  VOID           *Token;
  VOID           *RxData;
  VOID           *Session;
  UDP_RX_TOKEN   *RxToken;
  UDP_END_POINT  EndPoint;
  NET_BUF        *Netbuf;
 
  RxToken = (UDP_RX_TOKEN *)Context;
 
  ZeroMem (&EndPoint, sizeof (UDP_END_POINT));
 
  ASSERT (
    (RxToken->Signature == UDP_IO_RX_SIGNATURE) &&
    (RxToken == RxToken->UdpIo->RecvRequest)
    );
 
  ASSERT (
    (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (RxToken->UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  //
  // Clear the receive request first in case that the caller
  // wants to restart the receive in the callback.
  //
  RxToken->UdpIo->RecvRequest = NULL;
 
  if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    Token  = &RxToken->Token.Udp4;
    RxData = ((EFI_UDP4_COMPLETION_TOKEN *)Token)->Packet.RxData;
    Status = ((EFI_UDP4_COMPLETION_TOKEN *)Token)->Status;
  } else {
    Token  = &RxToken->Token.Udp6;
    RxData = ((EFI_UDP6_COMPLETION_TOKEN *)Token)->Packet.RxData;
    Status = ((EFI_UDP6_COMPLETION_TOKEN *)Token)->Status;
  }
 
  if (EFI_ERROR (Status) || (RxData == NULL)) {
    if (Status != EFI_ABORTED) {
      //
      // Invoke the CallBack only if the reception is not actively aborted.
      //
      RxToken->CallBack (NULL, NULL, Status, RxToken->Context);
    }
 
    UdpIoFreeRxToken (RxToken);
    return;
  }
 
  //
  // Build a NET_BUF from the UDP receive data, then deliver it up.
  //
  if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    if (((EFI_UDP4_RECEIVE_DATA *)RxData)->DataLength == 0) {
      //
      // Discard zero length data payload packet.
      //
      goto Resume;
    }
 
    Netbuf = NetbufFromExt (
               (NET_FRAGMENT *)((EFI_UDP4_RECEIVE_DATA *)RxData)->FragmentTable,
               ((EFI_UDP4_RECEIVE_DATA *)RxData)->FragmentCount,
               0,
               (UINT32)RxToken->HeadLen,
               UdpIoRecycleDgram,
               RxToken
               );
 
    if (Netbuf == NULL) {
      gBS->SignalEvent (((EFI_UDP4_RECEIVE_DATA *)RxData)->RecycleSignal);
      RxToken->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, RxToken->Context);
 
      UdpIoFreeRxToken (RxToken);
      return;
    }
 
    Session             = &((EFI_UDP4_RECEIVE_DATA *)RxData)->UdpSession;
    EndPoint.LocalPort  = ((EFI_UDP4_SESSION_DATA *)Session)->DestinationPort;
    EndPoint.RemotePort = ((EFI_UDP4_SESSION_DATA *)Session)->SourcePort;
 
    CopyMem (
      &EndPoint.LocalAddr,
      &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress,
      sizeof (EFI_IPv4_ADDRESS)
      );
 
    CopyMem (
      &EndPoint.RemoteAddr,
      &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress,
      sizeof (EFI_IPv4_ADDRESS)
      );
 
    EndPoint.LocalAddr.Addr[0]  = NTOHL (EndPoint.LocalAddr.Addr[0]);
    EndPoint.RemoteAddr.Addr[0] = NTOHL (EndPoint.RemoteAddr.Addr[0]);
  } else {
    if (((EFI_UDP6_RECEIVE_DATA *)RxData)->DataLength == 0) {
      //
      // Discard zero length data payload packet.
      //
      goto Resume;
    }
 
    Netbuf = NetbufFromExt (
               (NET_FRAGMENT *)((EFI_UDP6_RECEIVE_DATA *)RxData)->FragmentTable,
               ((EFI_UDP6_RECEIVE_DATA *)RxData)->FragmentCount,
               0,
               (UINT32)RxToken->HeadLen,
               UdpIoRecycleDgram,
               RxToken
               );
 
    if (Netbuf == NULL) {
      gBS->SignalEvent (((EFI_UDP6_RECEIVE_DATA *)RxData)->RecycleSignal);
      RxToken->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, RxToken->Context);
 
      UdpIoFreeRxToken (RxToken);
      return;
    }
 
    Session             = &((EFI_UDP6_RECEIVE_DATA *)RxData)->UdpSession;
    EndPoint.LocalPort  = ((EFI_UDP6_SESSION_DATA *)Session)->DestinationPort;
    EndPoint.RemotePort = ((EFI_UDP6_SESSION_DATA *)Session)->SourcePort;
 
    CopyMem (
      &EndPoint.LocalAddr,
      &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress,
      sizeof (EFI_IPv6_ADDRESS)
      );
 
    CopyMem (
      &EndPoint.RemoteAddr,
      &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress,
      sizeof (EFI_IPv6_ADDRESS)
      );
 
    Ip6Swap128 (&EndPoint.LocalAddr.v6);
    Ip6Swap128 (&EndPoint.RemoteAddr.v6);
  }
 
  RxToken->CallBack (Netbuf, &EndPoint, EFI_SUCCESS, RxToken->Context);
  return;
 
Resume:
  if (RxToken->UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    gBS->SignalEvent (((EFI_UDP4_RECEIVE_DATA *)RxData)->RecycleSignal);
    RxToken->UdpIo->Protocol.Udp4->Receive (RxToken->UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
  } else {
    gBS->SignalEvent (((EFI_UDP6_RECEIVE_DATA *)RxData)->RecycleSignal);
    RxToken->UdpIo->Protocol.Udp6->Receive (RxToken->UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
  }
}
 
VOID
EFIAPI
UdpIoOnDgramRcvd (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  //
  // Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK
  //
  QueueDpc (TPL_CALLBACK, UdpIoOnDgramRcvdDpc, Context);
}
 
UDP_RX_TOKEN *
UdpIoCreateRxToken (
  IN UDP_IO           *UdpIo,
  IN UDP_IO_CALLBACK  CallBack,
  IN VOID             *Context,
  IN UINT32           HeadLen
  )
{
  UDP_RX_TOKEN  *Token;
  EFI_STATUS    Status;
 
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  Token = AllocatePool (sizeof (UDP_RX_TOKEN));
 
  if (Token == NULL) {
    return NULL;
  }
 
  Token->Signature = UDP_IO_RX_SIGNATURE;
  Token->UdpIo     = UdpIo;
  Token->CallBack  = CallBack;
  Token->Context   = Context;
  Token->HeadLen   = HeadLen;
 
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    Token->Token.Udp4.Status        = EFI_NOT_READY;
    Token->Token.Udp4.Packet.RxData = NULL;
 
    Status = gBS->CreateEvent (
                    EVT_NOTIFY_SIGNAL,
                    TPL_NOTIFY,
                    UdpIoOnDgramRcvd,
                    Token,
                    &Token->Token.Udp4.Event
                    );
  } else {
    Token->Token.Udp6.Status        = EFI_NOT_READY;
    Token->Token.Udp6.Packet.RxData = NULL;
 
    Status = gBS->CreateEvent (
                    EVT_NOTIFY_SIGNAL,
                    TPL_NOTIFY,
                    UdpIoOnDgramRcvd,
                    Token,
                    &Token->Token.Udp6.Event
                    );
  }
 
  if (EFI_ERROR (Status)) {
    FreePool (Token);
    return NULL;
  }
 
  return Token;
}
 
UDP_TX_TOKEN *
UdpIoCreateTxToken (
  IN UDP_IO           *UdpIo,
  IN NET_BUF          *Packet,
  IN UDP_END_POINT    *EndPoint OPTIONAL,
  IN EFI_IP_ADDRESS   *Gateway  OPTIONAL,
  IN UDP_IO_CALLBACK  CallBack,
  IN VOID             *Context
  )
{
  UDP_TX_TOKEN  *TxToken;
  VOID          *Token;
  VOID          *Data;
  EFI_STATUS    Status;
  UINT32        Count;
  UINTN         Size;
  IP4_ADDR      Ip;
 
  ASSERT (Packet != NULL);
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    Size = sizeof (UDP_TX_TOKEN) + sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1);
  } else {
    Size = sizeof (UDP_TX_TOKEN) + sizeof (EFI_UDP6_FRAGMENT_DATA) * (Packet->BlockOpNum - 1);
  }
 
  TxToken = AllocatePool (Size);
 
  if (TxToken == NULL) {
    return NULL;
  }
 
  TxToken->Signature = UDP_IO_TX_SIGNATURE;
  InitializeListHead (&TxToken->Link);
 
  TxToken->UdpIo    = UdpIo;
  TxToken->CallBack = CallBack;
  TxToken->Packet   = Packet;
  TxToken->Context  = Context;
 
  Token = &(TxToken->Token);
  Count = Packet->BlockOpNum;
 
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    ((EFI_UDP4_COMPLETION_TOKEN *)Token)->Status = EFI_NOT_READY;
 
    Status = gBS->CreateEvent (
                    EVT_NOTIFY_SIGNAL,
                    TPL_NOTIFY,
                    UdpIoOnDgramSent,
                    TxToken,
                    &((EFI_UDP4_COMPLETION_TOKEN *)Token)->Event
                    );
 
    if (EFI_ERROR (Status)) {
      FreePool (TxToken);
      return NULL;
    }
 
    Data                                                = &(TxToken->Data.Udp4);
    ((EFI_UDP4_COMPLETION_TOKEN *)Token)->Packet.TxData = Data;
 
    ((EFI_UDP4_TRANSMIT_DATA *)Data)->UdpSessionData = NULL;
    ((EFI_UDP4_TRANSMIT_DATA *)Data)->GatewayAddress = NULL;
    ((EFI_UDP4_TRANSMIT_DATA *)Data)->DataLength     = Packet->TotalSize;
 
    NetbufBuildExt (
      Packet,
      (NET_FRAGMENT *)((EFI_UDP4_TRANSMIT_DATA *)Data)->FragmentTable,
      &Count
      );
 
    ((EFI_UDP4_TRANSMIT_DATA *)Data)->FragmentCount = Count;
 
    if (EndPoint != NULL) {
      Ip = HTONL (EndPoint->LocalAddr.Addr[0]);
      CopyMem (
        &TxToken->Session.Udp4.SourceAddress,
        &Ip,
        sizeof (EFI_IPv4_ADDRESS)
        );
 
      Ip = HTONL (EndPoint->RemoteAddr.Addr[0]);
      CopyMem (
        &TxToken->Session.Udp4.DestinationAddress,
        &Ip,
        sizeof (EFI_IPv4_ADDRESS)
        );
 
      TxToken->Session.Udp4.SourcePort                 = EndPoint->LocalPort;
      TxToken->Session.Udp4.DestinationPort            = EndPoint->RemotePort;
      ((EFI_UDP4_TRANSMIT_DATA *)Data)->UdpSessionData = &(TxToken->Session.Udp4);
    }
 
    if ((Gateway != NULL) && (Gateway->Addr[0] != 0)) {
      Ip = HTONL (Gateway->Addr[0]);
      CopyMem (&TxToken->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));
      ((EFI_UDP4_TRANSMIT_DATA *)Data)->GatewayAddress = &TxToken->Gateway;
    }
  } else {
    ((EFI_UDP6_COMPLETION_TOKEN *)Token)->Status = EFI_NOT_READY;
 
    Status = gBS->CreateEvent (
                    EVT_NOTIFY_SIGNAL,
                    TPL_NOTIFY,
                    UdpIoOnDgramSent,
                    TxToken,
                    &((EFI_UDP6_COMPLETION_TOKEN *)Token)->Event
                    );
 
    if (EFI_ERROR (Status)) {
      FreePool (TxToken);
      return NULL;
    }
 
    Data                                                = &(TxToken->Data.Udp6);
    ((EFI_UDP6_COMPLETION_TOKEN *)Token)->Packet.TxData = Data;
    ((EFI_UDP6_TRANSMIT_DATA *)Data)->UdpSessionData    = NULL;
    ((EFI_UDP6_TRANSMIT_DATA *)Data)->DataLength        = Packet->TotalSize;
 
    NetbufBuildExt (
      Packet,
      (NET_FRAGMENT *)((EFI_UDP6_TRANSMIT_DATA *)Data)->FragmentTable,
      &Count
      );
 
    ((EFI_UDP6_TRANSMIT_DATA *)Data)->FragmentCount = Count;
 
    if (EndPoint != NULL) {
      CopyMem (
        &TxToken->Session.Udp6.SourceAddress,
        &EndPoint->LocalAddr.v6,
        sizeof (EFI_IPv6_ADDRESS)
        );
 
      CopyMem (
        &TxToken->Session.Udp6.DestinationAddress,
        &EndPoint->RemoteAddr.v6,
        sizeof (EFI_IPv6_ADDRESS)
        );
 
      TxToken->Session.Udp6.SourcePort                 = EndPoint->LocalPort;
      TxToken->Session.Udp6.DestinationPort            = EndPoint->RemotePort;
      ((EFI_UDP6_TRANSMIT_DATA *)Data)->UdpSessionData = &(TxToken->Session.Udp6);
    }
  }
 
  return TxToken;
}
 
UDP_IO *
EFIAPI
UdpIoCreateIo (
  IN  EFI_HANDLE     Controller,
  IN  EFI_HANDLE     ImageHandle,
  IN  UDP_IO_CONFIG  Configure,
  IN  UINT8          UdpVersion,
  IN  VOID           *Context
  )
{
  UDP_IO      *UdpIo;
  EFI_STATUS  Status;
 
  ASSERT (Configure != NULL);
  ASSERT ((UdpVersion == UDP_IO_UDP4_VERSION) || (UdpVersion == UDP_IO_UDP6_VERSION));
 
  UdpIo = AllocatePool (sizeof (UDP_IO));
 
  if (UdpIo == NULL) {
    return NULL;
  }
 
  UdpIo->UdpVersion = UdpVersion;
  UdpIo->Signature  = UDP_IO_SIGNATURE;
  InitializeListHead (&UdpIo->Link);
  UdpIo->RefCnt = 1;
 
  UdpIo->Controller = Controller;
  UdpIo->Image      = ImageHandle;
 
  InitializeListHead (&UdpIo->SentDatagram);
  UdpIo->RecvRequest = NULL;
  UdpIo->UdpHandle   = NULL;
 
  if (UdpVersion == UDP_IO_UDP4_VERSION) {
    //
    // Create a UDP child then open and configure it
    //
    Status = NetLibCreateServiceChild (
               Controller,
               ImageHandle,
               &gEfiUdp4ServiceBindingProtocolGuid,
               &UdpIo->UdpHandle
               );
 
    if (EFI_ERROR (Status)) {
      goto FREE_MEM;
    }
 
    Status = gBS->OpenProtocol (
                    UdpIo->UdpHandle,
                    &gEfiUdp4ProtocolGuid,
                    (VOID **)&UdpIo->Protocol.Udp4,
                    ImageHandle,
                    Controller,
                    EFI_OPEN_PROTOCOL_BY_DRIVER
                    );
 
    if (EFI_ERROR (Status)) {
      goto FREE_CHILD;
    }
 
    if (EFI_ERROR (Configure (UdpIo, Context))) {
      goto CLOSE_PROTOCOL;
    }
 
    Status = UdpIo->Protocol.Udp4->GetModeData (
                                     UdpIo->Protocol.Udp4,
                                     NULL,
                                     NULL,
                                     NULL,
                                     &UdpIo->SnpMode
                                     );
 
    if (EFI_ERROR (Status)) {
      goto CLOSE_PROTOCOL;
    }
  } else {
    Status = NetLibCreateServiceChild (
               Controller,
               ImageHandle,
               &gEfiUdp6ServiceBindingProtocolGuid,
               &UdpIo->UdpHandle
               );
 
    if (EFI_ERROR (Status)) {
      goto FREE_MEM;
    }
 
    Status = gBS->OpenProtocol (
                    UdpIo->UdpHandle,
                    &gEfiUdp6ProtocolGuid,
                    (VOID **)&UdpIo->Protocol.Udp6,
                    ImageHandle,
                    Controller,
                    EFI_OPEN_PROTOCOL_BY_DRIVER
                    );
 
    if (EFI_ERROR (Status)) {
      goto FREE_CHILD;
    }
 
    if (EFI_ERROR (Configure (UdpIo, Context))) {
      goto CLOSE_PROTOCOL;
    }
 
    Status = UdpIo->Protocol.Udp6->GetModeData (
                                     UdpIo->Protocol.Udp6,
                                     NULL,
                                     NULL,
                                     NULL,
                                     &UdpIo->SnpMode
                                     );
 
    if (EFI_ERROR (Status)) {
      goto CLOSE_PROTOCOL;
    }
  }
 
  return UdpIo;
 
CLOSE_PROTOCOL:
  if (UdpVersion == UDP_IO_UDP4_VERSION) {
    gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, ImageHandle, Controller);
  } else {
    gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp6ProtocolGuid, ImageHandle, Controller);
  }
 
FREE_CHILD:
  if (UdpVersion == UDP_IO_UDP4_VERSION) {
    NetLibDestroyServiceChild (
      Controller,
      ImageHandle,
      &gEfiUdp4ServiceBindingProtocolGuid,
      UdpIo->UdpHandle
      );
  } else {
    NetLibDestroyServiceChild (
      Controller,
      ImageHandle,
      &gEfiUdp6ServiceBindingProtocolGuid,
      UdpIo->UdpHandle
      );
  }
 
FREE_MEM:
  FreePool (UdpIo);
  return NULL;
}
 
VOID
EFIAPI
UdpIoCancelDgrams (
  IN UDP_IO            *UdpIo,
  IN EFI_STATUS        IoStatus,
  IN UDP_IO_TO_CANCEL  ToCancel         OPTIONAL,
  IN VOID              *Context         OPTIONAL
  )
{
  LIST_ENTRY    *Entry;
  LIST_ENTRY    *Next;
  UDP_TX_TOKEN  *TxToken;
 
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {
    TxToken = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);
 
    if ((ToCancel == NULL) || (ToCancel (TxToken, Context))) {
      if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
        UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);
      } else {
        UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);
      }
    }
  }
}
 
EFI_STATUS
EFIAPI
UdpIoFreeIo (
  IN  UDP_IO  *UdpIo
  )
{
  EFI_STATUS    Status;
  UDP_RX_TOKEN  *RxToken;
 
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  //
  // Cancel all the sent datagram and receive requests. The
  // callbacks of transmit requests are executed to allow the
  // caller to release the resource. The callback of receive
  // request are NOT executed. This is because it is most
  // likely that the current user of the UDP IO port is closing
  // itself.
  //
  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);
 
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    if ((RxToken = UdpIo->RecvRequest) != NULL) {
      Status = UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
 
    //
    // Close then destroy the Udp4 child
    //
    Status = gBS->CloseProtocol (
                    UdpIo->UdpHandle,
                    &gEfiUdp4ProtocolGuid,
                    UdpIo->Image,
                    UdpIo->Controller
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    Status = NetLibDestroyServiceChild (
               UdpIo->Controller,
               UdpIo->Image,
               &gEfiUdp4ServiceBindingProtocolGuid,
               UdpIo->UdpHandle
               );
    if (EFI_ERROR (Status)) {
      return Status;
    }
  } else {
    if ((RxToken = UdpIo->RecvRequest) != NULL) {
      Status = UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
 
    //
    // Close then destroy the Udp6 child
    //
    Status = gBS->CloseProtocol (
                    UdpIo->UdpHandle,
                    &gEfiUdp6ProtocolGuid,
                    UdpIo->Image,
                    UdpIo->Controller
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    Status = NetLibDestroyServiceChild (
               UdpIo->Controller,
               UdpIo->Image,
               &gEfiUdp6ServiceBindingProtocolGuid,
               UdpIo->UdpHandle
               );
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  if (!IsListEmpty (&UdpIo->Link)) {
    RemoveEntryList (&UdpIo->Link);
  }
 
  FreePool (UdpIo);
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
UdpIoCleanIo (
  IN  UDP_IO  *UdpIo
  )
{
  UDP_RX_TOKEN  *RxToken;
 
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  //
  // Cancel all the sent datagram and receive requests.
  //
  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);
 
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    if ((RxToken = UdpIo->RecvRequest) != NULL) {
      UdpIo->Protocol.Udp4->Cancel (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
    }
 
    UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, NULL);
  } else {
    if ((RxToken = UdpIo->RecvRequest) != NULL) {
      UdpIo->Protocol.Udp6->Cancel (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
    }
 
    UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, NULL);
  }
}
 
EFI_STATUS
EFIAPI
UdpIoSendDatagram (
  IN  UDP_IO           *UdpIo,
  IN  NET_BUF          *Packet,
  IN  UDP_END_POINT    *EndPoint OPTIONAL,
  IN  EFI_IP_ADDRESS   *Gateway  OPTIONAL,
  IN  UDP_IO_CALLBACK  CallBack,
  IN  VOID             *Context
  )
{
  UDP_TX_TOKEN  *TxToken;
  EFI_STATUS    Status;
 
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  TxToken = UdpIoCreateTxToken (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);
 
  if (TxToken == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Insert the tx token into SendDatagram list before transmitting it. Remove
  // it from the list if the returned status is not EFI_SUCCESS.
  //
  InsertHeadList (&UdpIo->SentDatagram, &TxToken->Link);
 
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    Status = UdpIo->Protocol.Udp4->Transmit (UdpIo->Protocol.Udp4, &TxToken->Token.Udp4);
  } else {
    Status = UdpIo->Protocol.Udp6->Transmit (UdpIo->Protocol.Udp6, &TxToken->Token.Udp6);
  }
 
  if (EFI_ERROR (Status)) {
    RemoveEntryList (&TxToken->Link);
    UdpIoFreeTxToken (TxToken);
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
EFIAPI
UdpIoCancelSingleDgram (
  IN UDP_TX_TOKEN  *Token,
  IN VOID          *Context
  )
{
  NET_BUF  *Packet;
 
  Packet = (NET_BUF *)Context;
 
  if (Token->Packet == Packet) {
    return TRUE;
  }
 
  return FALSE;
}
 
VOID
EFIAPI
UdpIoCancelSentDatagram (
  IN  UDP_IO   *UdpIo,
  IN  NET_BUF  *Packet
  )
{
  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);
}
 
EFI_STATUS
EFIAPI
UdpIoRecvDatagram (
  IN  UDP_IO           *UdpIo,
  IN  UDP_IO_CALLBACK  CallBack,
  IN  VOID             *Context,
  IN  UINT32           HeadLen
  )
{
  UDP_RX_TOKEN  *RxToken;
  EFI_STATUS    Status;
 
  ASSERT (
    (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) ||
    (UdpIo->UdpVersion == UDP_IO_UDP6_VERSION)
    );
 
  if (UdpIo->RecvRequest != NULL) {
    return EFI_ALREADY_STARTED;
  }
 
  RxToken = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);
 
  if (RxToken == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  UdpIo->RecvRequest = RxToken;
  if (UdpIo->UdpVersion == UDP_IO_UDP4_VERSION) {
    Status = UdpIo->Protocol.Udp4->Receive (UdpIo->Protocol.Udp4, &RxToken->Token.Udp4);
  } else {
    Status = UdpIo->Protocol.Udp6->Receive (UdpIo->Protocol.Udp6, &RxToken->Token.Udp6);
  }
 
  if (EFI_ERROR (Status)) {
    UdpIo->RecvRequest = NULL;
    UdpIoFreeRxToken (RxToken);
  }
 
  return Status;
}