[mirror_edk2.git] / NetworkPkg / DnsDxe / DnsImpl.c

/** @file\r
DnsDxe support functions implementation.\r
\r
Copyright (c) 2016 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "DnsImpl.h"\r
\r
/**\r
  Remove TokenEntry from TokenMap.\r
\r
  @param[in] TokenMap          All DNSv4 Token entrys.\r
  @param[in] TokenEntry        TokenEntry need to be removed.\r
\r
  @retval EFI_SUCCESS          Remove TokenEntry from TokenMap successfully.\r
  @retval EFI_NOT_FOUND        TokenEntry is not found in TokenMap.\r
\r
**/\r
EFI_STATUS\r
Dns4RemoveTokenEntry (\r
  IN NET_MAP           *TokenMap,\r
  IN DNS4_TOKEN_ENTRY  *TokenEntry\r
  )\r
{\r
  NET_MAP_ITEM  *Item;\r
\r
  //\r
  // Find the TokenEntry first.\r
  //\r
  Item = NetMapFindKey (TokenMap, (VOID *)TokenEntry);\r
\r
  if (Item != NULL) {\r
    //\r
    // Remove the TokenEntry if it's found in the map.\r
    //\r
    NetMapRemoveItem (TokenMap, Item, NULL);\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Remove TokenEntry from TokenMap.\r
\r
  @param[in] TokenMap           All DNSv6 Token entrys.\r
  @param[in] TokenEntry         TokenEntry need to be removed.\r
\r
  @retval EFI_SUCCESS           Remove TokenEntry from TokenMap successfully.\r
  @retval EFI_NOT_FOUND         TokenEntry is not found in TokenMap.\r
\r
**/\r
EFI_STATUS\r
Dns6RemoveTokenEntry (\r
  IN NET_MAP           *TokenMap,\r
  IN DNS6_TOKEN_ENTRY  *TokenEntry\r
  )\r
{\r
  NET_MAP_ITEM  *Item;\r
\r
  //\r
  // Find the TokenEntry first.\r
  //\r
  Item = NetMapFindKey (TokenMap, (VOID *)TokenEntry);\r
\r
  if (Item != NULL) {\r
    //\r
    // Remove the TokenEntry if it's found in the map.\r
    //\r
    NetMapRemoveItem (TokenMap, Item, NULL);\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  This function cancel the token specified by Arg in the Map.\r
\r
  @param[in]  Map             Pointer to the NET_MAP.\r
  @param[in]  Item            Pointer to the NET_MAP_ITEM.\r
  @param[in]  Arg             Pointer to the token to be cancelled. If NULL, all\r
                              the tokens in this Map will be cancelled.\r
                              This parameter is optional and may be NULL.\r
\r
  @retval EFI_SUCCESS         The token is cancelled if Arg is NULL, or the token\r
                              is not the same as that in the Item, if Arg is not\r
                              NULL.\r
  @retval EFI_ABORTED         Arg is not NULL, and the token specified by Arg is\r
                              cancelled.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
Dns4CancelTokens (\r
  IN NET_MAP       *Map,\r
  IN NET_MAP_ITEM  *Item,\r
  IN VOID          *Arg OPTIONAL\r
  )\r
{\r
  DNS4_TOKEN_ENTRY  *TokenEntry;\r
  NET_BUF           *Packet;\r
  UDP_IO            *UdpIo;\r
\r
  if ((Arg != NULL) && (Item->Key != Arg)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (Item->Value != NULL) {\r
    //\r
    // If the TokenEntry is a transmit TokenEntry, the corresponding Packet is recorded in\r
    // Item->Value.\r
    //\r
    Packet = (NET_BUF *)(Item->Value);\r
    UdpIo  = (UDP_IO *)(*((UINTN *)&Packet->ProtoData[0]));\r
\r
    UdpIoCancelSentDatagram (UdpIo, Packet);\r
  }\r
\r
  //\r
  // Remove TokenEntry from Dns4TxTokens.\r
  //\r
  TokenEntry = (DNS4_TOKEN_ENTRY *)Item->Key;\r
  if (Dns4RemoveTokenEntry (Map, TokenEntry) == EFI_SUCCESS) {\r
    TokenEntry->Token->Status = EFI_ABORTED;\r
    gBS->SignalEvent (TokenEntry->Token->Event);\r
    DispatchDpc ();\r
  }\r
\r
  if (Arg != NULL) {\r
    return EFI_ABORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This function cancel the token specified by Arg in the Map.\r
\r
  @param[in]  Map             Pointer to the NET_MAP.\r
  @param[in]  Item            Pointer to the NET_MAP_ITEM.\r
  @param[in]  Arg             Pointer to the token to be cancelled. If NULL, all\r
                              the tokens in this Map will be cancelled.\r
                              This parameter is optional and may be NULL.\r
\r
  @retval EFI_SUCCESS         The token is cancelled if Arg is NULL, or the token\r
                              is not the same as that in the Item, if Arg is not\r
                              NULL.\r
  @retval EFI_ABORTED         Arg is not NULL, and the token specified by Arg is\r
                              cancelled.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
Dns6CancelTokens (\r
  IN NET_MAP       *Map,\r
  IN NET_MAP_ITEM  *Item,\r
  IN VOID          *Arg OPTIONAL\r
  )\r
{\r
  DNS6_TOKEN_ENTRY  *TokenEntry;\r
  NET_BUF           *Packet;\r
  UDP_IO            *UdpIo;\r
\r
  if ((Arg != NULL) && (Item->Key != Arg)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (Item->Value != NULL) {\r
    //\r
    // If the TokenEntry is a transmit TokenEntry, the corresponding Packet is recorded in\r
    // Item->Value.\r
    //\r
    Packet = (NET_BUF *)(Item->Value);\r
    UdpIo  = (UDP_IO *)(*((UINTN *)&Packet->ProtoData[0]));\r
\r
    UdpIoCancelSentDatagram (UdpIo, Packet);\r
  }\r
\r
  //\r
  // Remove TokenEntry from Dns6TxTokens.\r
  //\r
  TokenEntry = (DNS6_TOKEN_ENTRY *)Item->Key;\r
  if (Dns6RemoveTokenEntry (Map, TokenEntry) == EFI_SUCCESS) {\r
    TokenEntry->Token->Status = EFI_ABORTED;\r
    gBS->SignalEvent (TokenEntry->Token->Event);\r
    DispatchDpc ();\r
  }\r
\r
  if (Arg != NULL) {\r
    return EFI_ABORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Get the TokenEntry from the TokensMap.\r
\r
  @param[in]  TokensMap           All DNSv4 Token entrys\r
  @param[in]  Token               Pointer to the token to be get.\r
  @param[out] TokenEntry          Pointer to TokenEntry corresponding Token.\r
\r
  @retval EFI_SUCCESS             Get the TokenEntry from the TokensMap successfully.\r
  @retval EFI_NOT_FOUND           TokenEntry is not found in TokenMap.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetDns4TokenEntry (\r
  IN     NET_MAP                    *TokensMap,\r
  IN     EFI_DNS4_COMPLETION_TOKEN  *Token,\r
  OUT DNS4_TOKEN_ENTRY              **TokenEntry\r
  )\r
{\r
  LIST_ENTRY  *Entry;\r
\r
  NET_MAP_ITEM  *Item;\r
\r
  NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {\r
    Item        = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
    *TokenEntry = (DNS4_TOKEN_ENTRY *)(Item->Key);\r
    if ((*TokenEntry)->Token == Token) {\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  *TokenEntry = NULL;\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Get the TokenEntry from the TokensMap.\r
\r
  @param[in]  TokensMap           All DNSv6 Token entrys\r
  @param[in]  Token               Pointer to the token to be get.\r
  @param[out] TokenEntry          Pointer to TokenEntry corresponding Token.\r
\r
  @retval EFI_SUCCESS             Get the TokenEntry from the TokensMap successfully.\r
  @retval EFI_NOT_FOUND           TokenEntry is not found in TokenMap.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetDns6TokenEntry (\r
  IN     NET_MAP                    *TokensMap,\r
  IN     EFI_DNS6_COMPLETION_TOKEN  *Token,\r
  OUT DNS6_TOKEN_ENTRY              **TokenEntry\r
  )\r
{\r
  LIST_ENTRY  *Entry;\r
\r
  NET_MAP_ITEM  *Item;\r
\r
  NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {\r
    Item        = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
    *TokenEntry = (DNS6_TOKEN_ENTRY *)(Item->Key);\r
    if ((*TokenEntry)->Token == Token) {\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  *TokenEntry = NULL;\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Cancel DNS4 tokens from the DNS4 instance.\r
\r
  @param[in]  Instance           Pointer to the DNS instance context data.\r
  @param[in]  Token              Pointer to the token to be canceled. If NULL, all\r
                                 tokens in this instance will be cancelled.\r
                                 This parameter is optional and may be NULL.\r
\r
  @retval EFI_SUCCESS            The Token is cancelled.\r
  @retval EFI_NOT_FOUND          The Token is not found.\r
\r
**/\r
EFI_STATUS\r
Dns4InstanceCancelToken (\r
  IN DNS_INSTANCE               *Instance,\r
  IN EFI_DNS4_COMPLETION_TOKEN  *Token\r
  )\r
{\r
  EFI_STATUS        Status;\r
  DNS4_TOKEN_ENTRY  *TokenEntry;\r
\r
  TokenEntry = NULL;\r
\r
  if (Token != NULL  ) {\r
    Status = GetDns4TokenEntry (&Instance->Dns4TxTokens, Token, &TokenEntry);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  } else {\r
    TokenEntry = NULL;\r
  }\r
\r
  //\r
  // Cancel this TokenEntry from the Dns4TxTokens map.\r
  //\r
  Status = NetMapIterate (&Instance->Dns4TxTokens, Dns4CancelTokens, TokenEntry);\r
\r
  if ((TokenEntry != NULL) && (Status == EFI_ABORTED)) {\r
    //\r
    // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from\r
    // the Dns4TxTokens and returns success.\r
    //\r
    if (NetMapIsEmpty (&Instance->Dns4TxTokens)) {\r
      Instance->UdpIo->Protocol.Udp4->Cancel (Instance->UdpIo->Protocol.Udp4, &Instance->UdpIo->RecvRequest->Token.Udp4);\r
    }\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  ASSERT ((TokenEntry != NULL) || (0 == NetMapGetCount (&Instance->Dns4TxTokens)));\r
\r
  if (NetMapIsEmpty (&Instance->Dns4TxTokens)) {\r
    Instance->UdpIo->Protocol.Udp4->Cancel (Instance->UdpIo->Protocol.Udp4, &Instance->UdpIo->RecvRequest->Token.Udp4);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Cancel DNS6 tokens from the DNS6 instance.\r
\r
  @param[in]  Instance           Pointer to the DNS instance context data.\r
  @param[in]  Token              Pointer to the token to be canceled. If NULL, all\r
                                 tokens in this instance will be cancelled.\r
                                 This parameter is optional and may be NULL.\r
\r
  @retval EFI_SUCCESS            The Token is cancelled.\r
  @retval EFI_NOT_FOUND          The Token is not found.\r
\r
**/\r
EFI_STATUS\r
Dns6InstanceCancelToken (\r
  IN DNS_INSTANCE               *Instance,\r
  IN EFI_DNS6_COMPLETION_TOKEN  *Token\r
  )\r
{\r
  EFI_STATUS        Status;\r
  DNS6_TOKEN_ENTRY  *TokenEntry;\r
\r
  TokenEntry = NULL;\r
\r
  if (Token != NULL  ) {\r
    Status = GetDns6TokenEntry (&Instance->Dns6TxTokens, Token, &TokenEntry);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  } else {\r
    TokenEntry = NULL;\r
  }\r
\r
  //\r
  // Cancel this TokenEntry from the Dns6TxTokens map.\r
  //\r
  Status = NetMapIterate (&Instance->Dns6TxTokens, Dns6CancelTokens, TokenEntry);\r
\r
  if ((TokenEntry != NULL) && (Status == EFI_ABORTED)) {\r
    //\r
    // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from\r
    // the Dns6TxTokens and returns success.\r
    //\r
    if (NetMapIsEmpty (&Instance->Dns6TxTokens)) {\r
      Instance->UdpIo->Protocol.Udp6->Cancel (Instance->UdpIo->Protocol.Udp6, &Instance->UdpIo->RecvRequest->Token.Udp6);\r
    }\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  ASSERT ((TokenEntry != NULL) || (0 == NetMapGetCount (&Instance->Dns6TxTokens)));\r
\r
  if (NetMapIsEmpty (&Instance->Dns6TxTokens)) {\r
    Instance->UdpIo->Protocol.Udp6->Cancel (Instance->UdpIo->Protocol.Udp6, &Instance->UdpIo->RecvRequest->Token.Udp6);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Free the resource related to the configure parameters.\r
\r
  @param  Config                 The DNS configure data\r
\r
**/\r
VOID\r
Dns4CleanConfigure (\r
  IN OUT EFI_DNS4_CONFIG_DATA  *Config\r
  )\r
{\r
  if (Config->DnsServerList != NULL) {\r
    FreePool (Config->DnsServerList);\r
  }\r
\r
  ZeroMem (Config, sizeof (EFI_DNS4_CONFIG_DATA));\r
}\r
\r
/**\r
  Free the resource related to the configure parameters.\r
\r
  @param  Config                 The DNS configure data\r
\r
**/\r
VOID\r
Dns6CleanConfigure (\r
  IN OUT EFI_DNS6_CONFIG_DATA  *Config\r
  )\r
{\r
  if (Config->DnsServerList != NULL) {\r
    FreePool (Config->DnsServerList);\r
  }\r
\r
  ZeroMem (Config, sizeof (EFI_DNS6_CONFIG_DATA));\r
}\r
\r
/**\r
  Allocate memory for configure parameter such as timeout value for Dst,\r
  then copy the configure parameter from Src to Dst.\r
\r
  @param[out]  Dst               The destination DHCP configure data.\r
  @param[in]   Src               The source DHCP configure data.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Failed to allocate memory.\r
  @retval EFI_SUCCESS            The configure is copied.\r
\r
**/\r
EFI_STATUS\r
Dns4CopyConfigure (\r
  OUT EFI_DNS4_CONFIG_DATA  *Dst,\r
  IN  EFI_DNS4_CONFIG_DATA  *Src\r
  )\r
{\r
  UINTN   Len;\r
  UINT32  Index;\r
\r
  CopyMem (Dst, Src, sizeof (*Dst));\r
  Dst->DnsServerList = NULL;\r
\r
  //\r
  // Allocate a memory then copy DnsServerList to it\r
  //\r
  if (Src->DnsServerList != NULL) {\r
    Len                = Src->DnsServerListCount * sizeof (EFI_IPv4_ADDRESS);\r
    Dst->DnsServerList = AllocatePool (Len);\r
    if (Dst->DnsServerList == NULL) {\r
      Dns4CleanConfigure (Dst);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    for (Index = 0; Index < Src->DnsServerListCount; Index++) {\r
      CopyMem (&Dst->DnsServerList[Index], &Src->DnsServerList[Index], sizeof (EFI_IPv4_ADDRESS));\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Allocate memory for configure parameter such as timeout value for Dst,\r
  then copy the configure parameter from Src to Dst.\r
\r
  @param[out]  Dst               The destination DHCP configure data.\r
  @param[in]   Src               The source DHCP configure data.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Failed to allocate memory.\r
  @retval EFI_SUCCESS            The configure is copied.\r
\r
**/\r
EFI_STATUS\r
Dns6CopyConfigure (\r
  OUT EFI_DNS6_CONFIG_DATA  *Dst,\r
  IN  EFI_DNS6_CONFIG_DATA  *Src\r
  )\r
{\r
  UINTN   Len;\r
  UINT32  Index;\r
\r
  CopyMem (Dst, Src, sizeof (*Dst));\r
  Dst->DnsServerList = NULL;\r
\r
  //\r
  // Allocate a memory then copy DnsServerList to it\r
  //\r
  if (Src->DnsServerList != NULL) {\r
    Len                = Src->DnsServerCount * sizeof (EFI_IPv6_ADDRESS);\r
    Dst->DnsServerList = AllocatePool (Len);\r
    if (Dst->DnsServerList == NULL) {\r
      Dns6CleanConfigure (Dst);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    for (Index = 0; Index < Src->DnsServerCount; Index++) {\r
      CopyMem (&Dst->DnsServerList[Index], &Src->DnsServerList[Index], sizeof (EFI_IPv6_ADDRESS));\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Callback of Dns packet. Does nothing.\r
\r
  @param Arg           The context.\r
\r
**/\r
VOID\r
EFIAPI\r
DnsDummyExtFree (\r
  IN VOID  *Arg\r
  )\r
{\r
}\r
\r
/**\r
  Poll the UDP to get the IP4 default address, which may be retrieved\r
  by DHCP.\r
\r
  The default time out value is 5 seconds. If IP has retrieved the default address,\r
  the UDP is reconfigured.\r
\r
  @param  Instance               The DNS instance\r
  @param  UdpIo                  The UDP_IO to poll\r
  @param  UdpCfgData             The UDP configure data to reconfigure the UDP_IO\r
\r
  @retval TRUE                   The default address is retrieved and UDP is reconfigured.\r
  @retval FALSE                  Some error occurred.\r
\r
**/\r
BOOLEAN\r
Dns4GetMapping (\r
  IN DNS_INSTANCE          *Instance,\r
  IN UDP_IO                *UdpIo,\r
  IN EFI_UDP4_CONFIG_DATA  *UdpCfgData\r
  )\r
{\r
  DNS_SERVICE        *Service;\r
  EFI_IP4_MODE_DATA  Ip4Mode;\r
  EFI_UDP4_PROTOCOL  *Udp;\r
  EFI_STATUS         Status;\r
\r
  ASSERT (Instance->Dns4CfgData.UseDefaultSetting);\r
\r
  Service = Instance->Service;\r
  Udp     = UdpIo->Protocol.Udp4;\r
\r
  Status = gBS->SetTimer (\r
                  Service->TimerToGetMap,\r
                  TimerRelative,\r
                  DNS_TIME_TO_GETMAP * TICKS_PER_SECOND\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return FALSE;\r
  }\r
\r
  while (EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {\r
    Udp->Poll (Udp);\r
\r
    if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip4Mode, NULL, NULL)) &&\r
        Ip4Mode.IsConfigured)\r
    {\r
      Udp->Configure (Udp, NULL);\r
      return (BOOLEAN)(Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS);\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Configure the opened Udp6 instance until the corresponding Ip6 instance\r
  has been configured.\r
\r
  @param  Instance               The DNS instance\r
  @param  UdpIo                  The UDP_IO to poll\r
  @param  UdpCfgData             The UDP configure data to reconfigure the UDP_IO\r
\r
  @retval TRUE                   Configure the Udp6 instance successfully.\r
  @retval FALSE                  Some error occurred.\r
\r
**/\r
BOOLEAN\r
Dns6GetMapping (\r
  IN DNS_INSTANCE          *Instance,\r
  IN UDP_IO                *UdpIo,\r
  IN EFI_UDP6_CONFIG_DATA  *UdpCfgData\r
  )\r
{\r
  DNS_SERVICE        *Service;\r
  EFI_IP6_MODE_DATA  Ip6Mode;\r
  EFI_UDP6_PROTOCOL  *Udp;\r
  EFI_STATUS         Status;\r
\r
  Service = Instance->Service;\r
  Udp     = UdpIo->Protocol.Udp6;\r
\r
  Status = gBS->SetTimer (\r
                  Service->TimerToGetMap,\r
                  TimerRelative,\r
                  DNS_TIME_TO_GETMAP * TICKS_PER_SECOND\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return FALSE;\r
  }\r
\r
  while (EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {\r
    Udp->Poll (Udp);\r
\r
    if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip6Mode, NULL, NULL))) {\r
      if (Ip6Mode.AddressList != NULL) {\r
        FreePool (Ip6Mode.AddressList);\r
      }\r
\r
      if (Ip6Mode.GroupTable != NULL) {\r
        FreePool (Ip6Mode.GroupTable);\r
      }\r
\r
      if (Ip6Mode.RouteTable != NULL) {\r
        FreePool (Ip6Mode.RouteTable);\r
      }\r
\r
      if (Ip6Mode.NeighborCache != NULL) {\r
        FreePool (Ip6Mode.NeighborCache);\r
      }\r
\r
      if (Ip6Mode.PrefixTable != NULL) {\r
        FreePool (Ip6Mode.PrefixTable);\r
      }\r
\r
      if (Ip6Mode.IcmpTypeList != NULL) {\r
        FreePool (Ip6Mode.IcmpTypeList);\r
      }\r
\r
      if (!Ip6Mode.IsStarted || Ip6Mode.IsConfigured) {\r
        Udp->Configure (Udp, NULL);\r
        if (Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS) {\r
          return TRUE;\r
        }\r
      }\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Configure the UDP.\r
\r
  @param  Instance               The DNS session\r
  @param  UdpIo                  The UDP_IO instance\r
\r
  @retval EFI_SUCCESS            The UDP is successfully configured for the\r
                                 session.\r
\r
**/\r
EFI_STATUS\r
Dns4ConfigUdp (\r
  IN DNS_INSTANCE  *Instance,\r
  IN UDP_IO        *UdpIo\r
  )\r
{\r
  EFI_DNS4_CONFIG_DATA  *Config;\r
  EFI_UDP4_CONFIG_DATA  UdpConfig;\r
  EFI_STATUS            Status;\r
\r
  Config = &Instance->Dns4CfgData;\r
\r
  UdpConfig.AcceptBroadcast    = FALSE;\r
  UdpConfig.AcceptPromiscuous  = FALSE;\r
  UdpConfig.AcceptAnyPort      = FALSE;\r
  UdpConfig.AllowDuplicatePort = FALSE;\r
  UdpConfig.TypeOfService      = 0;\r
  UdpConfig.TimeToLive         = 128;\r
  UdpConfig.DoNotFragment      = FALSE;\r
  UdpConfig.ReceiveTimeout     = 0;\r
  UdpConfig.TransmitTimeout    = 0;\r
  UdpConfig.UseDefaultAddress  = Config->UseDefaultSetting;\r
  UdpConfig.SubnetMask         = Config->SubnetMask;\r
  UdpConfig.StationPort        = Config->LocalPort;\r
  UdpConfig.RemotePort         = DNS_SERVER_PORT;\r
\r
  CopyMem (&UdpConfig.StationAddress, &Config->StationIp, sizeof (EFI_IPv4_ADDRESS));\r
  CopyMem (&UdpConfig.RemoteAddress, &Instance->SessionDnsServer.v4, sizeof (EFI_IPv4_ADDRESS));\r
\r
  Status = UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, &UdpConfig);\r
\r
  if ((Status == EFI_NO_MAPPING) && Dns4GetMapping (Instance, UdpIo, &UdpConfig)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Configure the UDP.\r
\r
  @param  Instance               The DNS session\r
  @param  UdpIo                  The UDP_IO instance\r
\r
  @retval EFI_SUCCESS            The UDP is successfully configured for the\r
                                 session.\r
\r
**/\r
EFI_STATUS\r
Dns6ConfigUdp (\r
  IN DNS_INSTANCE  *Instance,\r
  IN UDP_IO        *UdpIo\r
  )\r
{\r
  EFI_DNS6_CONFIG_DATA  *Config;\r
  EFI_UDP6_CONFIG_DATA  UdpConfig;\r
  EFI_STATUS            Status;\r
\r
  Config = &Instance->Dns6CfgData;\r
\r
  UdpConfig.AcceptPromiscuous  = FALSE;\r
  UdpConfig.AcceptAnyPort      = FALSE;\r
  UdpConfig.AllowDuplicatePort = FALSE;\r
  UdpConfig.TrafficClass       = 0;\r
  UdpConfig.HopLimit           = 128;\r
  UdpConfig.ReceiveTimeout     = 0;\r
  UdpConfig.TransmitTimeout    = 0;\r
  UdpConfig.StationPort        = Config->LocalPort;\r
  UdpConfig.RemotePort         = DNS_SERVER_PORT;\r
  CopyMem (&UdpConfig.StationAddress, &Config->StationIp, sizeof (EFI_IPv6_ADDRESS));\r
  CopyMem (&UdpConfig.RemoteAddress, &Instance->SessionDnsServer.v6, sizeof (EFI_IPv6_ADDRESS));\r
\r
  Status = UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, &UdpConfig);\r
\r
  if ((Status == EFI_NO_MAPPING) && Dns6GetMapping (Instance, UdpIo, &UdpConfig)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Update Dns4 cache to shared list of caches of all DNSv4 instances.\r
\r
  @param  Dns4CacheList      All Dns4 cache list.\r
  @param  DeleteFlag         If FALSE, this function is to add one entry to the DNS Cache.\r
                             If TRUE, this function will delete matching DNS Cache entry.\r
  @param  Override           If TRUE, the matching DNS cache entry will be overwritten with the supplied parameter.\r
                             If FALSE, EFI_ACCESS_DENIED will be returned if the entry to be added is already exists.\r
  @param  DnsCacheEntry      Entry Pointer to DNS Cache entry.\r
\r
  @retval EFI_SUCCESS        Update Dns4 cache successfully.\r
  @retval Others             Failed to update Dns4 cache.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
UpdateDns4Cache (\r
  IN LIST_ENTRY            *Dns4CacheList,\r
  IN BOOLEAN               DeleteFlag,\r
  IN BOOLEAN               Override,\r
  IN EFI_DNS4_CACHE_ENTRY  DnsCacheEntry\r
  )\r
{\r
  DNS4_CACHE  *NewDnsCache;\r
  DNS4_CACHE  *Item;\r
  LIST_ENTRY  *Entry;\r
  LIST_ENTRY  *Next;\r
\r
  NewDnsCache = NULL;\r
  Item        = NULL;\r
\r
  //\r
  // Search the database for the matching EFI_DNS_CACHE_ENTRY\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns4CacheList) {\r
    Item = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);\r
    if ((StrCmp (DnsCacheEntry.HostName, Item->DnsCache.HostName) == 0) && \\r
        (CompareMem (DnsCacheEntry.IpAddress, Item->DnsCache.IpAddress, sizeof (EFI_IPv4_ADDRESS)) == 0))\r
    {\r
      //\r
      // This is the Dns cache entry\r
      //\r
      if (DeleteFlag) {\r
        //\r
        // Delete matching DNS Cache entry\r
        //\r
        RemoveEntryList (&Item->AllCacheLink);\r
\r
        FreePool (Item->DnsCache.HostName);\r
        FreePool (Item->DnsCache.IpAddress);\r
        FreePool (Item);\r
\r
        return EFI_SUCCESS;\r
      } else if (Override) {\r
        //\r
        // Update this one\r
        //\r
        Item->DnsCache.Timeout = DnsCacheEntry.Timeout;\r
\r
        return EFI_SUCCESS;\r
      } else {\r
        return EFI_ACCESS_DENIED;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Add new one\r
  //\r
  NewDnsCache = AllocatePool (sizeof (DNS4_CACHE));\r
  if (NewDnsCache == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  InitializeListHead (&NewDnsCache->AllCacheLink);\r
\r
  NewDnsCache->DnsCache.HostName = AllocatePool (StrSize (DnsCacheEntry.HostName));\r
  if (NewDnsCache->DnsCache.HostName == NULL) {\r
    FreePool (NewDnsCache);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CopyMem (NewDnsCache->DnsCache.HostName, DnsCacheEntry.HostName, StrSize (DnsCacheEntry.HostName));\r
\r
  NewDnsCache->DnsCache.IpAddress = AllocatePool (sizeof (EFI_IPv4_ADDRESS));\r
  if (NewDnsCache->DnsCache.IpAddress == NULL) {\r
    FreePool (NewDnsCache->DnsCache.HostName);\r
    FreePool (NewDnsCache);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CopyMem (NewDnsCache->DnsCache.IpAddress, DnsCacheEntry.IpAddress, sizeof (EFI_IPv4_ADDRESS));\r
\r
  NewDnsCache->DnsCache.Timeout = DnsCacheEntry.Timeout;\r
\r
  InsertTailList (Dns4CacheList, &NewDnsCache->AllCacheLink);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Update Dns6 cache to shared list of caches of all DNSv6 instances.\r
\r
  @param  Dns6CacheList      All Dns6 cache list.\r
  @param  DeleteFlag         If FALSE, this function is to add one entry to the DNS Cache.\r
                             If TRUE, this function will delete matching DNS Cache entry.\r
  @param  Override           If TRUE, the matching DNS cache entry will be overwritten with the supplied parameter.\r
                             If FALSE, EFI_ACCESS_DENIED will be returned if the entry to be added is already exists.\r
  @param  DnsCacheEntry      Entry Pointer to DNS Cache entry.\r
\r
  @retval EFI_SUCCESS        Update Dns6 cache successfully.\r
  @retval Others             Failed to update Dns6 cache.\r
**/\r
EFI_STATUS\r
EFIAPI\r
UpdateDns6Cache (\r
  IN LIST_ENTRY            *Dns6CacheList,\r
  IN BOOLEAN               DeleteFlag,\r
  IN BOOLEAN               Override,\r
  IN EFI_DNS6_CACHE_ENTRY  DnsCacheEntry\r
  )\r
{\r
  DNS6_CACHE  *NewDnsCache;\r
  DNS6_CACHE  *Item;\r
  LIST_ENTRY  *Entry;\r
  LIST_ENTRY  *Next;\r
\r
  NewDnsCache = NULL;\r
  Item        = NULL;\r
\r
  //\r
  // Search the database for the matching EFI_DNS_CACHE_ENTRY\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns6CacheList) {\r
    Item = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);\r
    if ((StrCmp (DnsCacheEntry.HostName, Item->DnsCache.HostName) == 0) && \\r
        (CompareMem (DnsCacheEntry.IpAddress, Item->DnsCache.IpAddress, sizeof (EFI_IPv6_ADDRESS)) == 0))\r
    {\r
      //\r
      // This is the Dns cache entry\r
      //\r
      if (DeleteFlag) {\r
        //\r
        // Delete matching DNS Cache entry\r
        //\r
        RemoveEntryList (&Item->AllCacheLink);\r
\r
        FreePool (Item->DnsCache.HostName);\r
        FreePool (Item->DnsCache.IpAddress);\r
        FreePool (Item);\r
\r
        return EFI_SUCCESS;\r
      } else if (Override) {\r
        //\r
        // Update this one\r
        //\r
        Item->DnsCache.Timeout = DnsCacheEntry.Timeout;\r
\r
        return EFI_SUCCESS;\r
      } else {\r
        return EFI_ACCESS_DENIED;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Add new one\r
  //\r
  NewDnsCache = AllocatePool (sizeof (DNS6_CACHE));\r
  if (NewDnsCache == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  InitializeListHead (&NewDnsCache->AllCacheLink);\r
\r
  NewDnsCache->DnsCache.HostName = AllocatePool (StrSize (DnsCacheEntry.HostName));\r
  if (NewDnsCache->DnsCache.HostName == NULL) {\r
    FreePool (NewDnsCache);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CopyMem (NewDnsCache->DnsCache.HostName, DnsCacheEntry.HostName, StrSize (DnsCacheEntry.HostName));\r
\r
  NewDnsCache->DnsCache.IpAddress = AllocatePool (sizeof (EFI_IPv6_ADDRESS));\r
  if (NewDnsCache->DnsCache.IpAddress == NULL) {\r
    FreePool (NewDnsCache->DnsCache.HostName);\r
    FreePool (NewDnsCache);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CopyMem (NewDnsCache->DnsCache.IpAddress, DnsCacheEntry.IpAddress, sizeof (EFI_IPv6_ADDRESS));\r
\r
  NewDnsCache->DnsCache.Timeout = DnsCacheEntry.Timeout;\r
\r
  InsertTailList (Dns6CacheList, &NewDnsCache->AllCacheLink);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Add Dns4 ServerIp to common list of addresses of all configured DNSv4 server.\r
\r
  @param  Dns4ServerList    Common list of addresses of all configured DNSv4 server.\r
  @param  ServerIp          DNS server Ip.\r
\r
  @retval EFI_SUCCESS       Add Dns4 ServerIp to common list successfully.\r
  @retval Others            Failed to add Dns4 ServerIp to common list.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AddDns4ServerIp (\r
  IN LIST_ENTRY        *Dns4ServerList,\r
  IN EFI_IPv4_ADDRESS  ServerIp\r
  )\r
{\r
  DNS4_SERVER_IP  *NewServerIp;\r
  DNS4_SERVER_IP  *Item;\r
  LIST_ENTRY      *Entry;\r
  LIST_ENTRY      *Next;\r
\r
  NewServerIp = NULL;\r
  Item        = NULL;\r
\r
  //\r
  // Search the database for the matching ServerIp\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns4ServerList) {\r
    Item = NET_LIST_USER_STRUCT (Entry, DNS4_SERVER_IP, AllServerLink);\r
    if (CompareMem (&Item->Dns4ServerIp, &ServerIp, sizeof (EFI_IPv4_ADDRESS)) == 0) {\r
      //\r
      // Already done.\r
      //\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  //\r
  // Add new one\r
  //\r
  NewServerIp = AllocatePool (sizeof (DNS4_SERVER_IP));\r
  if (NewServerIp == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  InitializeListHead (&NewServerIp->AllServerLink);\r
\r
  CopyMem (&NewServerIp->Dns4ServerIp, &ServerIp, sizeof (EFI_IPv4_ADDRESS));\r
\r
  InsertTailList (Dns4ServerList, &NewServerIp->AllServerLink);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Add Dns6 ServerIp to common list of addresses of all configured DNSv6 server.\r
\r
  @param  Dns6ServerList    Common list of addresses of all configured DNSv6 server.\r
  @param  ServerIp          DNS server Ip.\r
\r
  @retval EFI_SUCCESS       Add Dns6 ServerIp to common list successfully.\r
  @retval Others            Failed to add Dns6 ServerIp to common list.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AddDns6ServerIp (\r
  IN LIST_ENTRY        *Dns6ServerList,\r
  IN EFI_IPv6_ADDRESS  ServerIp\r
  )\r
{\r
  DNS6_SERVER_IP  *NewServerIp;\r
  DNS6_SERVER_IP  *Item;\r
  LIST_ENTRY      *Entry;\r
  LIST_ENTRY      *Next;\r
\r
  NewServerIp = NULL;\r
  Item        = NULL;\r
\r
  //\r
  // Search the database for the matching ServerIp\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns6ServerList) {\r
    Item = NET_LIST_USER_STRUCT (Entry, DNS6_SERVER_IP, AllServerLink);\r
    if (CompareMem (&Item->Dns6ServerIp, &ServerIp, sizeof (EFI_IPv6_ADDRESS)) == 0) {\r
      //\r
      // Already done.\r
      //\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  //\r
  // Add new one\r
  //\r
  NewServerIp = AllocatePool (sizeof (DNS6_SERVER_IP));\r
  if (NewServerIp == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  InitializeListHead (&NewServerIp->AllServerLink);\r
\r
  CopyMem (&NewServerIp->Dns6ServerIp, &ServerIp, sizeof (EFI_IPv6_ADDRESS));\r
\r
  InsertTailList (Dns6ServerList, &NewServerIp->AllServerLink);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Find out whether the response is valid or invalid.\r
\r
  @param  TokensMap       All DNS transmittal Tokens entry.\r
  @param  Identification  Identification for queried packet.\r
  @param  Type            Type for queried packet.\r
  @param  Class           Class for queried packet.\r
  @param  Item            Return corresponding Token entry.\r
\r
  @retval TRUE            The response is valid.\r
  @retval FALSE           The response is invalid.\r
\r
**/\r
BOOLEAN\r
IsValidDnsResponse (\r
  IN     NET_MAP    *TokensMap,\r
  IN     UINT16     Identification,\r
  IN     UINT16     Type,\r
  IN     UINT16     Class,\r
  OUT NET_MAP_ITEM  **Item\r
  )\r
{\r
  LIST_ENTRY  *Entry;\r
\r
  NET_BUF            *Packet;\r
  UINT8              *TxString;\r
  DNS_HEADER         *DnsHeader;\r
  CHAR8              *QueryName;\r
  DNS_QUERY_SECTION  *QuerySection;\r
\r
  NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {\r
    *Item  = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
    Packet = (NET_BUF *)((*Item)->Value);\r
    if (Packet == NULL) {\r
      continue;\r
    } else {\r
      TxString = NetbufGetByte (Packet, 0, NULL);\r
      ASSERT (TxString != NULL);\r
      DnsHeader    = (DNS_HEADER *)TxString;\r
      QueryName    = (CHAR8 *)(TxString + sizeof (*DnsHeader));\r
      QuerySection = (DNS_QUERY_SECTION *)(QueryName + AsciiStrLen (QueryName) + 1);\r
\r
      if ((NTOHS (DnsHeader->Identification) == Identification) &&\r
          (NTOHS (QuerySection->Type) == Type) &&\r
          (NTOHS (QuerySection->Class) == Class))\r
      {\r
        return TRUE;\r
      }\r
    }\r
  }\r
\r
  *Item = NULL;\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Parse Dns Response.\r
\r
  @param  Instance              The DNS instance\r
  @param  RxString              Received buffer.\r
  @param  Length                Received buffer length.\r
  @param  Completed             Flag to indicate that Dns response is valid.\r
\r
  @retval EFI_SUCCESS           Parse Dns Response successfully.\r
  @retval Others                Failed to parse Dns Response.\r
\r
**/\r
EFI_STATUS\r
ParseDnsResponse (\r
  IN OUT DNS_INSTANCE  *Instance,\r
  IN     UINT8         *RxString,\r
  IN     UINT32        Length,\r
  OUT BOOLEAN          *Completed\r
  )\r
{\r
  DNS_HEADER  *DnsHeader;\r
\r
  CHAR8              *QueryName;\r
  UINT32             QueryNameLen;\r
  DNS_QUERY_SECTION  *QuerySection;\r
\r
  CHAR8               *AnswerName;\r
  DNS_ANSWER_SECTION  *AnswerSection;\r
  UINT8               *AnswerData;\r
\r
  NET_MAP_ITEM      *Item;\r
  DNS4_TOKEN_ENTRY  *Dns4TokenEntry;\r
  DNS6_TOKEN_ENTRY  *Dns6TokenEntry;\r
\r
  UINT32  IpCount;\r
  UINT32  RRCount;\r
  UINT32  AnswerSectionNum;\r
  UINT32  CNameTtl;\r
\r
  EFI_IPv4_ADDRESS  *HostAddr4;\r
  EFI_IPv6_ADDRESS  *HostAddr6;\r
\r
  EFI_DNS4_CACHE_ENTRY  *Dns4CacheEntry;\r
  EFI_DNS6_CACHE_ENTRY  *Dns6CacheEntry;\r
\r
  DNS_RESOURCE_RECORD   *Dns4RR;\r
  DNS6_RESOURCE_RECORD  *Dns6RR;\r
\r
  EFI_STATUS  Status;\r
  UINT32      RemainingLength;\r
\r
  EFI_TPL  OldTpl;\r
\r
  Item           = NULL;\r
  Dns4TokenEntry = NULL;\r
  Dns6TokenEntry = NULL;\r
\r
  IpCount          = 0;\r
  RRCount          = 0;\r
  AnswerSectionNum = 0;\r
  CNameTtl         = 0;\r
\r
  HostAddr4 = NULL;\r
  HostAddr6 = NULL;\r
\r
  Dns4CacheEntry = NULL;\r
  Dns6CacheEntry = NULL;\r
\r
  Dns4RR = NULL;\r
  Dns6RR = NULL;\r
\r
  *Completed      = TRUE;\r
  Status          = EFI_SUCCESS;\r
  RemainingLength = Length;\r
\r
  //\r
  // Check whether the remaining packet length is available or not.\r
  //\r
  if (RemainingLength <= sizeof (DNS_HEADER)) {\r
    *Completed = FALSE;\r
    return EFI_ABORTED;\r
  } else {\r
    RemainingLength -= sizeof (DNS_HEADER);\r
  }\r
\r
  //\r
  // Get header\r
  //\r
  DnsHeader = (DNS_HEADER *)RxString;\r
\r
  DnsHeader->Identification = NTOHS (DnsHeader->Identification);\r
  DnsHeader->Flags.Uint16   = NTOHS (DnsHeader->Flags.Uint16);\r
  DnsHeader->QuestionsNum   = NTOHS (DnsHeader->QuestionsNum);\r
  DnsHeader->AnswersNum     = NTOHS (DnsHeader->AnswersNum);\r
  DnsHeader->AuthorityNum   = NTOHS (DnsHeader->AuthorityNum);\r
  DnsHeader->AditionalNum   = NTOHS (DnsHeader->AditionalNum);\r
\r
  //\r
  // There is always one QuestionsNum in DNS message. The capability to handle more\r
  // than one requires to redesign the message format. Currently, it's not supported.\r
  //\r
  if (DnsHeader->QuestionsNum > 1) {\r
    *Completed = FALSE;\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Get Query name\r
  //\r
  QueryName = (CHAR8 *)(RxString + sizeof (*DnsHeader));\r
\r
  QueryNameLen = (UINT32)AsciiStrLen (QueryName) + 1;\r
\r
  //\r
  // Check whether the remaining packet length is available or not.\r
  //\r
  if (RemainingLength <= QueryNameLen + sizeof (DNS_QUERY_SECTION)) {\r
    *Completed = FALSE;\r
    return EFI_ABORTED;\r
  } else {\r
    RemainingLength -= (QueryNameLen + sizeof (DNS_QUERY_SECTION));\r
  }\r
\r
  //\r
  // Get query section\r
  //\r
  QuerySection        = (DNS_QUERY_SECTION *)(QueryName + QueryNameLen);\r
  QuerySection->Type  = NTOHS (QuerySection->Type);\r
  QuerySection->Class = NTOHS (QuerySection->Class);\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  //\r
  // Check DnsResponse Validity, if so, also get a valid NET_MAP_ITEM.\r
  //\r
  if (Instance->Service->IpVersion == IP_VERSION_4) {\r
    if (!IsValidDnsResponse (\r
           &Instance->Dns4TxTokens,\r
           DnsHeader->Identification,\r
           QuerySection->Type,\r
           QuerySection->Class,\r
           &Item\r
           ))\r
    {\r
      *Completed = FALSE;\r
      Status     = EFI_ABORTED;\r
      goto ON_EXIT;\r
    }\r
\r
    ASSERT (Item != NULL);\r
    Dns4TokenEntry = (DNS4_TOKEN_ENTRY *)(Item->Key);\r
  } else {\r
    if (!IsValidDnsResponse (\r
           &Instance->Dns6TxTokens,\r
           DnsHeader->Identification,\r
           QuerySection->Type,\r
           QuerySection->Class,\r
           &Item\r
           ))\r
    {\r
      *Completed = FALSE;\r
      Status     = EFI_ABORTED;\r
      goto ON_EXIT;\r
    }\r
\r
    ASSERT (Item != NULL);\r
    Dns6TokenEntry = (DNS6_TOKEN_ENTRY *)(Item->Key);\r
  }\r
\r
  //\r
  // Continue Check Some Errors.\r
  //\r
  if ((DnsHeader->Flags.Bits.RCode != DNS_FLAGS_RCODE_NO_ERROR) || (DnsHeader->AnswersNum < 1) || \\r
      (DnsHeader->Flags.Bits.QR != DNS_FLAGS_QR_RESPONSE))\r
  {\r
    //\r
    // The domain name referenced in the query does not exist.\r
    //\r
    if (DnsHeader->Flags.Bits.RCode == DNS_FLAGS_RCODE_NAME_ERROR) {\r
      Status = EFI_NOT_FOUND;\r
    } else {\r
      Status = EFI_DEVICE_ERROR;\r
    }\r
\r
    goto ON_COMPLETE;\r
  }\r
\r
  //\r
  // Do some buffer allocations.\r
  //\r
  if (Instance->Service->IpVersion == IP_VERSION_4) {\r
    ASSERT (Dns4TokenEntry != NULL);\r
\r
    if (Dns4TokenEntry->GeneralLookUp) {\r
      //\r
      // It's the GeneralLookUp querying.\r
      //\r
      Dns4TokenEntry->Token->RspData.GLookupData = AllocateZeroPool (sizeof (DNS_RESOURCE_RECORD));\r
      if (Dns4TokenEntry->Token->RspData.GLookupData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
\r
      Dns4TokenEntry->Token->RspData.GLookupData->RRList = AllocateZeroPool (DnsHeader->AnswersNum * sizeof (DNS_RESOURCE_RECORD));\r
      if (Dns4TokenEntry->Token->RspData.GLookupData->RRList == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
    } else {\r
      //\r
      // It's not the GeneralLookUp querying. Check the Query type.\r
      //\r
      if (QuerySection->Type == DNS_TYPE_A) {\r
        Dns4TokenEntry->Token->RspData.H2AData = AllocateZeroPool (sizeof (DNS_HOST_TO_ADDR_DATA));\r
        if (Dns4TokenEntry->Token->RspData.H2AData == NULL) {\r
          Status = EFI_OUT_OF_RESOURCES;\r
          goto ON_EXIT;\r
        }\r
\r
        Dns4TokenEntry->Token->RspData.H2AData->IpList = AllocateZeroPool (DnsHeader->AnswersNum * sizeof (EFI_IPv4_ADDRESS));\r
        if (Dns4TokenEntry->Token->RspData.H2AData->IpList == NULL) {\r
          Status = EFI_OUT_OF_RESOURCES;\r
          goto ON_EXIT;\r
        }\r
      } else {\r
        Status = EFI_UNSUPPORTED;\r
        goto ON_EXIT;\r
      }\r
    }\r
  } else {\r
    ASSERT (Dns6TokenEntry != NULL);\r
\r
    if (Dns6TokenEntry->GeneralLookUp) {\r
      //\r
      // It's the GeneralLookUp querying.\r
      //\r
      Dns6TokenEntry->Token->RspData.GLookupData = AllocateZeroPool (sizeof (DNS_RESOURCE_RECORD));\r
      if (Dns6TokenEntry->Token->RspData.GLookupData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
\r
      Dns6TokenEntry->Token->RspData.GLookupData->RRList = AllocateZeroPool (DnsHeader->AnswersNum * sizeof (DNS_RESOURCE_RECORD));\r
      if (Dns6TokenEntry->Token->RspData.GLookupData->RRList == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
    } else {\r
      //\r
      // It's not the GeneralLookUp querying. Check the Query type.\r
      //\r
      if (QuerySection->Type == DNS_TYPE_AAAA) {\r
        Dns6TokenEntry->Token->RspData.H2AData = AllocateZeroPool (sizeof (DNS6_HOST_TO_ADDR_DATA));\r
        if (Dns6TokenEntry->Token->RspData.H2AData == NULL) {\r
          Status = EFI_OUT_OF_RESOURCES;\r
          goto ON_EXIT;\r
        }\r
\r
        Dns6TokenEntry->Token->RspData.H2AData->IpList = AllocateZeroPool (DnsHeader->AnswersNum * sizeof (EFI_IPv6_ADDRESS));\r
        if (Dns6TokenEntry->Token->RspData.H2AData->IpList == NULL) {\r
          Status = EFI_OUT_OF_RESOURCES;\r
          goto ON_EXIT;\r
        }\r
      } else {\r
        Status = EFI_UNSUPPORTED;\r
        goto ON_EXIT;\r
      }\r
    }\r
  }\r
\r
  Status = EFI_NOT_FOUND;\r
\r
  //\r
  // Get Answer name\r
  //\r
  AnswerName = (CHAR8 *)QuerySection + sizeof (*QuerySection);\r
\r
  //\r
  // Processing AnswerSection.\r
  //\r
  while (AnswerSectionNum < DnsHeader->AnswersNum) {\r
    //\r
    // Check whether the remaining packet length is available or not.\r
    //\r
    if (RemainingLength <= sizeof (UINT16) + sizeof (DNS_ANSWER_SECTION)) {\r
      *Completed = FALSE;\r
      Status     = EFI_ABORTED;\r
      goto ON_EXIT;\r
    } else {\r
      RemainingLength -= (sizeof (UINT16) + sizeof (DNS_ANSWER_SECTION));\r
    }\r
\r
    //\r
    // Answer name should be PTR, else EFI_UNSUPPORTED returned.\r
    //\r
    if ((*(UINT8 *)AnswerName & 0xC0) != 0xC0) {\r
      Status = EFI_UNSUPPORTED;\r
      goto ON_EXIT;\r
    }\r
\r
    //\r
    // Get Answer section.\r
    //\r
    AnswerSection             = (DNS_ANSWER_SECTION *)(AnswerName + sizeof (UINT16));\r
    AnswerSection->Type       = NTOHS (AnswerSection->Type);\r
    AnswerSection->Class      = NTOHS (AnswerSection->Class);\r
    AnswerSection->Ttl        = NTOHL (AnswerSection->Ttl);\r
    AnswerSection->DataLength = NTOHS (AnswerSection->DataLength);\r
\r
    //\r
    // Check whether the remaining packet length is available or not.\r
    //\r
    if (RemainingLength < AnswerSection->DataLength) {\r
      *Completed = FALSE;\r
      Status     = EFI_ABORTED;\r
      goto ON_EXIT;\r
    } else {\r
      RemainingLength -= AnswerSection->DataLength;\r
    }\r
\r
    //\r
    // Check whether it's the GeneralLookUp querying.\r
    //\r
    if ((Instance->Service->IpVersion == IP_VERSION_4) && Dns4TokenEntry->GeneralLookUp) {\r
      Dns4RR     = Dns4TokenEntry->Token->RspData.GLookupData->RRList;\r
      AnswerData = (UINT8 *)AnswerSection + sizeof (*AnswerSection);\r
\r
      //\r
      // Fill the ResourceRecord.\r
      //\r
      Dns4RR[RRCount].QName = AllocateZeroPool (AsciiStrLen (QueryName) + 1);\r
      if (Dns4RR[RRCount].QName == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
\r
      CopyMem (Dns4RR[RRCount].QName, QueryName, AsciiStrLen (QueryName));\r
      Dns4RR[RRCount].QType      = AnswerSection->Type;\r
      Dns4RR[RRCount].QClass     = AnswerSection->Class;\r
      Dns4RR[RRCount].TTL        = AnswerSection->Ttl;\r
      Dns4RR[RRCount].DataLength = AnswerSection->DataLength;\r
      Dns4RR[RRCount].RData      = AllocateZeroPool (Dns4RR[RRCount].DataLength);\r
      if (Dns4RR[RRCount].RData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
\r
      CopyMem (Dns4RR[RRCount].RData, AnswerData, Dns4RR[RRCount].DataLength);\r
\r
      RRCount++;\r
      Status = EFI_SUCCESS;\r
    } else if ((Instance->Service->IpVersion == IP_VERSION_6) && Dns6TokenEntry->GeneralLookUp) {\r
      Dns6RR     = Dns6TokenEntry->Token->RspData.GLookupData->RRList;\r
      AnswerData = (UINT8 *)AnswerSection + sizeof (*AnswerSection);\r
\r
      //\r
      // Fill the ResourceRecord.\r
      //\r
      Dns6RR[RRCount].QName = AllocateZeroPool (AsciiStrLen (QueryName) + 1);\r
      if (Dns6RR[RRCount].QName == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
\r
      CopyMem (Dns6RR[RRCount].QName, QueryName, AsciiStrLen (QueryName));\r
      Dns6RR[RRCount].QType      = AnswerSection->Type;\r
      Dns6RR[RRCount].QClass     = AnswerSection->Class;\r
      Dns6RR[RRCount].TTL        = AnswerSection->Ttl;\r
      Dns6RR[RRCount].DataLength = AnswerSection->DataLength;\r
      Dns6RR[RRCount].RData      = AllocateZeroPool (Dns6RR[RRCount].DataLength);\r
      if (Dns6RR[RRCount].RData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ON_EXIT;\r
      }\r
\r
      CopyMem (Dns6RR[RRCount].RData, AnswerData, Dns6RR[RRCount].DataLength);\r
\r
      RRCount++;\r
      Status = EFI_SUCCESS;\r
    } else {\r
      //\r
      // It's not the GeneralLookUp querying.\r
      // Check the Query type, parse the response packet.\r
      //\r
      switch (AnswerSection->Type) {\r
        case DNS_TYPE_A:\r
          //\r
          // This is address entry, get Data.\r
          //\r
          ASSERT (Dns4TokenEntry != NULL);\r
\r
          if (AnswerSection->DataLength != 4) {\r
            Status = EFI_ABORTED;\r
            goto ON_EXIT;\r
          }\r
\r
          HostAddr4  = Dns4TokenEntry->Token->RspData.H2AData->IpList;\r
          AnswerData = (UINT8 *)AnswerSection + sizeof (*AnswerSection);\r
          CopyMem (&HostAddr4[IpCount], AnswerData, sizeof (EFI_IPv4_ADDRESS));\r
\r
          //\r
          // Allocate new CacheEntry pool to update DNS cache dynamically.\r
          //\r
          Dns4CacheEntry = AllocateZeroPool (sizeof (EFI_DNS4_CACHE_ENTRY));\r
          if (Dns4CacheEntry == NULL) {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto ON_EXIT;\r
          }\r
\r
          Dns4CacheEntry->HostName = AllocateZeroPool (2 * (StrLen (Dns4TokenEntry->QueryHostName) + 1));\r
          if (Dns4CacheEntry->HostName == NULL) {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto ON_EXIT;\r
          }\r
\r
          CopyMem (Dns4CacheEntry->HostName, Dns4TokenEntry->QueryHostName, 2 * (StrLen (Dns4TokenEntry->QueryHostName) + 1));\r
          Dns4CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv4_ADDRESS));\r
          if (Dns4CacheEntry->IpAddress == NULL) {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto ON_EXIT;\r
          }\r
\r
          CopyMem (Dns4CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv4_ADDRESS));\r
\r
          if ((CNameTtl != 0) && (AnswerSection->Ttl != 0)) {\r
            Dns4CacheEntry->Timeout = MIN (CNameTtl, AnswerSection->Ttl);\r
          } else {\r
            Dns4CacheEntry->Timeout = MAX (CNameTtl, AnswerSection->Ttl);\r
          }\r
\r
          UpdateDns4Cache (&mDriverData->Dns4CacheList, FALSE, TRUE, *Dns4CacheEntry);\r
\r
          //\r
          // Free allocated CacheEntry pool.\r
          //\r
          FreePool (Dns4CacheEntry->HostName);\r
          Dns4CacheEntry->HostName = NULL;\r
\r
          FreePool (Dns4CacheEntry->IpAddress);\r
          Dns4CacheEntry->IpAddress = NULL;\r
\r
          FreePool (Dns4CacheEntry);\r
          Dns4CacheEntry = NULL;\r
\r
          IpCount++;\r
          Status = EFI_SUCCESS;\r
          break;\r
        case DNS_TYPE_AAAA:\r
          //\r
          // This is address entry, get Data.\r
          //\r
          ASSERT (Dns6TokenEntry != NULL);\r
\r
          if (AnswerSection->DataLength != 16) {\r
            Status = EFI_ABORTED;\r
            goto ON_EXIT;\r
          }\r
\r
          HostAddr6  = Dns6TokenEntry->Token->RspData.H2AData->IpList;\r
          AnswerData = (UINT8 *)AnswerSection + sizeof (*AnswerSection);\r
          CopyMem (&HostAddr6[IpCount], AnswerData, sizeof (EFI_IPv6_ADDRESS));\r
\r
          //\r
          // Allocate new CacheEntry pool to update DNS cache dynamically.\r
          //\r
          Dns6CacheEntry = AllocateZeroPool (sizeof (EFI_DNS6_CACHE_ENTRY));\r
          if (Dns6CacheEntry == NULL) {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto ON_EXIT;\r
          }\r
\r
          Dns6CacheEntry->HostName = AllocateZeroPool (2 * (StrLen (Dns6TokenEntry->QueryHostName) + 1));\r
          if (Dns6CacheEntry->HostName == NULL) {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto ON_EXIT;\r
          }\r
\r
          CopyMem (Dns6CacheEntry->HostName, Dns6TokenEntry->QueryHostName, 2 * (StrLen (Dns6TokenEntry->QueryHostName) + 1));\r
          Dns6CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv6_ADDRESS));\r
          if (Dns6CacheEntry->IpAddress == NULL) {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto ON_EXIT;\r
          }\r
\r
          CopyMem (Dns6CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv6_ADDRESS));\r
\r
          if ((CNameTtl != 0) && (AnswerSection->Ttl != 0)) {\r
            Dns6CacheEntry->Timeout = MIN (CNameTtl, AnswerSection->Ttl);\r
          } else {\r
            Dns6CacheEntry->Timeout = MAX (CNameTtl, AnswerSection->Ttl);\r
          }\r
\r
          UpdateDns6Cache (&mDriverData->Dns6CacheList, FALSE, TRUE, *Dns6CacheEntry);\r
\r
          //\r
          // Free allocated CacheEntry pool.\r
          //\r
          FreePool (Dns6CacheEntry->HostName);\r
          Dns6CacheEntry->HostName = NULL;\r
\r
          FreePool (Dns6CacheEntry->IpAddress);\r
          Dns6CacheEntry->IpAddress = NULL;\r
\r
          FreePool (Dns6CacheEntry);\r
          Dns6CacheEntry = NULL;\r
\r
          IpCount++;\r
          Status = EFI_SUCCESS;\r
          break;\r
        case DNS_TYPE_CNAME:\r
          //\r
          // According RFC 1034 - 3.6.2, if the query name is an alias, the name server will include the CNAME\r
          // record in the response and restart the query at the domain name specified in the data field of the\r
          // CNAME record. So, just record the TTL value of the CNAME, then skip to parse the next record.\r
          //\r
          CNameTtl = AnswerSection->Ttl;\r
          break;\r
        default:\r
          Status = EFI_UNSUPPORTED;\r
          goto ON_EXIT;\r
      }\r
    }\r
\r
    //\r
    // Find next one\r
    //\r
    AnswerName = (CHAR8 *)AnswerSection + sizeof (*AnswerSection) + AnswerSection->DataLength;\r
    AnswerSectionNum++;\r
  }\r
\r
  if (Instance->Service->IpVersion == IP_VERSION_4) {\r
    ASSERT (Dns4TokenEntry != NULL);\r
\r
    if (Dns4TokenEntry->GeneralLookUp) {\r
      Dns4TokenEntry->Token->RspData.GLookupData->RRCount = RRCount;\r
    } else {\r
      if (QuerySection->Type == DNS_TYPE_A) {\r
        Dns4TokenEntry->Token->RspData.H2AData->IpCount = IpCount;\r
      } else {\r
        Status = EFI_UNSUPPORTED;\r
        goto ON_EXIT;\r
      }\r
    }\r
  } else {\r
    ASSERT (Dns6TokenEntry != NULL);\r
\r
    if (Dns6TokenEntry->GeneralLookUp) {\r
      Dns6TokenEntry->Token->RspData.GLookupData->RRCount = RRCount;\r
    } else {\r
      if (QuerySection->Type == DNS_TYPE_AAAA) {\r
        Dns6TokenEntry->Token->RspData.H2AData->IpCount = IpCount;\r
      } else {\r
        Status = EFI_UNSUPPORTED;\r
        goto ON_EXIT;\r
      }\r
    }\r
  }\r
\r
ON_COMPLETE:\r
  //\r
  // Parsing is complete, free the sending packet and signal Event here.\r
  //\r
  if ((Item != NULL) && (Item->Value != NULL)) {\r
    NetbufFree ((NET_BUF *)(Item->Value));\r
  }\r
\r
  if (Instance->Service->IpVersion == IP_VERSION_4) {\r
    ASSERT (Dns4TokenEntry != NULL);\r
    Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);\r
    Dns4TokenEntry->Token->Status = Status;\r
    if (Dns4TokenEntry->Token->Event != NULL) {\r
      gBS->SignalEvent (Dns4TokenEntry->Token->Event);\r
      DispatchDpc ();\r
    }\r
  } else {\r
    ASSERT (Dns6TokenEntry != NULL);\r
    Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);\r
    Dns6TokenEntry->Token->Status = Status;\r
    if (Dns6TokenEntry->Token->Event != NULL) {\r
      gBS->SignalEvent (Dns6TokenEntry->Token->Event);\r
      DispatchDpc ();\r
    }\r
  }\r
\r
ON_EXIT:\r
  //\r
  // Free the allocated buffer if error happen.\r
  //\r
  if (EFI_ERROR (Status)) {\r
    if (Dns4TokenEntry != NULL) {\r
      if (Dns4TokenEntry->GeneralLookUp) {\r
        if (Dns4TokenEntry->Token->RspData.GLookupData != NULL) {\r
          if (Dns4TokenEntry->Token->RspData.GLookupData->RRList != NULL) {\r
            while (RRCount != 0) {\r
              RRCount--;\r
              if (Dns4TokenEntry->Token->RspData.GLookupData->RRList[RRCount].QName != NULL) {\r
                FreePool (Dns4TokenEntry->Token->RspData.GLookupData->RRList[RRCount].QName);\r
              }\r
\r
              if (Dns4TokenEntry->Token->RspData.GLookupData->RRList[RRCount].RData != NULL) {\r
                FreePool (Dns4TokenEntry->Token->RspData.GLookupData->RRList[RRCount].RData);\r
              }\r
            }\r
\r
            FreePool (Dns4TokenEntry->Token->RspData.GLookupData->RRList);\r
          }\r
\r
          FreePool (Dns4TokenEntry->Token->RspData.GLookupData);\r
        }\r
      } else {\r
        if ((QuerySection->Type == DNS_TYPE_A) && (Dns4TokenEntry->Token->RspData.H2AData != NULL)) {\r
          if (Dns4TokenEntry->Token->RspData.H2AData->IpList != NULL) {\r
            FreePool (Dns4TokenEntry->Token->RspData.H2AData->IpList);\r
          }\r
\r
          FreePool (Dns4TokenEntry->Token->RspData.H2AData);\r
          Dns4TokenEntry->Token->RspData.H2AData = NULL;\r
        }\r
      }\r
    }\r
\r
    if (Dns6TokenEntry != NULL) {\r
      if (Dns6TokenEntry->GeneralLookUp) {\r
        if (Dns6TokenEntry->Token->RspData.GLookupData != NULL) {\r
          if (Dns6TokenEntry->Token->RspData.GLookupData->RRList != NULL) {\r
            while (RRCount != 0) {\r
              RRCount--;\r
              if (Dns6TokenEntry->Token->RspData.GLookupData->RRList[RRCount].QName != NULL) {\r
                FreePool (Dns6TokenEntry->Token->RspData.GLookupData->RRList[RRCount].QName);\r
              }\r
\r
              if (Dns6TokenEntry->Token->RspData.GLookupData->RRList[RRCount].RData != NULL) {\r
                FreePool (Dns6TokenEntry->Token->RspData.GLookupData->RRList[RRCount].RData);\r
              }\r
            }\r
\r
            FreePool (Dns6TokenEntry->Token->RspData.GLookupData->RRList);\r
          }\r
\r
          FreePool (Dns6TokenEntry->Token->RspData.GLookupData);\r
        }\r
      } else {\r
        if ((QuerySection->Type == DNS_TYPE_AAAA) && (Dns6TokenEntry->Token->RspData.H2AData != NULL)) {\r
          if (Dns6TokenEntry->Token->RspData.H2AData->IpList != NULL) {\r
            FreePool (Dns6TokenEntry->Token->RspData.H2AData->IpList);\r
          }\r
\r
          FreePool (Dns6TokenEntry->Token->RspData.H2AData);\r
          Dns6TokenEntry->Token->RspData.H2AData = NULL;\r
        }\r
      }\r
    }\r
\r
    if (Dns4CacheEntry != NULL) {\r
      if (Dns4CacheEntry->HostName != NULL) {\r
        FreePool (Dns4CacheEntry->HostName);\r
      }\r
\r
      if (Dns4CacheEntry->IpAddress != NULL) {\r
        FreePool (Dns4CacheEntry->IpAddress);\r
      }\r
\r
      FreePool (Dns4CacheEntry);\r
    }\r
\r
    if (Dns6CacheEntry != NULL) {\r
      if (Dns6CacheEntry->HostName != NULL) {\r
        FreePool (Dns6CacheEntry->HostName);\r
      }\r
\r
      if (Dns6CacheEntry->IpAddress != NULL) {\r
        FreePool (Dns6CacheEntry->IpAddress);\r
      }\r
\r
      FreePool (Dns6CacheEntry);\r
    }\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
  return Status;\r
}\r
\r
/**\r
  Parse response packet.\r
\r
  @param  Packet                The packets received.\r
  @param  EndPoint              The local/remote UDP access point\r
  @param  IoStatus              The status of the UDP receive\r
  @param  Context               The opaque parameter to the function.\r
\r
**/\r
VOID\r
EFIAPI\r
DnsOnPacketReceived (\r
  NET_BUF        *Packet,\r
  UDP_END_POINT  *EndPoint,\r
  EFI_STATUS     IoStatus,\r
  VOID           *Context\r
  )\r
{\r
  DNS_INSTANCE  *Instance;\r
\r
  UINT8   *RcvString;\r
  UINT32  Len;\r
\r
  BOOLEAN  Completed;\r
\r
  Instance = (DNS_INSTANCE *)Context;\r
  NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);\r
\r
  RcvString = NULL;\r
  Completed = FALSE;\r
\r
  if (EFI_ERROR (IoStatus)) {\r
    goto ON_EXIT;\r
  }\r
\r
  ASSERT (Packet != NULL);\r
\r
  Len = Packet->TotalSize;\r
\r
  RcvString = NetbufGetByte (Packet, 0, NULL);\r
  ASSERT (RcvString != NULL);\r
\r
  //\r
  // Parse Dns Response\r
  //\r
  ParseDnsResponse (Instance, RcvString, Len, &Completed);\r
\r
ON_EXIT:\r
\r
  if (Packet != NULL) {\r
    NetbufFree (Packet);\r
  }\r
\r
  if (!Completed) {\r
    UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);\r
  }\r
}\r
\r
/**\r
  Release the net buffer when packet is sent.\r
\r
  @param  Packet                The packets received.\r
  @param  EndPoint              The local/remote UDP access point\r
  @param  IoStatus              The status of the UDP receive\r
  @param  Context               The opaque parameter to the function.\r
\r
**/\r
VOID\r
EFIAPI\r
DnsOnPacketSent (\r
  NET_BUF        *Packet,\r
  UDP_END_POINT  *EndPoint,\r
  EFI_STATUS     IoStatus,\r
  VOID           *Context\r
  )\r
{\r
  DNS_INSTANCE      *Instance;\r
  LIST_ENTRY        *Entry;\r
  NET_MAP_ITEM      *Item;\r
  DNS4_TOKEN_ENTRY  *Dns4TokenEntry;\r
  DNS6_TOKEN_ENTRY  *Dns6TokenEntry;\r
\r
  Dns4TokenEntry = NULL;\r
  Dns6TokenEntry = NULL;\r
\r
  Instance = (DNS_INSTANCE *)Context;\r
  NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);\r
\r
  if (Instance->Service->IpVersion == IP_VERSION_4) {\r
    NET_LIST_FOR_EACH (Entry, &Instance->Dns4TxTokens.Used) {\r
      Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
      if (Packet == (NET_BUF *)(Item->Value)) {\r
        Dns4TokenEntry               = ((DNS4_TOKEN_ENTRY *)Item->Key);\r
        Dns4TokenEntry->PacketToLive = Dns4TokenEntry->Token->RetryInterval;\r
        break;\r
      }\r
    }\r
  } else {\r
    NET_LIST_FOR_EACH (Entry, &Instance->Dns6TxTokens.Used) {\r
      Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);\r
      if (Packet == (NET_BUF *)(Item->Value)) {\r
        Dns6TokenEntry               = ((DNS6_TOKEN_ENTRY *)Item->Key);\r
        Dns6TokenEntry->PacketToLive = Dns6TokenEntry->Token->RetryInterval;\r
        break;\r
      }\r
    }\r
  }\r
\r
  NetbufFree (Packet);\r
}\r
\r
/**\r
  Query request information.\r
\r
  @param  Instance              The DNS instance\r
  @param  Packet                The packet for querying request information.\r
\r
  @retval EFI_SUCCESS           Query request information successfully.\r
  @retval Others                Failed to query request information.\r
\r
**/\r
EFI_STATUS\r
DoDnsQuery (\r
  IN  DNS_INSTANCE  *Instance,\r
  IN  NET_BUF       *Packet\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Ready to receive the DNS response.\r
  //\r
  if (Instance->UdpIo->RecvRequest == NULL) {\r
    Status = UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Transmit the DNS packet.\r
  //\r
  NET_GET_REF (Packet);\r
\r
  Status = UdpIoSendDatagram (Instance->UdpIo, Packet, NULL, NULL, DnsOnPacketSent, Instance);\r
\r
  return Status;\r
}\r
\r
/**\r
  Construct the Packet according query section.\r
\r
  @param  Instance              The DNS instance\r
  @param  QueryName             Queried Name\r
  @param  Type                  Queried Type\r
  @param  Class                 Queried Class\r
  @param  Packet                The packet for query\r
\r
  @retval EFI_SUCCESS           The packet is constructed.\r
  @retval Others                Failed to construct the Packet.\r
\r
**/\r
EFI_STATUS\r
ConstructDNSQuery (\r
  IN  DNS_INSTANCE  *Instance,\r
  IN  CHAR8         *QueryName,\r
  IN  UINT16        Type,\r
  IN  UINT16        Class,\r
  OUT NET_BUF       **Packet\r
  )\r
{\r
  NET_FRAGMENT       Frag;\r
  DNS_HEADER         *DnsHeader;\r
  DNS_QUERY_SECTION  *DnsQuery;\r
\r
  //\r
  // Messages carried by UDP are restricted to 512 bytes (not counting the IP\r
  // or UDP headers).\r
  //\r
  Frag.Bulk = AllocatePool (DNS_MAX_MESSAGE_SIZE * sizeof (UINT8));\r
  if (Frag.Bulk == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Fill header\r
  //\r
  DnsHeader                    = (DNS_HEADER *)Frag.Bulk;\r
  DnsHeader->Identification    = (UINT16)NET_RANDOM (NetRandomInitSeed ());\r
  DnsHeader->Flags.Uint16      = 0x0000;\r
  DnsHeader->Flags.Bits.RD     = 1;\r
  DnsHeader->Flags.Bits.OpCode = DNS_FLAGS_OPCODE_STANDARD;\r
  DnsHeader->Flags.Bits.QR     = DNS_FLAGS_QR_QUERY;\r
  DnsHeader->QuestionsNum      = 1;\r
  DnsHeader->AnswersNum        = 0;\r
  DnsHeader->AuthorityNum      = 0;\r
  DnsHeader->AditionalNum      = 0;\r
\r
  DnsHeader->Identification = HTONS (DnsHeader->Identification);\r
  DnsHeader->Flags.Uint16   = HTONS (DnsHeader->Flags.Uint16);\r
  DnsHeader->QuestionsNum   = HTONS (DnsHeader->QuestionsNum);\r
  DnsHeader->AnswersNum     = HTONS (DnsHeader->AnswersNum);\r
  DnsHeader->AuthorityNum   = HTONS (DnsHeader->AuthorityNum);\r
  DnsHeader->AditionalNum   = HTONS (DnsHeader->AditionalNum);\r
\r
  Frag.Len = sizeof (*DnsHeader);\r
\r
  //\r
  // Fill Query name\r
  //\r
  CopyMem (Frag.Bulk + Frag.Len, QueryName, AsciiStrLen (QueryName));\r
  Frag.Len                = (UINT32)(Frag.Len + AsciiStrLen (QueryName));\r
  *(Frag.Bulk + Frag.Len) = 0;\r
  Frag.Len++;\r
\r
  //\r
  // Rest query section\r
  //\r
  DnsQuery = (DNS_QUERY_SECTION *)(Frag.Bulk + Frag.Len);\r
\r
  DnsQuery->Type  = HTONS (Type);\r
  DnsQuery->Class = HTONS (Class);\r
\r
  Frag.Len += sizeof (*DnsQuery);\r
\r
  //\r
  // Wrap the Frag in a net buffer.\r
  //\r
  *Packet = NetbufFromExt (&Frag, 1, 0, 0, DnsDummyExtFree, NULL);\r
  if (*Packet == NULL) {\r
    FreePool (Frag.Bulk);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Store the UdpIo in ProtoData.\r
  //\r
  *((UINTN *)&((*Packet)->ProtoData[0])) = (UINTN)(Instance->UdpIo);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Retransmit the packet.\r
\r
  @param  Instance              The DNS instance\r
  @param  Packet                Retransmit the packet\r
\r
  @retval EFI_SUCCESS           The packet is retransmitted.\r
  @retval Others                Failed to retransmit.\r
\r
**/\r
EFI_STATUS\r
DnsRetransmit (\r
  IN DNS_INSTANCE  *Instance,\r
  IN NET_BUF       *Packet\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  UINT8  *Buffer;\r
\r
  ASSERT (Packet != NULL);\r
\r
  //\r
  // Set the requests to the listening port, other packets to the connected port\r
  //\r
  Buffer = NetbufGetByte (Packet, 0, NULL);\r
  ASSERT (Buffer != NULL);\r
\r
  NET_GET_REF (Packet);\r
\r
  Status = UdpIoSendDatagram (\r
             Instance->UdpIo,\r
             Packet,\r
             NULL,\r
             NULL,\r
             DnsOnPacketSent,\r
             Instance\r
             );\r
\r
  if (EFI_ERROR (Status)) {\r
    NET_PUT_REF (Packet);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  The timer ticking function for the DNS services.\r
\r
  @param  Event                 The ticking event\r
  @param  Context               The DNS service instance\r
\r
**/\r
VOID\r
EFIAPI\r
DnsOnTimerRetransmit (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  DNS_SERVICE  *Service;\r
\r
  LIST_ENTRY  *Entry;\r
  LIST_ENTRY  *Next;\r
\r
  DNS_INSTANCE      *Instance;\r
  LIST_ENTRY        *EntryNetMap;\r
  NET_MAP_ITEM      *ItemNetMap;\r
  DNS4_TOKEN_ENTRY  *Dns4TokenEntry;\r
  DNS6_TOKEN_ENTRY  *Dns6TokenEntry;\r
\r
  Dns4TokenEntry = NULL;\r
  Dns6TokenEntry = NULL;\r
\r
  Service = (DNS_SERVICE *)Context;\r
\r
  if (Service->IpVersion == IP_VERSION_4) {\r
    //\r
    // Iterate through all the children of the DNS service instance. Time\r
    // out the packet. If maximum retries reached, clean the Token up.\r
    //\r
    NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns4ChildrenList) {\r
      Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);\r
\r
      EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;\r
      while (EntryNetMap != &Instance->Dns4TxTokens.Used) {\r
        ItemNetMap     = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);\r
        Dns4TokenEntry = (DNS4_TOKEN_ENTRY *)(ItemNetMap->Key);\r
        if ((Dns4TokenEntry->PacketToLive == 0) || (--Dns4TokenEntry->PacketToLive > 0)) {\r
          EntryNetMap = EntryNetMap->ForwardLink;\r
          continue;\r
        }\r
\r
        //\r
        // Retransmit the packet if haven't reach the maximum retry count,\r
        // otherwise exit the transfer.\r
        //\r
        if (++Dns4TokenEntry->RetryCounting <= Dns4TokenEntry->Token->RetryCount) {\r
          DnsRetransmit (Instance, (NET_BUF *)ItemNetMap->Value);\r
          EntryNetMap = EntryNetMap->ForwardLink;\r
        } else {\r
          //\r
          // Maximum retries reached, clean the Token up.\r
          //\r
          Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);\r
          Dns4TokenEntry->Token->Status = EFI_TIMEOUT;\r
          gBS->SignalEvent (Dns4TokenEntry->Token->Event);\r
          DispatchDpc ();\r
\r
          //\r
          // Free the sending packet.\r
          //\r
          if (ItemNetMap->Value != NULL) {\r
            NetbufFree ((NET_BUF *)(ItemNetMap->Value));\r
          }\r
\r
          EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;\r
        }\r
      }\r
    }\r
  } else {\r
    //\r
    // Iterate through all the children of the DNS service instance. Time\r
    // out the packet. If maximum retries reached, clean the Token up.\r
    //\r
    NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns6ChildrenList) {\r
      Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);\r
\r
      EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;\r
      while (EntryNetMap != &Instance->Dns6TxTokens.Used) {\r
        ItemNetMap     = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);\r
        Dns6TokenEntry = (DNS6_TOKEN_ENTRY *)(ItemNetMap->Key);\r
        if ((Dns6TokenEntry->PacketToLive == 0) || (--Dns6TokenEntry->PacketToLive > 0)) {\r
          EntryNetMap = EntryNetMap->ForwardLink;\r
          continue;\r
        }\r
\r
        //\r
        // Retransmit the packet if haven't reach the maximum retry count,\r
        // otherwise exit the transfer.\r
        //\r
        if (++Dns6TokenEntry->RetryCounting <= Dns6TokenEntry->Token->RetryCount) {\r
          DnsRetransmit (Instance, (NET_BUF *)ItemNetMap->Value);\r
          EntryNetMap = EntryNetMap->ForwardLink;\r
        } else {\r
          //\r
          // Maximum retries reached, clean the Token up.\r
          //\r
          Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);\r
          Dns6TokenEntry->Token->Status = EFI_TIMEOUT;\r
          gBS->SignalEvent (Dns6TokenEntry->Token->Event);\r
          DispatchDpc ();\r
\r
          //\r
          // Free the sending packet.\r
          //\r
          if (ItemNetMap->Value != NULL) {\r
            NetbufFree ((NET_BUF *)(ItemNetMap->Value));\r
          }\r
\r
          EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;\r
        }\r
      }\r
    }\r
  }\r
}\r
\r
/**\r
  The timer ticking function for the DNS driver.\r
\r
  @param  Event                 The ticking event\r
  @param  Context               NULL\r
\r
**/\r
VOID\r
EFIAPI\r
DnsOnTimerUpdate (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  LIST_ENTRY  *Entry;\r
  LIST_ENTRY  *Next;\r
  DNS4_CACHE  *Item4;\r
  DNS6_CACHE  *Item6;\r
\r
  Item4 = NULL;\r
  Item6 = NULL;\r
\r
  //\r
  // Iterate through all the DNS4 cache list.\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns4CacheList) {\r
    Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);\r
    Item4->DnsCache.Timeout--;\r
  }\r
\r
  Entry = mDriverData->Dns4CacheList.ForwardLink;\r
  while (Entry != &mDriverData->Dns4CacheList) {\r
    Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);\r
    if (Item4->DnsCache.Timeout == 0) {\r
      RemoveEntryList (&Item4->AllCacheLink);\r
      FreePool (Item4->DnsCache.HostName);\r
      FreePool (Item4->DnsCache.IpAddress);\r
      FreePool (Item4);\r
      Entry = mDriverData->Dns4CacheList.ForwardLink;\r
    } else {\r
      Entry = Entry->ForwardLink;\r
    }\r
  }\r
\r
  //\r
  // Iterate through all the DNS6 cache list.\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns6CacheList) {\r
    Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);\r
    Item6->DnsCache.Timeout--;\r
  }\r
\r
  Entry = mDriverData->Dns6CacheList.ForwardLink;\r
  while (Entry != &mDriverData->Dns6CacheList) {\r
    Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);\r
    if (Item6->DnsCache.Timeout == 0) {\r
      RemoveEntryList (&Item6->AllCacheLink);\r
      FreePool (Item6->DnsCache.HostName);\r
      FreePool (Item6->DnsCache.IpAddress);\r
      FreePool (Item6);\r
      Entry = mDriverData->Dns6CacheList.ForwardLink;\r
    } else {\r
      Entry = Entry->ForwardLink;\r
    }\r
  }\r
}\r