[mirror_edk2.git] / MdeModulePkg / Library / DxeUdpIoLib / DxeUdpIoLib.c

/** @file\r
\r
Copyright (c) 2006 - 2007, 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
\r
Module Name:\r
\r
  Udp4Io.c\r
\r
Abstract:\r
\r
  Help functions to access UDP service, it is used by both the DHCP and MTFTP.\r
\r
\r
**/\r
\r
#include <PiDxe.h>\r
\r
#include <Protocol/Udp4.h>\r
\r
#include <Library/UdpIoLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/BaseMemoryLib.h>\r
\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramSentDpc (\r
  IN VOID                   *Context\r
  );\r
\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramSent (\r
  IN EFI_EVENT              Event,\r
  IN VOID                   *Context\r
  );\r
\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramRcvd (\r
  IN EFI_EVENT              Event,\r
  IN VOID                   *Context\r
  );\r
\r
\r
/**\r
  Wrap a transmit request into a UDP_TX_TOKEN.\r
\r
  @param  UdpIo                 The UdpIo port to send packet to\r
  @param  Packet                The user's packet\r
  @param  EndPoint              The local and remote access point\r
  @param  Gateway               The overrided next hop\r
  @param  CallBack              The function to call when transmission completed.\r
  @param  Context               The opaque parameter to the call back\r
\r
  @return The wrapped transmission request or NULL if failed to allocate resources.\r
\r
**/\r
STATIC\r
UDP_TX_TOKEN *\r
UdpIoWrapTx (\r
  IN UDP_IO_PORT            *UdpIo,\r
  IN NET_BUF                *Packet,\r
  IN UDP_POINTS             *EndPoint, OPTIONAL\r
  IN IP4_ADDR               Gateway,\r
  IN UDP_IO_CALLBACK        CallBack,\r
  IN VOID                   *Context\r
  )\r
{\r
  UDP_TX_TOKEN              *Token;\r
  EFI_UDP4_COMPLETION_TOKEN *UdpToken;\r
  EFI_UDP4_TRANSMIT_DATA    *UdpTxData;\r
  EFI_STATUS                Status;\r
  UINT32                    Count;\r
  IP4_ADDR                  Ip;\r
\r
  Token = AllocatePool (sizeof (UDP_TX_TOKEN) +\r
                           sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1));\r
\r
  if (Token == NULL) {\r
    return NULL;\r
  }\r
\r
  Token->Signature  = UDP_IO_TX_SIGNATURE;\r
  InitializeListHead (&Token->Link);\r
\r
  Token->UdpIo      = UdpIo;\r
  Token->CallBack   = CallBack;\r
  Token->Packet     = Packet;\r
  Token->Context    = Context;\r
\r
  UdpToken          = &(Token->UdpToken);\r
  UdpToken->Status  = EFI_NOT_READY;\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  UdpIoOnDgramSent,\r
                  Token,\r
                  &UdpToken->Event\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    gBS->FreePool (Token);\r
    return NULL;\r
  }\r
\r
  UdpTxData                 = &Token->UdpTxData;\r
  UdpToken->Packet.TxData   = UdpTxData;\r
\r
  UdpTxData->UdpSessionData = NULL;\r
  UdpTxData->GatewayAddress = NULL;\r
