[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcSupport.c

/** @file\r
  Support functions implementation for UefiPxeBc Driver.\r
\r
  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "PxeBcImpl.h"\r
\r
/**\r
  Flush the previous configuration using the new station Ip address.\r
\r
  @param[in]   Private        The pointer to the PxeBc private data.\r
  @param[in]   StationIp      The pointer to the station Ip address.\r
  @param[in]   SubnetMask     The pointer to the subnet mask address for v4.\r
\r
  @retval EFI_SUCCESS         Successfully flushed the previous configuration.\r
  @retval Others              Failed to flush using the new station Ip.\r
\r
**/\r
EFI_STATUS\r
PxeBcFlushStationIp (\r
  PXEBC_PRIVATE_DATA  *Private,\r
  EFI_IP_ADDRESS      *StationIp      OPTIONAL,\r
  EFI_IP_ADDRESS      *SubnetMask     OPTIONAL\r
  )\r
{\r
  EFI_PXE_BASE_CODE_MODE  *Mode;\r
  EFI_STATUS              Status;\r
  EFI_ARP_CONFIG_DATA     ArpConfigData;\r
\r
  Mode   = Private->PxeBc.Mode;\r
  Status = EFI_SUCCESS;\r
  ZeroMem (&ArpConfigData, sizeof (EFI_ARP_CONFIG_DATA));\r
\r
  if (Mode->UsingIpv6 && (StationIp != NULL)) {\r
    //\r
    // Overwrite Udp6CfgData/Ip6CfgData StationAddress.\r
    //\r
    CopyMem (&Private->Udp6CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));\r
    CopyMem (&Private->Ip6CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));\r
\r
    //\r
    // Reconfigure the Ip6 instance to capture background ICMP6 packets with new station Ip address.\r
    //\r
    Private->Ip6->Cancel (Private->Ip6, &Private->Icmp6Token);\r
    Private->Ip6->Configure (Private->Ip6, NULL);\r
\r
    Status = Private->Ip6->Configure (Private->Ip6, &Private->Ip6CfgData);\r
    if (EFI_ERROR (Status)) {\r
      goto ON_EXIT;\r
    }\r
\r
    Status = Private->Ip6->Receive (Private->Ip6, &Private->Icmp6Token);\r
  } else {\r
    if (StationIp != NULL) {\r
      //\r
      // Reconfigure the ARP instance with station Ip address.\r
      //\r
      ArpConfigData.SwAddressType   = 0x0800;\r
      ArpConfigData.SwAddressLength = (UINT8)sizeof (EFI_IPv4_ADDRESS);\r
      ArpConfigData.StationAddress  = StationIp;\r
\r
      Private->Arp->Configure (Private->Arp, NULL);\r
      Private->Arp->Configure (Private->Arp, &ArpConfigData);\r
\r
      //\r
      // Overwrite Udp4CfgData/Ip4CfgData StationAddress.\r
      //\r
      CopyMem (&Private->Udp4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));\r
      CopyMem (&Private->Ip4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));\r
    }\r