\r
  if (EndPoint != NULL) {\r
    Ip = HTONL (EndPoint->LocalAddr);\r
    CopyMem (&Token->UdpSession.SourceAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
    Ip = HTONL (EndPoint->RemoteAddr);\r
    CopyMem (&Token->UdpSession.DestinationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
    Token->UdpSession.SourcePort      = EndPoint->LocalPort;\r
    Token->UdpSession.DestinationPort = EndPoint->RemotePort;\r
    UdpTxData->UdpSessionData         = &Token->UdpSession;\r
  }\r
\r
  if (Gateway != 0) {\r
    Ip = HTONL (Gateway);\r
    CopyMem (&Token->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
\r
    UdpTxData->GatewayAddress = &Token->Gateway;\r
  }\r
\r
  UdpTxData->DataLength = Packet->TotalSize;\r
  Count                 = Packet->BlockOpNum;\r
  NetbufBuildExt (Packet, (NET_FRAGMENT *) UdpTxData->FragmentTable, &Count);\r
  UdpTxData->FragmentCount = Count;\r
\r
  return Token;\r
}\r
\r
\r
/**\r
  Free a UDP_TX_TOKEN. The event is closed and memory released.\r
\r
  @param  Token                 The UDP_TX_TOKEN to release.\r
\r
  @return None\r
\r
**/\r
VOID\r
UdpIoFreeTxToken (\r
  IN UDP_TX_TOKEN           *Token\r
  )\r
{\r
  gBS->CloseEvent (Token->UdpToken.Event);\r
  gBS->FreePool (Token);\r
}\r
\r
\r
/**\r
  Create a UDP_RX_TOKEN to wrap the request.\r
\r
  @param  UdpIo                 The UdpIo to receive packets from\r
  @param  CallBack              The function to call when receive finished.\r
  @param  Context               The opaque parameter to the CallBack\r
  @param  HeadLen               The head length to reserver for the packet.\r
\r
  @return The Wrapped request or NULL if failed to allocate resources.\r
\r
**/\r
UDP_RX_TOKEN *\r
UdpIoCreateRxToken (\r
  IN UDP_IO_PORT            *UdpIo,\r
  IN UDP_IO_CALLBACK        CallBack,\r
  IN VOID                   *Context,\r
  IN UINT32                 HeadLen\r
  )\r
{\r
  UDP_RX_TOKEN              *Token;\r
  EFI_STATUS                Status;\r
\r
  Token = AllocatePool (sizeof (UDP_RX_TOKEN));\r
\r
  if (Token == NULL) {\r
    return NULL;\r
  }\r
\r
  Token->Signature              = UDP_IO_RX_SIGNATURE;\r
  Token->UdpIo                  = UdpIo;\r
  Token->CallBack               = CallBack;\r
  Token->Context                = Context;\r
  Token->HeadLen                = HeadLen;\r
\r
  Token->UdpToken.Status        = EFI_NOT_READY;\r
  Token->UdpToken.Packet.RxData = NULL;\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  UdpIoOnDgramRcvd,\r
                  Token,\r
                  &Token->UdpToken.Event\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    gBS->FreePool (Token);\r
    return NULL;\r
  }\r
\r
  return Token;\r
}\r
\r
\r
/**\r
  Free a receive request wrap.\r
\r
  @param  Token                 The receive request to release.\r
\r
  @return None\r
\r
**/\r
VOID\r
UdpIoFreeRxToken (\r
  IN UDP_RX_TOKEN           *Token\r
  )\r
{\r
  gBS->CloseEvent (Token->UdpToken.Event);\r
  gBS->FreePool (Token);\r
}\r
\r
\r
/**\r
  Create a UDP IO port to access the UDP service. It will\r
  create and configure a UDP child.\r
\r
  @param  Controller            The controller that has the UDP service binding\r
                                protocol installed.\r
  @param  Image                 The image handle for the driver.\r
  @param  Configure             The function to configure the created UDP child\r
  @param  Context               The opaque parameter for the Configure funtion.\r
\r
  @return A point to just created UDP IO port or NULL if failed.\r
\r
**/\r
UDP_IO_PORT *\r
EFIAPI\r
UdpIoCreatePort (\r
  IN  EFI_HANDLE            Controller,\r
  IN  EFI_HANDLE            Image,\r
  IN  UDP_IO_CONFIG         Configure,\r
  IN  VOID                  *Context\r
  )\r
{\r
  UDP_IO_PORT               *UdpIo;\r
  EFI_STATUS                Status;\r
\r
  ASSERT (Configure != NULL);\r
\r
  UdpIo = AllocatePool (sizeof (UDP_IO_PORT));\r
\r
  if (UdpIo == NULL) {\r
    return NULL;\r
  }\r
\r
  UdpIo->Signature    = UDP_IO_SIGNATURE;\r
  InitializeListHead (&UdpIo->Link);\r
  UdpIo->RefCnt       = 1;\r
\r
  UdpIo->Controller   = Controller;\r
  UdpIo->Image        = Image;\r
\r
  InitializeListHead (&UdpIo->SentDatagram);\r
  UdpIo->RecvRequest  = NULL;\r
  UdpIo->UdpHandle    = NULL;\r
\r
  //\r
  // Create a UDP child then open and configure it\r
  //\r
  Status = NetLibCreateServiceChild (\r
             Controller,\r
             Image,\r
             &gEfiUdp4ServiceBindingProtocolGuid,\r
             &UdpIo->UdpHandle\r
             );\r
\r
  if (EFI_ERROR (Status)) {\r
    goto FREE_MEM;\r
  }\r
\r
  Status = gBS->OpenProtocol (\r
                  UdpIo->UdpHandle,\r
                  &gEfiUdp4ProtocolGuid,\r
                  (VOID **) &UdpIo->Udp,\r
                  Image,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    goto FREE_CHILD;\r
  }\r
\r
  if (EFI_ERROR (Configure (UdpIo, Context))) {\r
    goto CLOSE_PROTOCOL;\r
  }\r
\r
  Status = UdpIo->Udp->GetModeData (UdpIo->Udp, NULL, NULL, NULL, &UdpIo->SnpMode);\r
\r
  if (EFI_ERROR (Status)) {\r
    goto CLOSE_PROTOCOL;\r
  }\r
\r
  return UdpIo;\r
\r
CLOSE_PROTOCOL:\r
  gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, Image, Controller);\r
\r
FREE_CHILD:\r
  NetLibDestroyServiceChild (\r
    Controller,\r
    Image,\r
    &gEfiUdp4ServiceBindingProtocolGuid,\r
    UdpIo->UdpHandle\r
    );\r
\r
FREE_MEM:\r
  gBS->FreePool (UdpIo);\r
  return NULL;\r
}\r
\r
\r
/**\r
  Cancel all the sent datagram that pass the selection of ToCancel.\r
  If ToCancel is NULL, all the datagrams are cancelled.\r
\r
  @param  UdpIo                 The UDP IO port to cancel packet\r
  @param  IoStatus              The IoStatus to return to the packet owners.\r
  @param  ToCancel              The select funtion to test whether to cancel this\r
                                packet or not.\r
  @param  Context               The opaque parameter to the ToCancel.\r
\r
  @return None\r
\r
**/\r
STATIC\r
VOID\r
UdpIoCancelDgrams (\r
  IN UDP_IO_PORT            *UdpIo,\r
  IN EFI_STATUS             IoStatus,\r
  IN UDP_IO_TO_CANCEL       ToCancel,        OPTIONAL\r
  IN VOID                   *Context\r
  )\r
{\r
  LIST_ENTRY                *Entry;\r
  LIST_ENTRY                *Next;\r
  UDP_TX_TOKEN              *Token;\r
\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {\r
    Token = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);\r
\r
    if ((ToCancel == NULL) || (ToCancel (Token, Context))) {\r
      UdpIo->Udp->Cancel (UdpIo->Udp, &Token->UdpToken);\r
    }\r
  }\r
}\r
\r
\r
/**\r
  Free the UDP IO port and all its related resources including\r
  all the transmitted packet.\r
\r
  @param  UdpIo                 The UDP IO port to free.\r
\r
  @retval EFI_SUCCESS           The UDP IO port is freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
UdpIoFreePort (\r
  IN  UDP_IO_PORT           *UdpIo\r
  )\r
{\r
  UDP_RX_TOKEN  *RxToken;\r
\r
  //\r
  // Cancel all the sent datagram and receive requests. The\r
  // callbacks of transmit requests are executed to allow the\r
  // caller to release the resource. The callback of receive\r
  // request are NOT executed. This is because it is most\r
  // likely that the current user of the UDP IO port is closing\r
  // itself.\r
  //\r
  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
\r
  if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
    UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);\r
  }\r
\r
  //\r
  // Close then destory the UDP child\r
  //\r
  gBS->CloseProtocol (\r
         UdpIo->UdpHandle,\r
         &gEfiUdp4ProtocolGuid,\r
         UdpIo->Image,\r
         UdpIo->Controller\r
         );\r
\r
  NetLibDestroyServiceChild (\r
    UdpIo->Controller,\r
    UdpIo->Image,\r
    &gEfiUdp4ServiceBindingProtocolGuid,\r
    UdpIo->UdpHandle\r
    );\r
\r
  if (!IsListEmpty(&UdpIo->Link)) {\r
    RemoveEntryList (&UdpIo->Link);\r
  }\r
\r
  gBS->FreePool (UdpIo);\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Clean up the UDP IO port. It will release all the transmitted\r
  datagrams and receive request. It will also configure NULL the\r
  UDP child.\r
\r
  @param  UdpIo                 UDP IO port to clean up.\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
UdpIoCleanPort (\r
  IN  UDP_IO_PORT           *UdpIo\r
  )\r
{\r
  UDP_RX_TOKEN              *RxToken;\r
\r
  //\r
  // Cancel all the sent datagram and receive requests.\r
  //\r
  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
\r
  if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
    UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);\r
  }\r
\r
  UdpIo->Udp->Configure (UdpIo->Udp, NULL);\r
}\r
\r
\r
/**\r
  The callback function when the packet is sent by UDP.\r
  It will remove the packet from the local list then call\r
  the packet owner's callback function.\r
\r
  @param  Context               The UDP TX Token.\r
\r
  @return None\r
\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramSentDpc (\r
  IN VOID                   *Context\r
  )\r
{\r
  UDP_TX_TOKEN              *Token;\r
\r
  Token   = (UDP_TX_TOKEN *) Context;\r
  ASSERT (Token->Signature == UDP_IO_TX_SIGNATURE);\r
\r
  RemoveEntryList (&Token->Link);\r
  Token->CallBack (Token->Packet, NULL, Token->UdpToken.Status, Token->Context);\r
\r
  UdpIoFreeTxToken (Token);\r
}\r
\r
/**\r
  Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK.\r
\r
  @param  Event                 The event signalled.\r
  @param  Context               The UDP TX Token.\r
\r
  @return None\r
\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramSent (\r
  IN EFI_EVENT              Event,\r
  IN VOID                   *Context\r
  )\r
{\r
  //\r
  // Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK\r
  //\r
  NetLibQueueDpc (TPL_CALLBACK, UdpIoOnDgramSentDpc, Context);\r
}\r
\r
\r
/**\r
  Send a packet through the UDP IO port.\r
\r
  @param  UdpIo                 The UDP IO Port to send the packet through\r
  @param  Packet                The packet to send\r
  @param  EndPoint              The local and remote access point\r
  @param  Gateway               The gateway to use\r
  @param  CallBack              The call back function to call when packet is\r
                                transmitted or failed.\r
  @param  Context               The opque parameter to the CallBack\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for the packet\r
  @retval EFI_SUCCESS           The packet is successfully delivered to UDP  for\r
                                transmission.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
UdpIoSendDatagram (\r
  IN  UDP_IO_PORT           *UdpIo,\r
  IN  NET_BUF               *Packet,\r
  IN  UDP_POINTS            *EndPoint, OPTIONAL\r
  IN  IP4_ADDR              Gateway,\r
  IN  UDP_IO_CALLBACK       CallBack,\r
  IN  VOID                  *Context\r
  )\r
{\r
  UDP_TX_TOKEN              *Token;\r
  EFI_STATUS                Status;\r
\r
  Token = UdpIoWrapTx (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);\r
\r
  if (Token == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Insert the tx token into SendDatagram list before transmitting it. Remove\r
  // it from the list if the returned status is not EFI_SUCCESS.\r
  //\r
  InsertHeadList (&UdpIo->SentDatagram, &Token->Link);\r
  Status = UdpIo->Udp->Transmit (UdpIo->Udp, &Token->UdpToken);\r
  if (EFI_ERROR (Status)) {\r
    RemoveEntryList (&Token->Link);\r
    UdpIoFreeTxToken (Token);\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  The selection function to cancel a single sent datagram.\r
\r
  @param  Token                 The UDP TX token to test againist.\r
  @param  Context               The context\r
\r
  @return TRUE if the packet is to be cancelled, otherwise FALSE.\r
\r
**/\r
STATIC\r
BOOLEAN\r
UdpIoCancelSingleDgram (\r
  IN UDP_TX_TOKEN           *Token,\r
  IN VOID                   *Context\r
  )\r
{\r
  NET_BUF                   *Packet;\r
\r
  Packet = (NET_BUF *) Context;\r
\r
  if (Token->Packet == Packet) {\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
\r
/**\r
  Cancel a single sent datagram.\r
\r
  @param  UdpIo                 The UDP IO port to cancel the packet from\r
  @param  Packet                The packet to cancel\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
UdpIoCancelSentDatagram (\r
  IN  UDP_IO_PORT           *UdpIo,\r
  IN  NET_BUF               *Packet\r
  )\r
{\r
  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);\r
}\r
\r
\r
/**\r
  Recycle the received UDP data.\r
\r
  @param  Context               The UDP_RX_TOKEN\r
\r
  @return None\r
\r
**/\r
STATIC\r
VOID\r
UdpIoRecycleDgram (\r
  IN VOID                   *Context\r
  )\r
{\r
  UDP_RX_TOKEN              *Token;\r
\r
  Token = (UDP_RX_TOKEN *) Context;\r
  gBS->SignalEvent (Token->UdpToken.Packet.RxData->RecycleSignal);\r
  UdpIoFreeRxToken (Token);\r
}\r
\r
/**\r
  The event handle for UDP receive request. It will build\r
  a NET_BUF from the recieved UDP data, then deliver it\r
  to the receiver.\r
\r
  @param  Context               The UDP RX token.\r
\r
  @return None\r
\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramRcvdDpc (\r
  IN VOID                   *Context\r
  )\r
{\r
  EFI_UDP4_COMPLETION_TOKEN *UdpToken;\r
  EFI_UDP4_RECEIVE_DATA     *UdpRxData;\r
  EFI_UDP4_SESSION_DATA     *UdpSession;\r
  UDP_RX_TOKEN              *Token;\r
  UDP_POINTS                Points;\r
  NET_BUF                   *Netbuf;\r
\r
  Token   = (UDP_RX_TOKEN *) Context;\r
\r
  ASSERT ((Token->Signature == UDP_IO_RX_SIGNATURE) &&\r
          (Token == Token->UdpIo->RecvRequest));\r
\r
  //\r
  // Clear the receive request first in case that the caller\r
  // wants to restart the receive in the callback.\r
  //\r
  Token->UdpIo->RecvRequest = NULL;\r
\r
  UdpToken  = &Token->UdpToken;\r
  UdpRxData = UdpToken->Packet.RxData;\r
\r
  if (EFI_ERROR (UdpToken->Status) || (UdpRxData == NULL)) {\r
    if (UdpToken->Status != EFI_ABORTED) {\r
      //\r
      // Invoke the CallBack only if the reception is not actively aborted.\r
      //\r
      Token->CallBack (NULL, NULL, UdpToken->Status, Token->Context);\r
    }\r
\r
    UdpIoFreeRxToken (Token);\r
    return;\r
  }\r
\r
  //\r
  // Build a NET_BUF from the UDP receive data, then deliver it up.\r
  //\r
  Netbuf = NetbufFromExt (\r
             (NET_FRAGMENT *) UdpRxData->FragmentTable,\r
             UdpRxData->FragmentCount,\r
             0,\r
             (UINT32) Token->HeadLen,\r
             UdpIoRecycleDgram,\r
             Token\r
             );\r
\r
  if (Netbuf == NULL) {\r
    gBS->SignalEvent (UdpRxData->RecycleSignal);\r
    Token->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, Token->Context);\r
\r
    UdpIoFreeRxToken (Token);\r
    return;\r
  }\r
\r
  UdpSession        = &UdpRxData->UdpSession;\r
  Points.LocalPort  = UdpSession->DestinationPort;\r
  Points.RemotePort = UdpSession->SourcePort;\r
\r
  CopyMem (&Points.LocalAddr, &UdpSession->DestinationAddress, sizeof (IP4_ADDR));\r
  CopyMem (&Points.RemoteAddr, &UdpSession->SourceAddress, sizeof (IP4_ADDR));\r
  Points.LocalAddr  = NTOHL (Points.LocalAddr);\r
  Points.RemoteAddr = NTOHL (Points.RemoteAddr);\r
\r
  Token->CallBack (Netbuf, &Points, EFI_SUCCESS, Token->Context);\r
}\r
\r
/**\r
  Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK.\r
\r
  @param  Event                 The UDP receive request event.\r
  @param  Context               The UDP RX token.\r
\r
  @return None\r
\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
UdpIoOnDgramRcvd (\r
  IN EFI_EVENT              Event,\r
  IN VOID                   *Context\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK\r
\r
Arguments:\r
\r
  Event   - The UDP receive request event\r
  Context - The UDP RX token.\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  //\r
  // Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK\r
  //\r
  NetLibQueueDpc (TPL_CALLBACK, UdpIoOnDgramRcvdDpc, Context);\r
}\r
\r
\r
/**\r
  Issue a receive request to the UDP IO port.\r
\r
  @param  UdpIo                 The UDP IO port to recieve the packet from.\r
  @param  CallBack              The call back function to execute when receive\r
                                finished.\r
  @param  Context               The opque context to the call back\r
  @param  HeadLen               The lenght of the application's header\r
\r
  @retval EFI_ALREADY_STARTED   There is already a pending receive request. Only\r
                                one receive request is supported.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate some resource.\r
  @retval EFI_SUCCESS           The receive request is issued successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
UdpIoRecvDatagram (\r
  IN  UDP_IO_PORT           *UdpIo,\r
  IN  UDP_IO_CALLBACK       CallBack,\r
  IN  VOID                  *Context,\r
  IN  UINT32                HeadLen\r
  )\r
{\r
  UDP_RX_TOKEN              *Token;\r
  EFI_STATUS                Status;\r
\r
  if (UdpIo->RecvRequest != NULL) {\r
    return EFI_ALREADY_STARTED;\r
  }\r
\r
  Token = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);\r
\r
  if (Token == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  UdpIo->RecvRequest = Token;\r
  Status = UdpIo->Udp->Receive (UdpIo->Udp, &Token->UdpToken);\r
\r
  if (EFI_ERROR (Status)) {\r
    UdpIo->RecvRequest = NULL;\r
    UdpIoFreeRxToken (Token);\r
  }\r
\r
  return Status;\r
}\r
Commit	Line	Data
cbf316f2	1	/** @file\r
	2	\r
	3	Copyright (c) 2006 - 2007, Intel Corporation\r
	4	All rights reserved. This program and the accompanying materials\r
	5	are licensed and made available under the terms and conditions of the BSD License\r
	6	which accompanies this distribution. The full text of the license may be found at\r
	7	http://opensource.org/licenses/bsd-license.php\r
	8	\r
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	11	\r
	12	\r
	13	Module Name:\r
	14	\r
	15	Udp4Io.c\r
	16	\r
	17	Abstract:\r
	18	\r
	19	Help functions to access UDP service, it is used by both the DHCP and MTFTP.\r
	20	\r
	21	\r
	22	**/\r
	23	\r
	24	#include <PiDxe.h>\r
	25	\r
	26	#include <Protocol/Udp4.h>\r
	27	\r
	28	#include <Library/UdpIoLib.h>\r
	29	#include <Library/BaseLib.h>\r
	30	#include <Library/DebugLib.h>\r
	31	#include <Library/UefiBootServicesTableLib.h>\r
	32	#include <Library/MemoryAllocationLib.h>\r
ba0f75a3	33	#include <Library/BaseMemoryLib.h>\r
cbf316f2	34	\r
36ee91ca	35	STATIC\r
	36	VOID\r
	37	EFIAPI\r
	38	UdpIoOnDgramSentDpc (\r
	39	IN VOID *Context\r
	40	);\r
	41	\r
cbf316f2	42	STATIC\r
	43	VOID\r
	44	EFIAPI\r
	45	UdpIoOnDgramSent (\r
	46	IN EFI_EVENT Event,\r
	47	IN VOID *Context\r
	48	);\r
	49	\r
	50	STATIC\r
	51	VOID\r
	52	EFIAPI\r
	53	UdpIoOnDgramRcvd (\r
	54	IN EFI_EVENT Event,\r
	55	IN VOID *Context\r
	56	);\r
	57	\r
	58	\r
	59	/**\r
	60	Wrap a transmit request into a UDP_TX_TOKEN.\r
	61	\r
	62	@param UdpIo The UdpIo port to send packet to\r
	63	@param Packet The user's packet\r
	64	@param EndPoint The local and remote access point\r
	65	@param Gateway The overrided next hop\r
	66	@param CallBack The function to call when transmission completed.\r
	67	@param Context The opaque parameter to the call back\r
	68	\r
	69	@return The wrapped transmission request or NULL if failed to allocate resources.\r
	70	\r
	71	**/\r
	72	STATIC\r
	73	UDP_TX_TOKEN *\r
	74	UdpIoWrapTx (\r
	75	IN UDP_IO_PORT *UdpIo,\r
	76	IN NET_BUF *Packet,\r
	77	IN UDP_POINTS *EndPoint, OPTIONAL\r
	78	IN IP4_ADDR Gateway,\r
	79	IN UDP_IO_CALLBACK CallBack,\r
	80	IN VOID *Context\r
	81	)\r
	82	{\r
	83	UDP_TX_TOKEN *Token;\r
	84	EFI_UDP4_COMPLETION_TOKEN *UdpToken;\r
	85	EFI_UDP4_TRANSMIT_DATA *UdpTxData;\r
	86	EFI_STATUS Status;\r
	87	UINT32 Count;\r
b61439a7	88	IP4_ADDR Ip;\r
cbf316f2	89	\r
e48e37fc	90	Token = AllocatePool (sizeof (UDP_TX_TOKEN) +\r
cbf316f2	91	sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1));\r
	92	\r
	93	if (Token == NULL) {\r
	94	return NULL;\r
	95	}\r
	96	\r
	97	Token->Signature = UDP_IO_TX_SIGNATURE;\r
e48e37fc	98	InitializeListHead (&Token->Link);\r
cbf316f2	99	\r
	100	Token->UdpIo = UdpIo;\r
	101	Token->CallBack = CallBack;\r
	102	Token->Packet = Packet;\r
	103	Token->Context = Context;\r
	104	\r
	105	UdpToken = &(Token->UdpToken);\r
	106	UdpToken->Status = EFI_NOT_READY;\r
	107	\r
	108	Status = gBS->CreateEvent (\r
	109	EVT_NOTIFY_SIGNAL,\r
e48e37fc	110	TPL_NOTIFY,\r
cbf316f2	111	UdpIoOnDgramSent,\r
	112	Token,\r
	113	&UdpToken->Event\r
	114	);\r
	115	\r
	116	if (EFI_ERROR (Status)) {\r
e48e37fc	117	gBS->FreePool (Token);\r
cbf316f2	118	return NULL;\r
	119	}\r
	120	\r
	121	UdpTxData = &Token->UdpTxData;\r
	122	UdpToken->Packet.TxData = UdpTxData;\r
	123	\r
	124	UdpTxData->UdpSessionData = NULL;\r
	125	UdpTxData->GatewayAddress = NULL;\r
	126	\r
	127	if (EndPoint != NULL) {\r
b61439a7	128	Ip = HTONL (EndPoint->LocalAddr);\r
e48e37fc	129	CopyMem (&Token->UdpSession.SourceAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
b61439a7	130	\r
b61439a7	131	Ip = HTONL (EndPoint->RemoteAddr);\r
e48e37fc	132	CopyMem (&Token->UdpSession.DestinationAddress, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
b61439a7	133	\r
	134	Token->UdpSession.SourcePort = EndPoint->LocalPort;\r
	135	Token->UdpSession.DestinationPort = EndPoint->RemotePort;\r
	136	UdpTxData->UdpSessionData = &Token->UdpSession;\r
cbf316f2	137	}\r
	138	\r
	139	if (Gateway != 0) {\r
b61439a7	140	Ip = HTONL (Gateway);\r
e48e37fc	141	CopyMem (&Token->Gateway, &Ip, sizeof (EFI_IPv4_ADDRESS));\r
b61439a7	142	\r
cbf316f2	143	UdpTxData->GatewayAddress = &Token->Gateway;\r
	144	}\r
	145	\r
	146	UdpTxData->DataLength = Packet->TotalSize;\r
	147	Count = Packet->BlockOpNum;\r
	148	NetbufBuildExt (Packet, (NET_FRAGMENT *) UdpTxData->FragmentTable, &Count);\r
	149	UdpTxData->FragmentCount = Count;\r
	150	\r
	151	return Token;\r
	152	}\r
	153	\r
	154	\r
	155	/**\r
	156	Free a UDP_TX_TOKEN. The event is closed and memory released.\r
	157	\r
	158	@param Token The UDP_TX_TOKEN to release.\r
	159	\r
	160	@return None\r
	161	\r
	162	**/\r
	163	VOID\r
	164	UdpIoFreeTxToken (\r
	165	IN UDP_TX_TOKEN *Token\r
	166	)\r
	167	{\r
	168	gBS->CloseEvent (Token->UdpToken.Event);\r
e48e37fc	169	gBS->FreePool (Token);\r
cbf316f2	170	}\r
	171	\r
	172	\r
	173	/**\r
	174	Create a UDP_RX_TOKEN to wrap the request.\r
	175	\r
	176	@param UdpIo The UdpIo to receive packets from\r
	177	@param CallBack The function to call when receive finished.\r
	178	@param Context The opaque parameter to the CallBack\r
	179	@param HeadLen The head length to reserver for the packet.\r
	180	\r
	181	@return The Wrapped request or NULL if failed to allocate resources.\r
	182	\r
	183	**/\r
	184	UDP_RX_TOKEN *\r
	185	UdpIoCreateRxToken (\r
	186	IN UDP_IO_PORT *UdpIo,\r
	187	IN UDP_IO_CALLBACK CallBack,\r
	188	IN VOID *Context,\r
	189	IN UINT32 HeadLen\r
	190	)\r
	191	{\r
	192	UDP_RX_TOKEN *Token;\r
	193	EFI_STATUS Status;\r
	194	\r
e48e37fc	195	Token = AllocatePool (sizeof (UDP_RX_TOKEN));\r
cbf316f2	196	\r
	197	if (Token == NULL) {\r
	198	return NULL;\r
	199	}\r
	200	\r
	201	Token->Signature = UDP_IO_RX_SIGNATURE;\r
	202	Token->UdpIo = UdpIo;\r
	203	Token->CallBack = CallBack;\r
	204	Token->Context = Context;\r
	205	Token->HeadLen = HeadLen;\r
	206	\r
	207	Token->UdpToken.Status = EFI_NOT_READY;\r
	208	Token->UdpToken.Packet.RxData = NULL;\r
	209	\r
	210	Status = gBS->CreateEvent (\r
	211	EVT_NOTIFY_SIGNAL,\r
e48e37fc	212	TPL_NOTIFY,\r
cbf316f2	213	UdpIoOnDgramRcvd,\r
	214	Token,\r
	215	&Token->UdpToken.Event\r
	216	);\r
	217	\r
	218	if (EFI_ERROR (Status)) {\r
e48e37fc	219	gBS->FreePool (Token);\r
cbf316f2	220	return NULL;\r
	221	}\r
	222	\r
	223	return Token;\r
	224	}\r
	225	\r
	226	\r
	227	/**\r
	228	Free a receive request wrap.\r
	229	\r
	230	@param Token The receive request to release.\r
	231	\r
	232	@return None\r
	233	\r
	234	**/\r
	235	VOID\r
	236	UdpIoFreeRxToken (\r
	237	IN UDP_RX_TOKEN *Token\r
	238	)\r
	239	{\r
	240	gBS->CloseEvent (Token->UdpToken.Event);\r
e48e37fc	241	gBS->FreePool (Token);\r
cbf316f2	242	}\r
	243	\r
	244	\r
	245	/**\r
	246	Create a UDP IO port to access the UDP service. It will\r
	247	create and configure a UDP child.\r
	248	\r
	249	@param Controller The controller that has the UDP service binding\r
	250	protocol installed.\r
	251	@param Image The image handle for the driver.\r
	252	@param Configure The function to configure the created UDP child\r
	253	@param Context The opaque parameter for the Configure funtion.\r
	254	\r
	255	@return A point to just created UDP IO port or NULL if failed.\r
	256	\r
	257	**/\r
	258	UDP_IO_PORT *\r
7b414b4e	259	EFIAPI\r
cbf316f2	260	UdpIoCreatePort (\r
	261	IN EFI_HANDLE Controller,\r
	262	IN EFI_HANDLE Image,\r
	263	IN UDP_IO_CONFIG Configure,\r
	264	IN VOID *Context\r
	265	)\r
	266	{\r
	267	UDP_IO_PORT *UdpIo;\r
	268	EFI_STATUS Status;\r
	269	\r
	270	ASSERT (Configure != NULL);\r
	271	\r
e48e37fc	272	UdpIo = AllocatePool (sizeof (UDP_IO_PORT));\r
cbf316f2	273	\r
	274	if (UdpIo == NULL) {\r
	275	return NULL;\r
	276	}\r
	277	\r
	278	UdpIo->Signature = UDP_IO_SIGNATURE;\r
e48e37fc	279	InitializeListHead (&UdpIo->Link);\r
cbf316f2	280	UdpIo->RefCnt = 1;\r
	281	\r
	282	UdpIo->Controller = Controller;\r
	283	UdpIo->Image = Image;\r
	284	\r
e48e37fc	285	InitializeListHead (&UdpIo->SentDatagram);\r
cbf316f2	286	UdpIo->RecvRequest = NULL;\r
	287	UdpIo->UdpHandle = NULL;\r
	288	\r
	289	//\r
	290	// Create a UDP child then open and configure it\r
	291	//\r
	292	Status = NetLibCreateServiceChild (\r
	293	Controller,\r
	294	Image,\r
	295	&gEfiUdp4ServiceBindingProtocolGuid,\r
	296	&UdpIo->UdpHandle\r
	297	);\r
	298	\r
	299	if (EFI_ERROR (Status)) {\r
	300	goto FREE_MEM;\r
	301	}\r
	302	\r
	303	Status = gBS->OpenProtocol (\r
	304	UdpIo->UdpHandle,\r
	305	&gEfiUdp4ProtocolGuid,\r
4eb65aff	306	(VOID **) &UdpIo->Udp,\r
cbf316f2	307	Image,\r
	308	Controller,\r
	309	EFI_OPEN_PROTOCOL_BY_DRIVER\r
	310	);\r
	311	\r
	312	if (EFI_ERROR (Status)) {\r
	313	goto FREE_CHILD;\r
	314	}\r
	315	\r
	316	if (EFI_ERROR (Configure (UdpIo, Context))) {\r
	317	goto CLOSE_PROTOCOL;\r
	318	}\r
	319	\r
	320	Status = UdpIo->Udp->GetModeData (UdpIo->Udp, NULL, NULL, NULL, &UdpIo->SnpMode);\r
	321	\r
	322	if (EFI_ERROR (Status)) {\r
	323	goto CLOSE_PROTOCOL;\r
	324	}\r
	325	\r
	326	return UdpIo;\r
	327	\r
	328	CLOSE_PROTOCOL:\r
	329	gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, Image, Controller);\r
	330	\r
	331	FREE_CHILD:\r
	332	NetLibDestroyServiceChild (\r
	333	Controller,\r
	334	Image,\r
	335	&gEfiUdp4ServiceBindingProtocolGuid,\r
	336	UdpIo->UdpHandle\r
	337	);\r
	338	\r
	339	FREE_MEM:\r
e48e37fc	340	gBS->FreePool (UdpIo);\r
cbf316f2	341	return NULL;\r
	342	}\r
	343	\r
	344	\r
	345	/**\r
	346	Cancel all the sent datagram that pass the selection of ToCancel.\r
	347	If ToCancel is NULL, all the datagrams are cancelled.\r
	348	\r
	349	@param UdpIo The UDP IO port to cancel packet\r
	350	@param IoStatus The IoStatus to return to the packet owners.\r
	351	@param ToCancel The select funtion to test whether to cancel this\r
	352	packet or not.\r
	353	@param Context The opaque parameter to the ToCancel.\r
	354	\r
	355	@return None\r
	356	\r
	357	**/\r
	358	STATIC\r
	359	VOID\r
	360	UdpIoCancelDgrams (\r
	361	IN UDP_IO_PORT *UdpIo,\r
	362	IN EFI_STATUS IoStatus,\r
	363	IN UDP_IO_TO_CANCEL ToCancel, OPTIONAL\r
	364	IN VOID *Context\r
	365	)\r
	366	{\r
e48e37fc	367	LIST_ENTRY *Entry;\r
e48e37fc	368	LIST_ENTRY *Next;\r
cbf316f2	369	UDP_TX_TOKEN *Token;\r
	370	\r
	371	NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {\r
	372	Token = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);\r
	373	\r
	374	if ((ToCancel == NULL) \|\| (ToCancel (Token, Context))) {\r
cbf316f2	375	UdpIo->Udp->Cancel (UdpIo->Udp, &Token->UdpToken);\r
cbf316f2	376	}\r
	377	}\r
	378	}\r
	379	\r
	380	\r
	381	/**\r
	382	Free the UDP IO port and all its related resources including\r
	383	all the transmitted packet.\r
	384	\r
	385	@param UdpIo The UDP IO port to free.\r
	386	\r
	387	@retval EFI_SUCCESS The UDP IO port is freed.\r
	388	\r
	389	**/\r
	390	EFI_STATUS\r
7b414b4e	391	EFIAPI\r
cbf316f2	392	UdpIoFreePort (\r
	393	IN UDP_IO_PORT *UdpIo\r
	394	)\r
	395	{\r
	396	UDP_RX_TOKEN *RxToken;\r
	397	\r
	398	//\r
	399	// Cancel all the sent datagram and receive requests. The\r
	400	// callbacks of transmit requests are executed to allow the\r
	401	// caller to release the resource. The callback of receive\r
	402	// request are NOT executed. This is because it is most\r
	403	// likely that the current user of the UDP IO port is closing\r
	404	// itself.\r
	405	//\r
	406	UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
	407	\r
	408	if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
cbf316f2	409	UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);\r
cbf316f2	410	}\r
	411	\r
	412	//\r
	413	// Close then destory the UDP child\r
	414	//\r
	415	gBS->CloseProtocol (\r
	416	UdpIo->UdpHandle,\r
	417	&gEfiUdp4ProtocolGuid,\r
	418	UdpIo->Image,\r
	419	UdpIo->Controller\r
	420	);\r
	421	\r
	422	NetLibDestroyServiceChild (\r
	423	UdpIo->Controller,\r
	424	UdpIo->Image,\r
	425	&gEfiUdp4ServiceBindingProtocolGuid,\r
	426	UdpIo->UdpHandle\r
	427	);\r
	428	\r
687a2e5f	429	if (!IsListEmpty(&UdpIo->Link)) {\r
e48e37fc	430	RemoveEntryList (&UdpIo->Link);\r
687a2e5f	431	}\r
687a2e5f	432	\r
e48e37fc	433	gBS->FreePool (UdpIo);\r
cbf316f2	434	return EFI_SUCCESS;\r
	435	}\r
	436	\r
	437	\r
	438	/**\r
	439	Clean up the UDP IO port. It will release all the transmitted\r
	440	datagrams and receive request. It will also configure NULL the\r
	441	UDP child.\r
	442	\r
	443	@param UdpIo UDP IO port to clean up.\r
	444	\r
	445	@return None\r
	446	\r
	447	**/\r
	448	VOID\r
7b414b4e	449	EFIAPI\r
cbf316f2	450	UdpIoCleanPort (\r
	451	IN UDP_IO_PORT *UdpIo\r
	452	)\r
	453	{\r
	454	UDP_RX_TOKEN *RxToken;\r
	455	\r
	456	//\r
	457	// Cancel all the sent datagram and receive requests.\r
	458	//\r
	459	UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
	460	\r
	461	if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
cbf316f2	462	UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);\r
cbf316f2	463	}\r
	464	\r
	465	UdpIo->Udp->Configure (UdpIo->Udp, NULL);\r
	466	}\r
	467	\r
	468	\r
	469	/**\r
	470	The callback function when the packet is sent by UDP.\r
	471	It will remove the packet from the local list then call\r
	472	the packet owner's callback function.\r
	473	\r
cbf316f2	474	@param Context The UDP TX Token.\r
	475	\r
	476	@return None\r
	477	\r
	478	**/\r
	479	STATIC\r
	480	VOID\r
	481	EFIAPI\r