\r
    if (SubnetMask != NULL) {\r
      //\r
      // Overwrite Udp4CfgData/Ip4CfgData SubnetMask.\r
      //\r
      CopyMem (&Private->Udp4CfgData.SubnetMask, SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
      CopyMem (&Private->Ip4CfgData.SubnetMask, SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
    }\r
\r
    if ((StationIp != NULL) && (SubnetMask != NULL)) {\r
      //\r
      // Updated the route table.\r
      //\r
      Mode->RouteTableEntries                = 1;\r
      Mode->RouteTable[0].IpAddr.Addr[0]     = StationIp->Addr[0] & SubnetMask->Addr[0];\r
      Mode->RouteTable[0].SubnetMask.Addr[0] = SubnetMask->Addr[0];\r
      Mode->RouteTable[0].GwAddr.Addr[0]     = 0;\r
    }\r
\r
    if ((StationIp != NULL) || (SubnetMask != NULL)) {\r
      //\r
      // Reconfigure the Ip4 instance to capture background ICMP packets with new station Ip address.\r
      //\r
      Private->Ip4->Cancel (Private->Ip4, &Private->IcmpToken);\r
      Private->Ip4->Configure (Private->Ip4, NULL);\r
\r
      Status = Private->Ip4->Configure (Private->Ip4, &Private->Ip4CfgData);\r
      if (EFI_ERROR (Status)) {\r
        goto ON_EXIT;\r
      }\r
\r
      Status = Private->Ip4->Receive (Private->Ip4, &Private->IcmpToken);\r
    }\r
  }\r
\r
ON_EXIT:\r
  return Status;\r
}\r
\r
/**\r
  Notify the callback function when an event is triggered.\r
\r
  @param[in]  Event           The triggered event.\r
  @param[in]  Context         The opaque parameter to the function.\r
\r
**/\r
VOID\r
EFIAPI\r
PxeBcCommonNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  *((BOOLEAN *)Context) = TRUE;\r
}\r
\r
/**\r
  Do arp resolution from arp cache in PxeBcMode.\r
\r
  @param  Mode           The pointer to EFI_PXE_BASE_CODE_MODE.\r
  @param  Ip4Addr        The Ip4 address for resolution.\r
  @param  MacAddress     The resolved MAC address if the resolution is successful.\r
                         The value is undefined if the resolution fails.\r
\r
  @retval TRUE           Found an matched entry.\r
  @retval FALSE          Did not find a matched entry.\r
\r
**/\r
BOOLEAN\r
PxeBcCheckArpCache (\r
  IN  EFI_PXE_BASE_CODE_MODE  *Mode,\r
  IN  EFI_IPv4_ADDRESS        *Ip4Addr,\r
  OUT EFI_MAC_ADDRESS         *MacAddress\r
  )\r
{\r
  UINT32  Index;\r
\r
  ASSERT (!Mode->UsingIpv6);\r
\r
  //\r
  // Check whether the current Arp cache in mode data contains this information or not.\r
  //\r
  for (Index = 0; Index < Mode->ArpCacheEntries; Index++) {\r
    if (EFI_IP4_EQUAL (&Mode->ArpCache[Index].IpAddr.v4, Ip4Addr)) {\r
      CopyMem (\r
        MacAddress,\r
        &Mode->ArpCache[Index].MacAddr,\r
        sizeof (EFI_MAC_ADDRESS)\r
        );\r
      return TRUE;\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Update the arp cache periodically.\r
\r
  @param  Event              The pointer to EFI_PXE_BC_PROTOCOL.\r
  @param  Context            Context of the timer event.\r
\r
**/\r
VOID\r
EFIAPI\r
PxeBcArpCacheUpdate (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  PXEBC_PRIVATE_DATA      *Private;\r
  EFI_PXE_BASE_CODE_MODE  *Mode;\r
  EFI_ARP_FIND_DATA       *ArpEntry;\r
  UINT32                  EntryLength;\r
  UINT32                  EntryCount;\r
  UINT32                  Index;\r
  EFI_STATUS              Status;\r
\r
  Private = (PXEBC_PRIVATE_DATA *)Context;\r
  Mode    = Private->PxeBc.Mode;\r
\r
  ASSERT (!Mode->UsingIpv6);\r
\r
  //\r
  // Get the current Arp cache from Arp driver.\r
  //\r
  Status = Private->Arp->Find (\r
                           Private->Arp,\r
                           TRUE,\r
                           NULL,\r
                           &EntryLength,\r
                           &EntryCount,\r
                           &ArpEntry,\r
                           TRUE\r
                           );\r
  if (EFI_ERROR (Status)) {\r
    return;\r
  }\r
\r
  //\r
  // Update the Arp cache in mode data.\r
  //\r
  Mode->ArpCacheEntries = MIN (EntryCount, EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES);\r
\r
  for (Index = 0; Index < Mode->ArpCacheEntries; Index++) {\r
    CopyMem (\r
      &Mode->ArpCache[Index].IpAddr,\r
      ArpEntry + 1,\r
      ArpEntry->SwAddressLength\r
      );\r
    CopyMem (\r
      &Mode->ArpCache[Index].MacAddr,\r
      (UINT8 *)(ArpEntry + 1) + ArpEntry->SwAddressLength,\r
      ArpEntry->HwAddressLength\r
      );\r
    ArpEntry = (EFI_ARP_FIND_DATA *)((UINT8 *)ArpEntry + EntryLength);\r
  }\r
}\r
\r
/**\r
  Notify function to handle the received ICMP message in DPC.\r
\r
  @param  Context               The PXEBC private data.\r
\r
**/\r
VOID\r
EFIAPI\r
PxeBcIcmpErrorDpcHandle (\r
  IN VOID  *Context\r
  )\r
{\r
  EFI_STATUS              Status;\r
  EFI_IP4_RECEIVE_DATA    *RxData;\r
  EFI_IP4_PROTOCOL        *Ip4;\r
  PXEBC_PRIVATE_DATA      *Private;\r
  EFI_PXE_BASE_CODE_MODE  *Mode;\r
  UINT8                   Type;\r
  UINTN                   Index;\r
  UINT32                  CopiedLen;\r
  UINT8                   *IcmpError;\r
\r
  Private = (PXEBC_PRIVATE_DATA *)Context;\r
  Mode    = &Private->Mode;\r
  Status  = Private->IcmpToken.Status;\r
  RxData  = Private->IcmpToken.Packet.RxData;\r
  Ip4     = Private->Ip4;\r
\r
  ASSERT (!Mode->UsingIpv6);\r
\r
  if (Status == EFI_ABORTED) {\r
    //\r
    // It's triggered by user cancellation.\r
    //\r
    return;\r
  }\r
\r
  if (RxData == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  if (Status != EFI_ICMP_ERROR) {\r
    //\r
    // The return status should be recognized as EFI_ICMP_ERROR.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  if ((EFI_IP4 (RxData->Header->SourceAddress) != 0) &&\r
      (NTOHL (Mode->SubnetMask.Addr[0]) != 0) &&\r
      IP4_NET_EQUAL (NTOHL (Mode->StationIp.Addr[0]), EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0])) &&\r
      !NetIp4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), NTOHL (Mode->SubnetMask.Addr[0])))\r
  {\r
    //\r
    // The source address of the received packet should be a valid unicast address.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  if (!EFI_IP4_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v4)) {\r
    //\r
    // The destination address of the received packet should be equal to the host address.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  //\r
  // The protocol has been configured to only receive ICMP packet.\r
  //\r
  ASSERT (RxData->Header->Protocol == EFI_IP_PROTO_ICMP);\r
\r
  Type = *((UINT8 *)RxData->FragmentTable[0].FragmentBuffer);\r
\r
  if ((Type != ICMP_DEST_UNREACHABLE) &&\r
      (Type != ICMP_SOURCE_QUENCH) &&\r
      (Type != ICMP_REDIRECT) &&\r
      (Type != ICMP_TIME_EXCEEDED) &&\r
      (Type != ICMP_PARAMETER_PROBLEM))\r
  {\r
    //\r
    // The type of the receveid ICMP message should be ICMP_ERROR_MESSAGE.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  //\r
  // Copy the right ICMP error message into mode data.\r
  //\r
  CopiedLen = 0;\r
  IcmpError = (UINT8 *)&Mode->IcmpError;\r
\r
  for (Index = 0; Index < RxData->FragmentCount; Index++) {\r
    CopiedLen += RxData->FragmentTable[Index].FragmentLength;\r
    if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) {\r
      CopyMem (\r
        IcmpError,\r
        RxData->FragmentTable[Index].FragmentBuffer,\r
        RxData->FragmentTable[Index].FragmentLength\r
        );\r
    } else {\r
      CopyMem (\r
        IcmpError,\r
        RxData->FragmentTable[Index].FragmentBuffer,\r
        CopiedLen - sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)\r
        );\r
    }\r
\r
    IcmpError += CopiedLen;\r
  }\r
\r
ON_RECYCLE:\r
  gBS->SignalEvent (RxData->RecycleSignal);\r
\r
ON_EXIT:\r
  Private->IcmpToken.Status = EFI_NOT_READY;\r
  Ip4->Receive (Ip4, &Private->IcmpToken);\r
}\r
\r
/**\r
  Callback function to update the latest ICMP6 error message.\r
\r
  @param  Event                 The event signalled.\r
  @param  Context               The context passed in using the event notifier.\r
\r
**/\r
VOID\r
EFIAPI\r
PxeBcIcmpErrorUpdate (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  QueueDpc (TPL_CALLBACK, PxeBcIcmpErrorDpcHandle, Context);\r
}\r
\r
/**\r
  Notify function to handle the received ICMP6 message in DPC.\r
\r
  @param  Context               The PXEBC private data.\r
\r
**/\r
VOID\r
EFIAPI\r
PxeBcIcmp6ErrorDpcHandle (\r
  IN VOID  *Context\r
  )\r
{\r
  PXEBC_PRIVATE_DATA      *Private;\r
  EFI_IP6_RECEIVE_DATA    *RxData;\r
  EFI_IP6_PROTOCOL        *Ip6;\r
  EFI_PXE_BASE_CODE_MODE  *Mode;\r
  EFI_STATUS              Status;\r
  UINTN                   Index;\r
  UINT8                   Type;\r
  UINT32                  CopiedLen;\r
  UINT8                   *Icmp6Error;\r
\r
  Private = (PXEBC_PRIVATE_DATA *)Context;\r
  Mode    = &Private->Mode;\r
  Status  = Private->Icmp6Token.Status;\r
  RxData  = Private->Icmp6Token.Packet.RxData;\r
  Ip6     = Private->Ip6;\r
\r
  ASSERT (Mode->UsingIpv6);\r
\r
  if (Status == EFI_ABORTED) {\r
    //\r
    // It's triggered by user cancellation.\r
    //\r
    return;\r
  }\r
\r
  if (RxData == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  if (Status != EFI_ICMP_ERROR) {\r
    //\r
    // The return status should be recognized as EFI_ICMP_ERROR.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  if (!NetIp6IsValidUnicast (&RxData->Header->SourceAddress)) {\r
    //\r
    // The source address of the received packet should be a valid unicast address.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  if (!NetIp6IsUnspecifiedAddr (&Mode->StationIp.v6) &&\r
      !EFI_IP6_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v6))\r
  {\r
    //\r
    // The destination address of the received packet should be equal to the host address.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  //\r
  // The protocol has been configured to only receive ICMP packet.\r
  //\r
  ASSERT (RxData->Header->NextHeader == IP6_ICMP);\r
\r
  Type = *((UINT8 *)RxData->FragmentTable[0].FragmentBuffer);\r
\r
  if ((Type != ICMP_V6_DEST_UNREACHABLE) &&\r
      (Type != ICMP_V6_PACKET_TOO_BIG) &&\r
      (Type != ICMP_V6_TIME_EXCEEDED) &&\r
      (Type != ICMP_V6_PARAMETER_PROBLEM))\r
  {\r
    //\r
    // The type of the receveid packet should be an ICMP6 error message.\r
    //\r
    goto ON_RECYCLE;\r
  }\r
\r
  //\r
  // Copy the right ICMP6 error message into mode data.\r
  //\r
  CopiedLen  = 0;\r
  Icmp6Error = (UINT8 *)&Mode->IcmpError;\r
\r
  for (Index = 0; Index < RxData->FragmentCount; Index++) {\r
    CopiedLen += RxData->FragmentTable[Index].FragmentLength;\r
    if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) {\r
      CopyMem (\r
        Icmp6Error,\r
        RxData->FragmentTable[Index].FragmentBuffer,\r
        RxData->FragmentTable[Index].FragmentLength\r
        );\r
    } else {\r
      CopyMem (\r
        Icmp6Error,\r
        RxData->FragmentTable[Index].FragmentBuffer,\r
        CopiedLen - sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)\r
        );\r
    }\r
\r
    Icmp6Error += CopiedLen;\r
  }\r