36ee91ca	482	UdpIoOnDgramSentDpc (\r
cbf316f2	483	IN VOID *Context\r
	484	)\r
	485	{\r
	486	UDP_TX_TOKEN *Token;\r
	487	\r
	488	Token = (UDP_TX_TOKEN *) Context;\r
	489	ASSERT (Token->Signature == UDP_IO_TX_SIGNATURE);\r
	490	\r
e48e37fc	491	RemoveEntryList (&Token->Link);\r
cbf316f2	492	Token->CallBack (Token->Packet, NULL, Token->UdpToken.Status, Token->Context);\r
	493	\r
	494	UdpIoFreeTxToken (Token);\r
	495	}\r
	496	\r
36ee91ca	497	/**\r
	498	Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK.\r
	499	\r
	500	@param Event The event signalled.\r
	501	@param Context The UDP TX Token.\r
	502	\r
	503	@return None\r
	504	\r
	505	**/\r
	506	STATIC\r
	507	VOID\r
	508	EFIAPI\r
	509	UdpIoOnDgramSent (\r
	510	IN EFI_EVENT Event,\r
	511	IN VOID *Context\r
	512	)\r
	513	{\r
	514	//\r
	515	// Request UdpIoOnDgramSentDpc as a DPC at TPL_CALLBACK\r
	516	//\r
	517	NetLibQueueDpc (TPL_CALLBACK, UdpIoOnDgramSentDpc, Context);\r
	518	}\r
	519	\r