\r
ON_RECYCLE:\r
  gBS->SignalEvent (RxData->RecycleSignal);\r
\r
ON_EXIT:\r
  Private->Icmp6Token.Status = EFI_NOT_READY;\r
  Ip6->Receive (Ip6, &Private->Icmp6Token);\r
}\r
\r
/**\r
  Callback function to update the latest ICMP6 error message.\r
\r
  @param  Event                 The event signalled.\r
  @param  Context               The context passed in using the event notifier.\r
\r
**/\r
VOID\r
EFIAPI\r
PxeBcIcmp6ErrorUpdate (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  QueueDpc (TPL_CALLBACK, PxeBcIcmp6ErrorDpcHandle, Context);\r
}\r
\r
/**\r
  This function is to configure a UDPv4 instance for UdpWrite.\r
\r
  @param[in]       Udp4                 The pointer to EFI_UDP4_PROTOCOL.\r
  @param[in]       StationIp            The pointer to the station address.\r
  @param[in]       SubnetMask           The pointer to the subnet mask.\r
  @param[in]       Gateway              The pointer to the gateway address.\r
  @param[in, out]  SrcPort              The pointer to the source port.\r
  @param[in]       DoNotFragment        If TRUE, fragment is not enabled.\r
                                        Otherwise, fragment is enabled.\r
  @param[in]       Ttl                  The time to live field of the IP header.\r
  @param[in]       ToS                  The type of service field of the IP header.\r
\r
  @retval          EFI_SUCCESS          Successfully configured this instance.\r
  @retval          Others               Failed to configure this instance.\r
\r
**/\r
EFI_STATUS\r
PxeBcConfigUdp4Write (\r
  IN     EFI_UDP4_PROTOCOL  *Udp4,\r
  IN     EFI_IPv4_ADDRESS   *StationIp,\r
  IN     EFI_IPv4_ADDRESS   *SubnetMask,\r
  IN     EFI_IPv4_ADDRESS   *Gateway,\r
  IN OUT UINT16             *SrcPort,\r
  IN     BOOLEAN            DoNotFragment,\r
  IN     UINT8              Ttl,\r
  IN     UINT8              ToS\r
  )\r
{\r
  EFI_UDP4_CONFIG_DATA  Udp4CfgData;\r
  EFI_STATUS            Status;\r
\r
  ZeroMem (&Udp4CfgData, sizeof (Udp4CfgData));\r
\r
  Udp4CfgData.TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;\r
  Udp4CfgData.ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;\r
  Udp4CfgData.TypeOfService      = ToS;\r
  Udp4CfgData.TimeToLive         = Ttl;\r
  Udp4CfgData.AllowDuplicatePort = TRUE;\r
  Udp4CfgData.DoNotFragment      = DoNotFragment;\r
\r
  CopyMem (&Udp4CfgData.StationAddress, StationIp, sizeof (*StationIp));\r
  CopyMem (&Udp4CfgData.SubnetMask, SubnetMask, sizeof (*SubnetMask));\r
\r
  Udp4CfgData.StationPort = *SrcPort;\r
\r
  //\r
  // Reset the UDPv4 instance.\r
  //\r
  Udp4->Configure (Udp4, NULL);\r
\r
  Status = Udp4->Configure (Udp4, &Udp4CfgData);\r
  if (!EFI_ERROR (Status) && !EFI_IP4_EQUAL (Gateway, &mZeroIp4Addr)) {\r
    //\r
    // The basic configuration is OK, need to add the default route entry\r
    //\r
    Status = Udp4->Routes (Udp4, FALSE, &mZeroIp4Addr, &mZeroIp4Addr, Gateway);\r
    if (EFI_ERROR (Status)) {\r
      Udp4->Configure (Udp4, NULL);\r
    }\r
  }\r
\r
  if (!EFI_ERROR (Status) && (*SrcPort == 0)) {\r
    Udp4->GetModeData (Udp4, &Udp4CfgData, NULL, NULL, NULL);\r
    *SrcPort = Udp4CfgData.StationPort;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function is to configure a UDPv6 instance for UdpWrite.\r
\r
  @param[in]       Udp6                 The pointer to EFI_UDP6_PROTOCOL.\r
  @param[in]       StationIp            The pointer to the station address.\r
  @param[in, out]  SrcPort              The pointer to the source port.\r
\r
  @retval          EFI_SUCCESS          Successfully configured this instance.\r
  @retval          Others               Failed to configure this instance.\r
\r
**/\r
EFI_STATUS\r
PxeBcConfigUdp6Write (\r
  IN     EFI_UDP6_PROTOCOL  *Udp6,\r
  IN     EFI_IPv6_ADDRESS   *StationIp,\r
  IN OUT UINT16             *SrcPort\r
  )\r
{\r
  EFI_UDP6_CONFIG_DATA  CfgData;\r
  EFI_STATUS            Status;\r
\r
  ZeroMem (&CfgData, sizeof (EFI_UDP6_CONFIG_DATA));\r
\r
  CfgData.ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;\r
  CfgData.TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;\r
  CfgData.HopLimit           = PXEBC_DEFAULT_HOPLIMIT;\r
  CfgData.AllowDuplicatePort = TRUE;\r
  CfgData.StationPort        = *SrcPort;\r
\r
  CopyMem (&CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));\r
\r
  //\r
  // Reset the UDPv6 instance.\r
  //\r
  Udp6->Configure (Udp6, NULL);\r
\r
  Status = Udp6->Configure (Udp6, &CfgData);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (!EFI_ERROR (Status) && (*SrcPort == 0)) {\r
    Udp6->GetModeData (Udp6, &CfgData, NULL, NULL, NULL);\r
    *SrcPort = CfgData.StationPort;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function is to configure a UDPv4 instance for UdpWrite.\r
\r
  @param[in]       Udp4                 The pointer to EFI_UDP4_PROTOCOL.\r
  @param[in]       Session              The pointer to the UDP4 session data.\r
  @param[in]       TimeoutEvent         The event for timeout.\r
  @param[in]       Gateway              The pointer to the gateway address.\r
  @param[in]       HeaderSize           An optional field which may be set to the length of a header\r
                                        at HeaderPtr to be prefixed to the data at BufferPtr.\r
  @param[in]       HeaderPtr            If HeaderSize is not NULL, a pointer to a header to be\r
                                        prefixed to the data at BufferPtr.\r
  @param[in]       BufferSize           A pointer to the size of the data at BufferPtr.\r
  @param[in]       BufferPtr            A pointer to the data to be written.\r
\r
  @retval          EFI_SUCCESS          Successfully send out data using Udp4Write.\r
  @retval          Others               Failed to send out data.\r
\r
**/\r
EFI_STATUS\r
PxeBcUdp4Write (\r
  IN EFI_UDP4_PROTOCOL      *Udp4,\r
  IN EFI_UDP4_SESSION_DATA  *Session,\r
  IN EFI_EVENT              TimeoutEvent,\r
  IN EFI_IPv4_ADDRESS       *Gateway      OPTIONAL,\r
  IN UINTN                  *HeaderSize   OPTIONAL,\r
  IN VOID                   *HeaderPtr    OPTIONAL,\r
  IN UINTN                  *BufferSize,\r
  IN VOID                   *BufferPtr\r
  )\r
{\r
  EFI_UDP4_COMPLETION_TOKEN  Token;\r
  EFI_UDP4_TRANSMIT_DATA     *TxData;\r
  UINT32                     TxLength;\r
  UINT32                     FragCount;\r
  UINT32                     DataLength;\r
  BOOLEAN                    IsDone;\r
  EFI_STATUS                 Status;\r
\r
  //\r
  // Arrange one fragment buffer for data, and another fragment buffer for header if has.\r
  //\r
  FragCount = (HeaderSize != NULL) ? 2 : 1;\r
  TxLength  = sizeof (EFI_UDP4_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP4_FRAGMENT_DATA);\r
  TxData    = (EFI_UDP4_TRANSMIT_DATA *)AllocateZeroPool (TxLength);\r
  if (TxData == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  TxData->FragmentCount                               = FragCount;\r
  TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32)*BufferSize;\r
  TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;\r
  DataLength                                          = (UINT32)*BufferSize;\r
\r
  if (HeaderSize != NULL) {\r
    TxData->FragmentTable[0].FragmentLength = (UINT32)*HeaderSize;\r
    TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;\r
    DataLength                             += (UINT32)*HeaderSize;\r
  }\r
\r
  if (Gateway != NULL) {\r
    TxData->GatewayAddress = Gateway;\r
  }\r
\r
  TxData->UdpSessionData = Session;\r
  TxData->DataLength     = DataLength;\r
  Token.Packet.TxData    = TxData;\r
  Token.Status           = EFI_NOT_READY;\r
  IsDone                 = FALSE;\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  PxeBcCommonNotify,\r
                  &IsDone,\r
                  &Token.Event\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = Udp4->Transmit (Udp4, &Token);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Poll the UDPv6 read instance if no packet received and no timeout triggered.\r
  //\r
  while (!IsDone &&\r
         Token.Status == EFI_NOT_READY &&\r
         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))\r
  {\r
    Udp4->Poll (Udp4);\r
  }\r
\r
  Status = (Token.Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token.Status;\r
\r
ON_EXIT:\r
  if (Token.Event != NULL) {\r
    gBS->CloseEvent (Token.Event);\r
  }\r
\r
  FreePool (TxData);\r
\r
  return Status;\r
}\r
\r
/**\r
  This function is to configure a UDPv4 instance for UdpWrite.\r
\r
  @param[in]       Udp6                 The pointer to EFI_UDP6_PROTOCOL.\r
  @param[in]       Session              The pointer to the UDP6 session data.\r
  @param[in]       TimeoutEvent         The event for timeout.\r
  @param[in]       HeaderSize           An optional field which may be set to the length of a header\r
                                        at HeaderPtr to be prefixed to the data at BufferPtr.\r
  @param[in]       HeaderPtr            If HeaderSize is not NULL, a pointer to a header to be\r
                                        prefixed to the data at BufferPtr.\r
  @param[in]       BufferSize           A pointer to the size of the data at BufferPtr.\r
  @param[in]       BufferPtr            A pointer to the data to be written.\r
\r
  @retval          EFI_SUCCESS          Successfully sent out data using Udp6Write.\r
  @retval          Others               Failed to send out data.\r
\r
**/\r
EFI_STATUS\r
PxeBcUdp6Write (\r
  IN EFI_UDP6_PROTOCOL      *Udp6,\r
  IN EFI_UDP6_SESSION_DATA  *Session,\r
  IN EFI_EVENT              TimeoutEvent,\r
  IN UINTN                  *HeaderSize   OPTIONAL,\r
  IN VOID                   *HeaderPtr    OPTIONAL,\r
  IN UINTN                  *BufferSize,\r
  IN VOID                   *BufferPtr\r
  )\r
{\r
  EFI_UDP6_COMPLETION_TOKEN  Token;\r
  EFI_UDP6_TRANSMIT_DATA     *TxData;\r
  UINT32                     TxLength;\r
  UINT32                     FragCount;\r
  UINT32                     DataLength;\r
  BOOLEAN                    IsDone;\r
  EFI_STATUS                 Status;\r
\r
  //\r
  // Arrange one fragment buffer for data, and another fragment buffer for header if has.\r
  //\r
  FragCount = (HeaderSize != NULL) ? 2 : 1;\r
  TxLength  = sizeof (EFI_UDP6_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP6_FRAGMENT_DATA);\r
  TxData    = (EFI_UDP6_TRANSMIT_DATA *)AllocateZeroPool (TxLength);\r
  if (TxData == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  TxData->FragmentCount                               = FragCount;\r
  TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32)*BufferSize;\r
  TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;\r
  DataLength                                          = (UINT32)*BufferSize;\r
\r
  if (HeaderSize != NULL) {\r
    TxData->FragmentTable[0].FragmentLength = (UINT32)*HeaderSize;\r
    TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;\r
    DataLength                             += (UINT32)*HeaderSize;\r
  }\r
\r
  TxData->UdpSessionData = Session;\r
  TxData->DataLength     = DataLength;\r
  Token.Packet.TxData    = TxData;\r
  Token.Status           = EFI_NOT_READY;\r
  IsDone                 = FALSE;\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  PxeBcCommonNotify,\r
                  &IsDone,\r
                  &Token.Event\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = Udp6->Transmit (Udp6, &Token);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  //\r
  // Poll the UDPv6 read instance if no packet received and no timeout triggered.\r
  //\r
  while (!IsDone &&\r
         Token.Status == EFI_NOT_READY &&\r
         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))\r
  {\r
    Udp6->Poll (Udp6);\r
  }\r
\r
  Status = (Token.Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token.Status;\r
\r
ON_EXIT:\r
  if (Token.Event != NULL) {\r
    gBS->CloseEvent (Token.Event);\r
  }\r
\r
  FreePool (TxData);\r
\r
  return Status;\r
}\r
\r
/**\r
  Check the received packet using the Ip filter.\r
\r
  @param[in]  Mode                The pointer to the mode data of PxeBc.\r
  @param[in]  Session             The pointer to the current UDPv4 session.\r
  @param[in]  OpFlags             Operation flag for UdpRead/UdpWrite.\r
\r
  @retval     TRUE                Passed the Ip filter successfully.\r
  @retval     FALSE               Failed to pass the Ip filter.\r
\r
**/\r
BOOLEAN\r
PxeBcCheckByIpFilter (\r
  IN EFI_PXE_BASE_CODE_MODE  *Mode,\r
  IN VOID                    *Session,\r
  IN UINT16                  OpFlags\r
  )\r
{\r
  EFI_IP_ADDRESS  DestinationIp;\r
  UINTN           Index;\r
\r
  if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER) == 0) {\r
    return TRUE;\r
  }\r
\r
  if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS) != 0) {\r
    return TRUE;\r
  }\r