cbf316f2	520	\r
	521	/**\r
	522	Send a packet through the UDP IO port.\r
	523	\r
	524	@param UdpIo The UDP IO Port to send the packet through\r
	525	@param Packet The packet to send\r
	526	@param EndPoint The local and remote access point\r
	527	@param Gateway The gateway to use\r
	528	@param CallBack The call back function to call when packet is\r
	529	transmitted or failed.\r
	530	@param Context The opque parameter to the CallBack\r
	531	\r
	532	@retval EFI_OUT_OF_RESOURCES Failed to allocate resource for the packet\r
	533	@retval EFI_SUCCESS The packet is successfully delivered to UDP for\r
	534	transmission.\r
	535	\r
	536	**/\r
	537	EFI_STATUS\r
7b414b4e	538	EFIAPI\r
cbf316f2	539	UdpIoSendDatagram (\r
	540	IN UDP_IO_PORT *UdpIo,\r
	541	IN NET_BUF *Packet,\r
	542	IN UDP_POINTS *EndPoint, OPTIONAL\r
	543	IN IP4_ADDR Gateway,\r
	544	IN UDP_IO_CALLBACK CallBack,\r
	545	IN VOID *Context\r
	546	)\r
	547	{\r
	548	UDP_TX_TOKEN *Token;\r
	549	EFI_STATUS Status;\r
	550	\r
	551	Token = UdpIoWrapTx (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);\r
	552	\r
	553	if (Token == NULL) {\r
	554	return EFI_OUT_OF_RESOURCES;\r
	555	}\r
	556	\r
36ee91ca	557	//\r
	558	// Insert the tx token into SendDatagram list before transmitting it. Remove\r
	559	// it from the list if the returned status is not EFI_SUCCESS.\r
	560	//\r
e48e37fc	561	InsertHeadList (&UdpIo->SentDatagram, &Token->Link);\r
cbf316f2	562	Status = UdpIo->Udp->Transmit (UdpIo->Udp, &Token->UdpToken);\r
cbf316f2	563	if (EFI_ERROR (Status)) {\r
e48e37fc	564	RemoveEntryList (&Token->Link);\r
cbf316f2	565	UdpIoFreeTxToken (Token);\r
	566	return Status;\r
	567	}\r
	568	\r
cbf316f2	569	return EFI_SUCCESS;\r
	570	}\r
	571	\r
	572	\r
	573	/**\r
	574	The selection function to cancel a single sent datagram.\r
	575	\r
	576	@param Token The UDP TX token to test againist.\r
	577	@param Context The context\r
	578	\r
	579	@return TRUE if the packet is to be cancelled, otherwise FALSE.\r
	580	\r
	581	**/\r
	582	STATIC\r
	583	BOOLEAN\r
	584	UdpIoCancelSingleDgram (\r
	585	IN UDP_TX_TOKEN *Token,\r
	586	IN VOID *Context\r
	587	)\r
	588	{\r
	589	NET_BUF *Packet;\r
	590	\r
	591	Packet = (NET_BUF *) Context;\r
	592	\r
	593	if (Token->Packet == Packet) {\r
	594	return TRUE;\r
	595	}\r
	596	\r
	597	return FALSE;\r
	598	}\r
	599	\r
	600	\r
	601	/**\r
	602	Cancel a single sent datagram.\r
	603	\r
	604	@param UdpIo The UDP IO port to cancel the packet from\r
	605	@param Packet The packet to cancel\r
	606	\r
	607	@return None\r
	608	\r
	609	**/\r
	610	VOID\r
7b414b4e	611	EFIAPI\r
cbf316f2	612	UdpIoCancelSentDatagram (\r
	613	IN UDP_IO_PORT *UdpIo,\r
	614	IN NET_BUF *Packet\r
	615	)\r
	616	{\r
	617	UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);\r
	618	}\r
	619	\r
	620	\r
	621	/**\r
	622	Recycle the received UDP data.\r
	623	\r
	624	@param Context The UDP_RX_TOKEN\r
	625	\r
	626	@return None\r
	627	\r
	628	**/\r
	629	STATIC\r
	630	VOID\r
	631	UdpIoRecycleDgram (\r
	632	IN VOID *Context\r
	633	)\r
	634	{\r
	635	UDP_RX_TOKEN *Token;\r
	636	\r
	637	Token = (UDP_RX_TOKEN *) Context;\r
	638	gBS->SignalEvent (Token->UdpToken.Packet.RxData->RecycleSignal);\r
	639	UdpIoFreeRxToken (Token);\r
	640	}\r
	641	\r
cbf316f2	642	/**\r
	643	The event handle for UDP receive request. It will build\r
	644	a NET_BUF from the recieved UDP data, then deliver it\r
	645	to the receiver.\r
	646	\r
cbf316f2	647	@param Context The UDP RX token.\r
	648	\r
	649	@return None\r
	650	\r
	651	**/\r
	652	STATIC\r
	653	VOID\r
	654	EFIAPI\r