\r
  //\r
  // Convert the destination address in session data to host order.\r
  //\r
  if (Mode->UsingIpv6) {\r
    CopyMem (\r
      &DestinationIp,\r
      &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress,\r
      sizeof (EFI_IPv6_ADDRESS)\r
      );\r
    NTOHLLL (&DestinationIp.v6);\r
  } else {\r
    ZeroMem (&DestinationIp, sizeof (EFI_IP_ADDRESS));\r
    CopyMem (\r
      &DestinationIp,\r
      &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress,\r
      sizeof (EFI_IPv4_ADDRESS)\r
      );\r
    EFI_NTOHL (DestinationIp);\r
  }\r
\r
  if (((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST) != 0) &&\r
      (IP4_IS_MULTICAST (DestinationIp.Addr[0]) ||\r
       IP6_IS_MULTICAST (&DestinationIp)))\r
  {\r
    return TRUE;\r
  }\r
\r
  if (((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST) != 0) &&\r
      IP4_IS_LOCAL_BROADCAST (DestinationIp.Addr[0]))\r
  {\r
    ASSERT (!Mode->UsingIpv6);\r
    return TRUE;\r
  }\r
\r
  if (((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP) != 0) &&\r
      (EFI_IP4_EQUAL (&Mode->StationIp.v4, &DestinationIp) ||\r
       EFI_IP6_EQUAL (&Mode->StationIp.v6, &DestinationIp)))\r
  {\r
    //\r
    // Matched if the dest address is equal to the station address.\r
    //\r
    return TRUE;\r
  }\r
\r
  for (Index = 0; Index < Mode->IpFilter.IpCnt; Index++) {\r
    ASSERT (Index < EFI_PXE_BASE_CODE_MAX_IPCNT);\r
    if (EFI_IP4_EQUAL (&Mode->IpFilter.IpList[Index].v4, &DestinationIp) ||\r
        EFI_IP6_EQUAL (&Mode->IpFilter.IpList[Index].v6, &DestinationIp))\r
    {\r
      //\r
      // Matched if the dest address is equal to any of address in the filter list.\r
      //\r
      return TRUE;\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Filter the received packet using the destination Ip.\r
\r
  @param[in]       Mode           The pointer to the mode data of PxeBc.\r
  @param[in]       Session        The pointer to the current UDPv4 session.\r
  @param[in, out]  DestIp         The pointer to the destination Ip address.\r
  @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.\r
\r
  @retval     TRUE                Passed the IPv4 filter successfully.\r
  @retval     FALSE               Failed to pass the IPv4 filter.\r
\r
**/\r
BOOLEAN\r
PxeBcCheckByDestIp (\r
  IN     EFI_PXE_BASE_CODE_MODE  *Mode,\r
  IN     VOID                    *Session,\r
  IN OUT EFI_IP_ADDRESS          *DestIp,\r
  IN     UINT16                  OpFlags\r
  )\r
{\r
  if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP) != 0) {\r
    //\r
    // Copy the destination address from the received packet if accept any.\r
    //\r
    if (DestIp != NULL) {\r
      if (Mode->UsingIpv6) {\r
        CopyMem (\r
          DestIp,\r
          &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress,\r
          sizeof (EFI_IPv6_ADDRESS)\r
          );\r
      } else {\r
        ZeroMem (DestIp, sizeof (EFI_IP_ADDRESS));\r
        CopyMem (\r
          DestIp,\r
          &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress,\r
          sizeof (EFI_IPv4_ADDRESS)\r
          );\r
      }\r
    }\r
\r
    return TRUE;\r
  } else if ((DestIp != NULL) &&\r
             (EFI_IP4_EQUAL (DestIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||\r
              EFI_IP6_EQUAL (DestIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress)))\r
  {\r
    //\r
    // The destination address in the received packet is matched if present.\r
    //\r
    return TRUE;\r
  } else if (EFI_IP4_EQUAL (&Mode->StationIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||\r
             EFI_IP6_EQUAL (&Mode->StationIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress))\r
  {\r
    //\r
    // The destination address in the received packet is equal to the host address.\r
    //\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Check the received packet using the destination port.\r
\r
  @param[in]       Mode           The pointer to the mode data of PxeBc.\r
  @param[in]       Session        The pointer to the current UDPv4 session.\r
  @param[in, out]  DestPort       The pointer to the destination port.\r
  @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.\r
\r
  @retval     TRUE                Passed the IPv4 filter successfully.\r
  @retval     FALSE               Failed to pass the IPv4 filter.\r
\r
**/\r
BOOLEAN\r
PxeBcCheckByDestPort (\r
  IN     EFI_PXE_BASE_CODE_MODE  *Mode,\r
  IN     VOID                    *Session,\r
  IN OUT UINT16                  *DestPort,\r
  IN     UINT16                  OpFlags\r
  )\r
{\r
  UINT16  Port;\r
\r
  if (Mode->UsingIpv6) {\r
    Port = ((EFI_UDP6_SESSION_DATA *)Session)->DestinationPort;\r
  } else {\r
    Port = ((EFI_UDP4_SESSION_DATA *)Session)->DestinationPort;\r
  }\r
\r
  if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT) != 0) {\r
    //\r
    // Return the destination port in the received packet if accept any.\r
    //\r
    if (DestPort != NULL) {\r
      *DestPort = Port;\r
    }\r
\r
    return TRUE;\r
  } else if ((DestPort != NULL) && (*DestPort == Port)) {\r
    //\r
    // The destination port in the received packet is matched if present.\r
    //\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Filter the received packet using the source Ip.\r
\r
  @param[in]       Mode           The pointer to the mode data of PxeBc.\r
  @param[in]       Session        The pointer to the current UDPv4 session.\r
  @param[in, out]  SrcIp          The pointer to the source Ip address.\r
  @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.\r
\r
  @retval     TRUE                Passed the IPv4 filter successfully.\r
  @retval     FALSE               Failed to pass the IPv4 filter.\r
\r
**/\r
BOOLEAN\r
PxeBcFilterBySrcIp (\r
  IN     EFI_PXE_BASE_CODE_MODE  *Mode,\r
  IN     VOID                    *Session,\r
  IN OUT EFI_IP_ADDRESS          *SrcIp,\r
  IN     UINT16                  OpFlags\r
  )\r
{\r
  if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP) != 0) {\r
    //\r
    // Copy the source address from the received packet if accept any.\r
    //\r
    if (SrcIp != NULL) {\r
      if (Mode->UsingIpv6) {\r
        CopyMem (\r
          SrcIp,\r
          &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress,\r
          sizeof (EFI_IPv6_ADDRESS)\r
          );\r
      } else {\r
        ZeroMem (SrcIp, sizeof (EFI_IP_ADDRESS));\r
        CopyMem (\r
          SrcIp,\r
          &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress,\r
          sizeof (EFI_IPv4_ADDRESS)\r
          );\r
      }\r
    }\r
\r
    return TRUE;\r
  } else if ((SrcIp != NULL) &&\r
             (EFI_IP4_EQUAL (SrcIp, &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress) ||\r
              EFI_IP6_EQUAL (SrcIp, &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress)))\r
  {\r
    //\r
    // The source address in the received packet is matched if present.\r
    //\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Filter the received packet using the source port.\r
\r
  @param[in]       Mode           The pointer to the mode data of PxeBc.\r
  @param[in]       Session        The pointer to the current UDPv4 session.\r
  @param[in, out]  SrcPort        The pointer to the source port.\r
  @param[in]       OpFlags        Operation flag for UdpRead/UdpWrite.\r
\r
  @retval     TRUE                Passed the IPv4 filter successfully.\r
  @retval     FALSE               Failed to pass the IPv4 filter.\r
\r
**/\r
BOOLEAN\r
PxeBcFilterBySrcPort (\r
  IN     EFI_PXE_BASE_CODE_MODE  *Mode,\r
  IN     VOID                    *Session,\r
  IN OUT UINT16                  *SrcPort,\r
  IN     UINT16                  OpFlags\r
  )\r
{\r
  UINT16  Port;\r
\r
  if (Mode->UsingIpv6) {\r
    Port = ((EFI_UDP6_SESSION_DATA *)Session)->SourcePort;\r
  } else {\r
    Port = ((EFI_UDP4_SESSION_DATA *)Session)->SourcePort;\r
  }\r
\r
  if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT) != 0) {\r
    //\r
    // Return the source port in the received packet if accept any.\r
    //\r
    if (SrcPort != NULL) {\r
      *SrcPort = Port;\r
    }\r
\r
    return TRUE;\r
  } else if ((SrcPort != NULL) && (*SrcPort == Port)) {\r
    //\r
    // The source port in the received packet is matched if present.\r
    //\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  This function is to receive packet using Udp4Read.\r
\r
  @param[in]       Udp4                 The pointer to EFI_UDP4_PROTOCOL.\r
  @param[in]       Token                The pointer to EFI_UDP4_COMPLETION_TOKEN.\r
  @param[in]       Mode                 The pointer to EFI_PXE_BASE_CODE_MODE.\r
  @param[in]       TimeoutEvent         The event for timeout.\r
  @param[in]       OpFlags              The UDP operation flags.\r
  @param[in]       IsDone               The pointer to the IsDone flag.\r
  @param[out]      IsMatched            The pointer to the IsMatched flag.\r
  @param[in, out]  DestIp               The pointer to the destination address.\r
  @param[in, out]  DestPort             The pointer to the destination port.\r
  @param[in, out]  SrcIp                The pointer to the source address.\r
  @param[in, out]  SrcPort              The pointer to the source port.\r
\r
  @retval          EFI_SUCCESS          Successfully read the data using Udp4.\r
  @retval          Others               Failed to send out data.\r
\r
**/\r
EFI_STATUS\r
PxeBcUdp4Read (\r
  IN     EFI_UDP4_PROTOCOL           *Udp4,\r
  IN     EFI_UDP4_COMPLETION_TOKEN   *Token,\r
  IN     EFI_PXE_BASE_CODE_MODE      *Mode,\r
  IN     EFI_EVENT                   TimeoutEvent,\r
  IN     UINT16                      OpFlags,\r
  IN     BOOLEAN                     *IsDone,\r
  OUT BOOLEAN                        *IsMatched,\r
  IN OUT EFI_IP_ADDRESS              *DestIp      OPTIONAL,\r
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *DestPort    OPTIONAL,\r
  IN OUT EFI_IP_ADDRESS              *SrcIp       OPTIONAL,\r
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *SrcPort     OPTIONAL\r
  )\r
{\r
  EFI_UDP4_RECEIVE_DATA  *RxData;\r
  EFI_UDP4_SESSION_DATA  *Session;\r
  EFI_STATUS             Status;\r
\r
  Token->Status = EFI_NOT_READY;\r
  *IsDone       = FALSE;\r
\r
  Status = Udp4->Receive (Udp4, Token);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Poll the UDPv6 read instance if no packet received and no timeout triggered.\r
  //\r
  while (!(*IsDone) &&\r
         Token->Status == EFI_NOT_READY &&\r
         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))\r
  {\r
    //\r
    // Poll the token until reply/ICMPv6 error message received or timeout.\r
    //\r
    Udp4->Poll (Udp4);\r
    if ((Token->Status == EFI_ICMP_ERROR) ||\r
        (Token->Status == EFI_NETWORK_UNREACHABLE) ||\r
        (Token->Status == EFI_HOST_UNREACHABLE) ||\r
        (Token->Status == EFI_PROTOCOL_UNREACHABLE) ||\r
        (Token->Status == EFI_PORT_UNREACHABLE))\r
    {\r
      break;\r
    }\r
  }\r
\r
  Status = (Token->Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token->Status;\r
\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // check whether this packet matches the filters\r
    //\r
    RxData  = Token->Packet.RxData;\r
    Session = &RxData->UdpSession;\r
\r
    *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcCheckByDestIp (Mode, Session, DestIp, OpFlags);\r
    }\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcCheckByDestPort (Mode, Session, DestPort, OpFlags);\r
    }\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcFilterBySrcIp (Mode, Session, SrcIp, OpFlags);\r
    }\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcFilterBySrcPort (Mode, Session, SrcPort, OpFlags);\r
    }\r
\r
    if (!(*IsMatched)) {\r
      //\r
      // Recycle the receiving buffer if not matched.\r
      //\r
      gBS->SignalEvent (RxData->RecycleSignal);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function is to receive packets using Udp6Read.\r
\r
  @param[in]       Udp6                 The pointer to EFI_UDP6_PROTOCOL.\r
  @param[in]       Token                The pointer to EFI_UDP6_COMPLETION_TOKEN.\r
  @param[in]       Mode                 The pointer to EFI_PXE_BASE_CODE_MODE.\r
  @param[in]       TimeoutEvent         The event for timeout.\r
  @param[in]       OpFlags              The UDP operation flags.\r
  @param[in]       IsDone               The pointer to the IsDone flag.\r
  @param[out]      IsMatched            The pointer to the IsMatched flag.\r
  @param[in, out]  DestIp               The pointer to the destination address.\r
  @param[in, out]  DestPort             The pointer to the destination port.\r
  @param[in, out]  SrcIp                The pointer to the source address.\r
  @param[in, out]  SrcPort              The pointer to the source port.\r
\r
  @retval          EFI_SUCCESS          Successfully read data using Udp6.\r
  @retval          Others               Failed to send out data.\r
\r
**/\r
EFI_STATUS\r
PxeBcUdp6Read (\r
  IN     EFI_UDP6_PROTOCOL           *Udp6,\r
  IN     EFI_UDP6_COMPLETION_TOKEN   *Token,\r
  IN     EFI_PXE_BASE_CODE_MODE      *Mode,\r
  IN     EFI_EVENT                   TimeoutEvent,\r
  IN     UINT16                      OpFlags,\r
  IN     BOOLEAN                     *IsDone,\r
  OUT BOOLEAN                        *IsMatched,\r
  IN OUT EFI_IP_ADDRESS              *DestIp      OPTIONAL,\r
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *DestPort    OPTIONAL,\r
  IN OUT EFI_IP_ADDRESS              *SrcIp       OPTIONAL,\r
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT  *SrcPort     OPTIONAL\r
  )\r
{\r
  EFI_UDP6_RECEIVE_DATA  *RxData;\r
  EFI_UDP6_SESSION_DATA  *Session;\r
  EFI_STATUS             Status;\r
\r
  Token->Status = EFI_NOT_READY;\r
  *IsDone       = FALSE;\r
\r
  Status = Udp6->Receive (Udp6, Token);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Poll the UDPv6 read instance if no packet received and no timeout triggered.\r
  //\r
  while (!(*IsDone) &&\r
         Token->Status == EFI_NOT_READY &&\r
         EFI_ERROR (gBS->CheckEvent (TimeoutEvent)))\r
  {\r
    //\r
    // Poll the token until reply/ICMPv6 error message received or timeout.\r
    //\r
    Udp6->Poll (Udp6);\r
    if ((Token->Status == EFI_ICMP_ERROR) ||\r
        (Token->Status == EFI_NETWORK_UNREACHABLE) ||\r
        (Token->Status == EFI_HOST_UNREACHABLE) ||\r
        (Token->Status == EFI_PROTOCOL_UNREACHABLE) ||\r
        (Token->Status == EFI_PORT_UNREACHABLE))\r
    {\r
      break;\r
    }\r
  }\r
\r
  Status = (Token->Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token->Status;\r
\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // check whether this packet matches the filters\r
    //\r
    RxData  = Token->Packet.RxData;\r
    Session = &RxData->UdpSession;\r
\r
    *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcCheckByDestIp (Mode, Session, DestIp, OpFlags);\r
    }\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcCheckByDestPort (Mode, Session, DestPort, OpFlags);\r
    }\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcFilterBySrcIp (Mode, Session, SrcIp, OpFlags);\r
    }\r
\r
    if (*IsMatched) {\r
      *IsMatched = PxeBcFilterBySrcPort (Mode, Session, SrcPort, OpFlags);\r
    }\r
\r
    if (!(*IsMatched)) {\r
      //\r
      // Recycle the receiving buffer if not matched.\r
      //\r
      gBS->SignalEvent (RxData->RecycleSignal);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function is to display the IPv4 address.\r
\r
  @param[in]  Ip        The pointer to the IPv4 address.\r
\r
**/\r
VOID\r
PxeBcShowIp4Addr (\r
  IN EFI_IPv4_ADDRESS  *Ip\r
  )\r
{\r
  UINTN  Index;\r
\r
  for (Index = 0; Index < 4; Index++) {\r
    AsciiPrint ("%d", Ip->Addr[Index]);\r
    if (Index < 3) {\r
      AsciiPrint (".");\r
    }\r
  }\r
}\r
\r
/**\r
  This function is to display the IPv6 address.\r
\r
  @param[in]  Ip        The pointer to the IPv6 address.\r
\r
**/\r
VOID\r
PxeBcShowIp6Addr (\r
  IN EFI_IPv6_ADDRESS  *Ip\r
  )\r
{\r
  UINTN  Index;\r
\r
  for (Index = 0; Index < 16; Index++) {\r
    if (Ip->Addr[Index] != 0) {\r
      AsciiPrint ("%x", Ip->Addr[Index]);\r
    }\r
\r
    Index++;\r
    if (Index > 15) {\r
      return;\r
    }\r
\r
    if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) {\r
      AsciiPrint ("0");\r
    }\r
\r
    AsciiPrint ("%x", Ip->Addr[Index]);\r
    if (Index < 15) {\r
      AsciiPrint (":");\r
    }\r
  }\r
}\r
\r
/**\r
  This function is to convert UINTN to ASCII string with the required formatting.\r
\r
  @param[in]  Number         Numeric value to be converted.\r
  @param[in]  Buffer         The pointer to the buffer for ASCII string.\r
  @param[in]  Length         The length of the required format.\r
\r
**/\r
VOID\r
PxeBcUintnToAscDecWithFormat (\r
  IN UINTN  Number,\r
  IN UINT8  *Buffer,\r
  IN INTN   Length\r
  )\r
{\r
  UINTN  Remainder;\r
\r
  for ( ; Length > 0; Length--) {\r
    Remainder          = Number % 10;\r
    Number            /= 10;\r
    Buffer[Length - 1] = (UINT8)('0' + Remainder);\r
  }\r
}\r
\r
/**\r
  This function is to convert a UINTN to a ASCII string, and return the\r
  actual length of the buffer.\r
\r
  @param[in]  Number         Numeric value to be converted.\r
  @param[in]  Buffer         The pointer to the buffer for ASCII string.\r
  @param[in]  BufferSize     The maxsize of the buffer.\r
\r
  @return     Length         The actual length of the ASCII string.\r
\r
**/\r
UINTN\r
PxeBcUintnToAscDec (\r
  IN UINTN  Number,\r
  IN UINT8  *Buffer,\r
  IN UINTN  BufferSize\r
  )\r
{\r
  UINTN  Index;\r
  UINTN  Length;\r
  CHAR8  TempStr[64];\r
\r
  Index          = 63;\r
  TempStr[Index] = 0;\r
\r
  do {\r
    Index--;\r
    TempStr[Index] = (CHAR8)('0' + (Number % 10));\r
    Number         = (UINTN)(Number / 10);\r
  } while (Number != 0);\r
\r
  AsciiStrCpyS ((CHAR8 *)Buffer, BufferSize, &TempStr[Index]);\r
\r
  Length = AsciiStrLen ((CHAR8 *)Buffer);\r
\r
  return Length;\r
}\r
\r
/**\r
  This function is to convert unicode hex number to a UINT8.\r
\r
  @param[out]  Digit                   The converted UINT8 for output.\r
  @param[in]   Char                    The unicode hex number to be converted.\r
\r
  @retval      EFI_SUCCESS             Successfully converted the unicode hex.\r
  @retval      EFI_INVALID_PARAMETER   Failed to convert the unicode hex.\r
\r
**/\r
EFI_STATUS\r
PxeBcUniHexToUint8 (\r
  OUT UINT8   *Digit,\r
  IN  CHAR16  Char\r
  )\r
{\r
  if ((Char >= L'0') && (Char <= L'9')) {\r
    *Digit = (UINT8)(Char - L'0');\r
    return EFI_SUCCESS;\r
  }\r
\r
  if ((Char >= L'A') && (Char <= L'F')) {\r
    *Digit = (UINT8)(Char - L'A' + 0x0A);\r
    return EFI_SUCCESS;\r
  }\r
\r
  if ((Char >= L'a') && (Char <= L'f')) {\r
    *Digit = (UINT8)(Char - L'a' + 0x0A);\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_INVALID_PARAMETER;\r
}\r
\r
/**\r
  Calculate the elapsed time.\r
\r
  @param[in]      Private      The pointer to PXE private data\r
\r
**/\r
VOID\r
CalcElapsedTime (\r
  IN     PXEBC_PRIVATE_DATA  *Private\r
  )\r
{\r
  EFI_TIME  Time;\r
  UINT64    CurrentStamp;\r
  UINT64    ElapsedTimeValue;\r
\r
  //\r
  // Generate a time stamp of the centiseconds from 1900/1/1, assume 30day/month.\r
  //\r
  ZeroMem (&Time, sizeof (EFI_TIME));\r
  gRT->GetTime (&Time, NULL);\r
  CurrentStamp = MultU64x32 (\r
                   ((((UINT32)(Time.Year - 1900) * 360 + (Time.Month - 1) * 30 + (Time.Day - 1)) * 24 + Time.Hour) * 60 + Time.Minute) * 60 + Time.Second,\r
                   100\r
                   ) +\r
                 DivU64x32 (\r
                   Time.Nanosecond,\r
                   10000000\r
                   );\r
\r
  //\r
  // Sentinel value of 0 means that this is the first DHCP packet that we are\r
  // sending and that we need to initialize the value.  First DHCP Solicit\r
  // gets 0 elapsed-time.  Otherwise, calculate based on StartTime.\r
  //\r
  if (Private->ElapsedTime == 0) {\r
    Private->ElapsedTime = CurrentStamp;\r
  } else {\r
    ElapsedTimeValue = CurrentStamp - Private->ElapsedTime;\r
\r
    //\r
    // If elapsed time cannot fit in two bytes, set it to 0xffff.\r
    //\r
    if (ElapsedTimeValue > 0xffff) {\r
      ElapsedTimeValue = 0xffff;\r
    }\r
\r
    //\r
    // Save the elapsed time\r
    //\r
    Private->ElapsedTime = ElapsedTimeValue;\r
  }\r
}\r