36ee91ca	655	UdpIoOnDgramRcvdDpc (\r
cbf316f2	656	IN VOID *Context\r
	657	)\r
	658	{\r
	659	EFI_UDP4_COMPLETION_TOKEN *UdpToken;\r
	660	EFI_UDP4_RECEIVE_DATA *UdpRxData;\r
	661	EFI_UDP4_SESSION_DATA *UdpSession;\r
	662	UDP_RX_TOKEN *Token;\r
	663	UDP_POINTS Points;\r
	664	NET_BUF *Netbuf;\r
	665	\r
	666	Token = (UDP_RX_TOKEN *) Context;\r
	667	\r
	668	ASSERT ((Token->Signature == UDP_IO_RX_SIGNATURE) &&\r
	669	(Token == Token->UdpIo->RecvRequest));\r
	670	\r
	671	//\r
	672	// Clear the receive request first in case that the caller\r
	673	// wants to restart the receive in the callback.\r
	674	//\r
	675	Token->UdpIo->RecvRequest = NULL;\r
	676	\r
	677	UdpToken = &Token->UdpToken;\r
	678	UdpRxData = UdpToken->Packet.RxData;\r
	679	\r
	680	if (EFI_ERROR (UdpToken->Status) \|\| (UdpRxData == NULL)) {\r
36ee91ca	681	if (UdpToken->Status != EFI_ABORTED) {\r
	682	//\r
	683	// Invoke the CallBack only if the reception is not actively aborted.\r
	684	//\r
	685	Token->CallBack (NULL, NULL, UdpToken->Status, Token->Context);\r
	686	}\r
cbf316f2	687	\r
36ee91ca	688	UdpIoFreeRxToken (Token);\r
36ee91ca	689	return;\r
cbf316f2	690	}\r
	691	\r
	692	//\r
	693	// Build a NET_BUF from the UDP receive data, then deliver it up.\r
	694	//\r
	695	Netbuf = NetbufFromExt (\r
	696	(NET_FRAGMENT *) UdpRxData->FragmentTable,\r
	697	UdpRxData->FragmentCount,\r
	698	0,\r
	699	(UINT32) Token->HeadLen,\r
	700	UdpIoRecycleDgram,\r
	701	Token\r
	702	);\r
	703	\r
	704	if (Netbuf == NULL) {\r
	705	gBS->SignalEvent (UdpRxData->RecycleSignal);\r
	706	Token->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, Token->Context);\r
	707	\r
	708	UdpIoFreeRxToken (Token);\r
36ee91ca	709	return;\r
cbf316f2	710	}\r
	711	\r
	712	UdpSession = &UdpRxData->UdpSession;\r
cbf316f2	713	Points.LocalPort = UdpSession->DestinationPort;\r
cbf316f2	714	Points.RemotePort = UdpSession->SourcePort;\r
cbf316f2	715	\r
e48e37fc	716	CopyMem (&Points.LocalAddr, &UdpSession->DestinationAddress, sizeof (IP4_ADDR));\r
e48e37fc	717	CopyMem (&Points.RemoteAddr, &UdpSession->SourceAddress, sizeof (IP4_ADDR));\r
b61439a7	718	Points.LocalAddr = NTOHL (Points.LocalAddr);\r
	719	Points.RemoteAddr = NTOHL (Points.RemoteAddr);\r
	720	\r
cbf316f2	721	Token->CallBack (Netbuf, &Points, EFI_SUCCESS, Token->Context);\r
36ee91ca	722	}\r
	723	\r
	724	/**\r
	725	Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK.\r
	726	\r
	727	@param Event The UDP receive request event.\r
	728	@param Context The UDP RX token.\r
	729	\r
	730	@return None\r
	731	\r
	732	**/\r
	733	STATIC\r
	734	VOID\r
	735	EFIAPI\r
	736	UdpIoOnDgramRcvd (\r
	737	IN EFI_EVENT Event,\r
	738	IN VOID *Context\r
	739	)\r
	740	/*++\r
	741	\r
	742	Routine Description:\r
	743	\r
	744	Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK\r
	745	\r
	746	Arguments:\r
	747	\r
	748	Event - The UDP receive request event\r
	749	Context - The UDP RX token.\r
	750	\r
	751	Returns:\r
cbf316f2	752	\r
36ee91ca	753	None\r
	754	\r
	755	--*/\r
	756	{\r
	757	//\r
	758	// Request UdpIoOnDgramRcvdDpc as a DPC at TPL_CALLBACK\r
	759	//\r
	760	NetLibQueueDpc (TPL_CALLBACK, UdpIoOnDgramRcvdDpc, Context);\r
cbf316f2	761	}\r
	762	\r
	763	\r
	764	/**\r
	765	Issue a receive request to the UDP IO port.\r
	766	\r
	767	@param UdpIo The UDP IO port to recieve the packet from.\r
	768	@param CallBack The call back function to execute when receive\r
	769	finished.\r
	770	@param Context The opque context to the call back\r
	771	@param HeadLen The lenght of the application's header\r
	772	\r
	773	@retval EFI_ALREADY_STARTED There is already a pending receive request. Only\r
	774	one receive request is supported.\r
	775	@retval EFI_OUT_OF_RESOURCES Failed to allocate some resource.\r
	776	@retval EFI_SUCCESS The receive request is issued successfully.\r
	777	\r
	778	**/\r
	779	EFI_STATUS\r
7b414b4e	780	EFIAPI\r
cbf316f2	781	UdpIoRecvDatagram (\r
	782	IN UDP_IO_PORT *UdpIo,\r
	783	IN UDP_IO_CALLBACK CallBack,\r
	784	IN VOID *Context,\r
	785	IN UINT32 HeadLen\r
	786	)\r
	787	{\r
	788	UDP_RX_TOKEN *Token;\r
	789	EFI_STATUS Status;\r
	790	\r
	791	if (UdpIo->RecvRequest != NULL) {\r
	792	return EFI_ALREADY_STARTED;\r
	793	}\r
	794	\r
	795	Token = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);\r
	796	\r
	797	if (Token == NULL) {\r
	798	return EFI_OUT_OF_RESOURCES;\r
	799	}\r
	800	\r
36ee91ca	801	UdpIo->RecvRequest = Token;\r
cbf316f2	802	Status = UdpIo->Udp->Receive (UdpIo->Udp, &Token->UdpToken);\r
	803	\r
	804	if (EFI_ERROR (Status)) {\r
36ee91ca	805	UdpIo->RecvRequest = NULL;\r
cbf316f2	806	UdpIoFreeRxToken (Token);\r
cbf316f2	807	}\r
cbf316f2	808	\r
36ee91ca	809	return Status;\r
cbf316f2	810	}\r