NetworkPkg/DnsDxe/DnsImpl.c

   1 /** @file
   2 DnsDxe support functions implementation.
   3
   4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "DnsImpl.h"
  16
  17 /**
  18   Remove TokenEntry from TokenMap.
  19
  20   @param[in] TokenMap          All DNSv4 Token entrys.
  21   @param[in] TokenEntry        TokenEntry need to be removed.
  22
  23   @retval EFI_SUCCESS          Remove TokenEntry from TokenMap sucessfully.
  24   @retval EFI_NOT_FOUND        TokenEntry is not found in TokenMap.
  25
  26 **/
  27 EFI_STATUS
  28 Dns4RemoveTokenEntry (
  29   IN NET_MAP                    *TokenMap,
  30   IN DNS4_TOKEN_ENTRY           *TokenEntry
  31   )
  32 {
  33   NET_MAP_ITEM  *Item;
  34
  35   //
  36   // Find the TokenEntry first.
  37   //
  38   Item = NetMapFindKey (TokenMap, (VOID *) TokenEntry);
  39
  40   if (Item != NULL) {
  41     //
  42     // Remove the TokenEntry if it's found in the map.
  43     //
  44     NetMapRemoveItem (TokenMap, Item, NULL);
  45
  46     return EFI_SUCCESS;
  47   }
  48
  49   return EFI_NOT_FOUND;
  50 }
  51
  52 /**
  53   Remove TokenEntry from TokenMap.
  54
  55   @param[in] TokenMap           All DNSv6 Token entrys.
  56   @param[in] TokenEntry         TokenEntry need to be removed.
  57
  58   @retval EFI_SUCCESS           Remove TokenEntry from TokenMap sucessfully.
  59   @retval EFI_NOT_FOUND         TokenEntry is not found in TokenMap.
  60
  61 **/
  62 EFI_STATUS
  63 Dns6RemoveTokenEntry (
  64   IN NET_MAP                    *TokenMap,
  65   IN DNS6_TOKEN_ENTRY           *TokenEntry
  66   )
  67 {
  68   NET_MAP_ITEM  *Item;
  69
  70   //
  71   // Find the TokenEntry first.
  72   //
  73   Item = NetMapFindKey (TokenMap, (VOID *) TokenEntry);
  74
  75   if (Item != NULL) {
  76     //
  77     // Remove the TokenEntry if it's found in the map.
  78     //
  79     NetMapRemoveItem (TokenMap, Item, NULL);
  80
  81     return EFI_SUCCESS;
  82   }
  83
  84   return EFI_NOT_FOUND;
  85 }
  86
  87 /**
  88   This function cancle the token specified by Arg in the Map.
  89
  90   @param[in]  Map             Pointer to the NET_MAP.
  91   @param[in]  Item            Pointer to the NET_MAP_ITEM.
  92   @param[in]  Arg             Pointer to the token to be cancelled. If NULL, all
  93                               the tokens in this Map will be cancelled.
  94                               This parameter is optional and may be NULL.
  95
  96   @retval EFI_SUCCESS         The token is cancelled if Arg is NULL, or the token
  97                               is not the same as that in the Item, if Arg is not
  98                               NULL.
  99   @retval EFI_ABORTED         Arg is not NULL, and the token specified by Arg is
 100                               cancelled.
 101
 102 **/
 103 EFI_STATUS
 104 EFIAPI
 105 Dns4CancelTokens (
 106   IN NET_MAP       *Map,
 107   IN NET_MAP_ITEM  *Item,
 108   IN VOID          *Arg OPTIONAL
 109   )
 110 {
 111   DNS4_TOKEN_ENTRY           *TokenEntry;
 112   NET_BUF                    *Packet;
 113   UDP_IO                     *UdpIo;
 114
 115   if ((Arg != NULL) && (Item->Key != Arg)) {
 116     return EFI_SUCCESS;
 117   }
 118
 119   if (Item->Value != NULL) {
 120     //
 121     // If the TokenEntry is a transmit TokenEntry, the corresponding Packet is recorded in
 122     // Item->Value.
 123     //
 124     Packet  = (NET_BUF *) (Item->Value);
 125     UdpIo = (UDP_IO *) (*((UINTN *) &Packet->ProtoData[0]));
 126
 127     UdpIoCancelSentDatagram (UdpIo, Packet);
 128   }
 129
 130   //
 131   // Remove TokenEntry from Dns4TxTokens.
 132   //
 133   TokenEntry = (DNS4_TOKEN_ENTRY *) Item->Key;
 134   if (Dns4RemoveTokenEntry (Map, TokenEntry) == EFI_SUCCESS) {
 135     TokenEntry->Token->Status = EFI_ABORTED;
 136     gBS->SignalEvent (TokenEntry->Token->Event);
 137     DispatchDpc ();
 138   }
 139
 140   if (Arg != NULL) {
 141     return EFI_ABORTED;
 142   }
 143
 144   return EFI_SUCCESS;
 145 }
 146
 147 /**
 148   This function cancle the token specified by Arg in the Map.
 149
 150   @param[in]  Map             Pointer to the NET_MAP.
 151   @param[in]  Item            Pointer to the NET_MAP_ITEM.
 152   @param[in]  Arg             Pointer to the token to be cancelled. If NULL, all
 153                               the tokens in this Map will be cancelled.
 154                               This parameter is optional and may be NULL.
 155
 156   @retval EFI_SUCCESS         The token is cancelled if Arg is NULL, or the token
 157                               is not the same as that in the Item, if Arg is not
 158                               NULL.
 159   @retval EFI_ABORTED         Arg is not NULL, and the token specified by Arg is
 160                               cancelled.
 161
 162 **/
 163 EFI_STATUS
 164 EFIAPI
 165 Dns6CancelTokens (
 166   IN NET_MAP       *Map,
 167   IN NET_MAP_ITEM  *Item,
 168   IN VOID          *Arg OPTIONAL
 169   )
 170 {
 171   DNS6_TOKEN_ENTRY           *TokenEntry;
 172   NET_BUF                    *Packet;
 173   UDP_IO                     *UdpIo;
 174
 175   if ((Arg != NULL) && (Item->Key != Arg)) {
 176     return EFI_SUCCESS;
 177   }
 178
 179   if (Item->Value != NULL) {
 180     //
 181     // If the TokenEntry is a transmit TokenEntry, the corresponding Packet is recorded in
 182     // Item->Value.
 183     //
 184     Packet  = (NET_BUF *) (Item->Value);
 185     UdpIo = (UDP_IO *) (*((UINTN *) &Packet->ProtoData[0]));
 186
 187     UdpIoCancelSentDatagram (UdpIo, Packet);
 188   }
 189
 190   //
 191   // Remove TokenEntry from Dns6TxTokens.
 192   //
 193   TokenEntry = (DNS6_TOKEN_ENTRY *) Item->Key;
 194   if (Dns6RemoveTokenEntry (Map, TokenEntry) == EFI_SUCCESS) {
 195     TokenEntry->Token->Status = EFI_ABORTED;
 196     gBS->SignalEvent (TokenEntry->Token->Event);
 197     DispatchDpc ();
 198   }
 199
 200   if (Arg != NULL) {
 201     return EFI_ABORTED;
 202   }
 203
 204   return EFI_SUCCESS;
 205 }
 206
 207 /**
 208   Get the TokenEntry from the TokensMap.
 209
 210   @param[in]  TokensMap           All DNSv4 Token entrys
 211   @param[in]  Token               Pointer to the token to be get.
 212   @param[out] TokenEntry          Pointer to TokenEntry corresponding Token.
 213
 214   @retval EFI_SUCCESS             Get the TokenEntry from the TokensMap sucessfully.
 215   @retval EFI_NOT_FOUND           TokenEntry is not found in TokenMap.
 216
 217 **/
 218 EFI_STATUS
 219 EFIAPI
 220 GetDns4TokenEntry (
 221   IN     NET_MAP                   *TokensMap,
 222   IN     EFI_DNS4_COMPLETION_TOKEN *Token,
 223      OUT DNS4_TOKEN_ENTRY          **TokenEntry
 224   )
 225 {
 226   LIST_ENTRY              *Entry;
 227
 228   NET_MAP_ITEM            *Item;
 229
 230   NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {
 231     Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
 232     *TokenEntry = (DNS4_TOKEN_ENTRY *) (Item->Key);
 233     if ((*TokenEntry)->Token == Token) {
 234       return EFI_SUCCESS;
 235     }
 236   }
 237
 238   *TokenEntry = NULL;
 239
 240   return EFI_NOT_FOUND;
 241 }
 242
 243 /**
 244   Get the TokenEntry from the TokensMap.
 245
 246   @param[in]  TokensMap           All DNSv6 Token entrys
 247   @param[in]  Token               Pointer to the token to be get.
 248   @param[out] TokenEntry          Pointer to TokenEntry corresponding Token.
 249
 250   @retval EFI_SUCCESS             Get the TokenEntry from the TokensMap sucessfully.
 251   @retval EFI_NOT_FOUND           TokenEntry is not found in TokenMap.
 252
 253 **/
 254 EFI_STATUS
 255 EFIAPI
 256 GetDns6TokenEntry (
 257   IN     NET_MAP                   *TokensMap,
 258   IN     EFI_DNS6_COMPLETION_TOKEN *Token,
 259      OUT DNS6_TOKEN_ENTRY          **TokenEntry
 260   )
 261 {
 262   LIST_ENTRY              *Entry;
 263
 264   NET_MAP_ITEM            *Item;
 265
 266   NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {
 267     Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
 268     *TokenEntry = (DNS6_TOKEN_ENTRY *) (Item->Key);
 269     if ((*TokenEntry)->Token == Token) {
 270       return EFI_SUCCESS;
 271     }
 272   }
 273
 274   *TokenEntry =NULL;
 275
 276   return EFI_NOT_FOUND;
 277 }
 278
 279 /**
 280   Cancel DNS4 tokens from the DNS4 instance.
 281
 282   @param[in]  Instance           Pointer to the DNS instance context data.
 283   @param[in]  Token              Pointer to the token to be canceled. If NULL, all
 284                                  tokens in this instance will be cancelled.
 285                                  This parameter is optional and may be NULL.
 286
 287   @retval EFI_SUCCESS            The Token is cancelled.
 288   @retval EFI_NOT_FOUND          The Token is not found.
 289
 290 **/
 291 EFI_STATUS
 292 Dns4InstanceCancelToken (
 293   IN DNS_INSTANCE               *Instance,
 294   IN EFI_DNS4_COMPLETION_TOKEN  *Token
 295   )
 296 {
 297   EFI_STATUS        Status;
 298   DNS4_TOKEN_ENTRY  *TokenEntry;
 299
 300   TokenEntry = NULL;
 301
 302   if(Token != NULL  ) {
 303     Status = GetDns4TokenEntry (&Instance->Dns4TxTokens, Token, &TokenEntry);
 304     if (EFI_ERROR (Status)) {
 305       return Status;
 306     }
 307   } else {
 308     TokenEntry = NULL;
 309   }
 310
 311   //
 312   // Cancel this TokenEntry from the Dns4TxTokens map.
 313   //
 314   Status = NetMapIterate (&Instance->Dns4TxTokens, Dns4CancelTokens, TokenEntry);
 315
 316   if ((TokenEntry != NULL) && (Status == EFI_ABORTED)) {
 317     //
 318     // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from
 319     // the Dns4TxTokens and returns success.
 320     //
 321     if (NetMapIsEmpty (&Instance->Dns4TxTokens)) {
 322        Instance->UdpIo->Protocol.Udp4->Cancel (Instance->UdpIo->Protocol.Udp4, &Instance->UdpIo->RecvRequest->Token.Udp4);
 323     }
 324     return EFI_SUCCESS;
 325   }
 326
 327   ASSERT ((TokenEntry != NULL) || (0 == NetMapGetCount (&Instance->Dns4TxTokens)));
 328
 329   if (NetMapIsEmpty (&Instance->Dns4TxTokens)) {
 330     Instance->UdpIo->Protocol.Udp4->Cancel (Instance->UdpIo->Protocol.Udp4, &Instance->UdpIo->RecvRequest->Token.Udp4);
 331   }
 332
 333   return EFI_SUCCESS;
 334 }
 335
 336 /**
 337   Cancel DNS6 tokens from the DNS6 instance.
 338
 339   @param[in]  Instance           Pointer to the DNS instance context data.
 340   @param[in]  Token              Pointer to the token to be canceled. If NULL, all
 341                                  tokens in this instance will be cancelled.
 342                                  This parameter is optional and may be NULL.
 343
 344   @retval EFI_SUCCESS            The Token is cancelled.
 345   @retval EFI_NOT_FOUND          The Token is not found.
 346
 347 **/
 348 EFI_STATUS
 349 Dns6InstanceCancelToken (
 350   IN DNS_INSTANCE               *Instance,
 351   IN EFI_DNS6_COMPLETION_TOKEN  *Token
 352   )
 353 {
 354   EFI_STATUS        Status;
 355   DNS6_TOKEN_ENTRY  *TokenEntry;
 356
 357   TokenEntry = NULL;
 358
 359   if(Token != NULL  ) {
 360     Status = GetDns6TokenEntry (&Instance->Dns6TxTokens, Token, &TokenEntry);
 361     if (EFI_ERROR (Status)) {
 362       return Status;
 363     }
 364   } else {
 365     TokenEntry = NULL;
 366   }
 367
 368   //
 369   // Cancel this TokenEntry from the Dns6TxTokens map.
 370   //
 371   Status = NetMapIterate (&Instance->Dns6TxTokens, Dns6CancelTokens, TokenEntry);
 372
 373   if ((TokenEntry != NULL) && (Status == EFI_ABORTED)) {
 374     //
 375     // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from
 376     // the Dns6TxTokens and returns success.
 377     //
 378     if (NetMapIsEmpty (&Instance->Dns6TxTokens)) {
 379        Instance->UdpIo->Protocol.Udp6->Cancel (Instance->UdpIo->Protocol.Udp6, &Instance->UdpIo->RecvRequest->Token.Udp6);
 380     }
 381     return EFI_SUCCESS;
 382   }
 383
 384   ASSERT ((TokenEntry != NULL) || (0 == NetMapGetCount (&Instance->Dns6TxTokens)));
 385
 386   if (NetMapIsEmpty (&Instance->Dns6TxTokens)) {
 387     Instance->UdpIo->Protocol.Udp6->Cancel (Instance->UdpIo->Protocol.Udp6, &Instance->UdpIo->RecvRequest->Token.Udp6);
 388   }
 389
 390   return EFI_SUCCESS;
 391 }
 392
 393 /**
 394   Free the resource related to the configure parameters.
 395
 396   @param  Config                 The DNS configure data
 397
 398 **/
 399 VOID
 400 Dns4CleanConfigure (
 401   IN OUT EFI_DNS4_CONFIG_DATA  *Config
 402   )
 403 {
 404   if (Config->DnsServerList != NULL) {
 405     FreePool (Config->DnsServerList);
 406   }
 407
 408   ZeroMem (Config, sizeof (EFI_DNS4_CONFIG_DATA));
 409 }
 410
 411 /**
 412   Free the resource related to the configure parameters.
 413
 414   @param  Config                 The DNS configure data
 415
 416 **/
 417 VOID
 418 Dns6CleanConfigure (
 419   IN OUT EFI_DNS6_CONFIG_DATA  *Config
 420   )
 421 {
 422   if (Config->DnsServerList != NULL) {
 423     FreePool (Config->DnsServerList);
 424   }
 425
 426   ZeroMem (Config, sizeof (EFI_DNS6_CONFIG_DATA));
 427 }
 428
 429 /**
 430   Allocate memory for configure parameter such as timeout value for Dst,
 431   then copy the configure parameter from Src to Dst.
 432
 433   @param[out]  Dst               The destination DHCP configure data.
 434   @param[in]   Src               The source DHCP configure data.
 435
 436   @retval EFI_OUT_OF_RESOURCES   Failed to allocate memory.
 437   @retval EFI_SUCCESS            The configure is copied.
 438
 439 **/
 440 EFI_STATUS
 441 Dns4CopyConfigure (
 442   OUT EFI_DNS4_CONFIG_DATA  *Dst,
 443   IN  EFI_DNS4_CONFIG_DATA  *Src
 444   )
 445 {
 446   UINTN                     Len;
 447   UINT32                    Index;
 448
 449   CopyMem (Dst, Src, sizeof (*Dst));
 450   Dst->DnsServerList = NULL;
 451
 452   //
 453   // Allocate a memory then copy DnsServerList to it
 454   //
 455   if (Src->DnsServerList != NULL) {
 456     Len                = Src->DnsServerListCount * sizeof (EFI_IPv4_ADDRESS);
 457     Dst->DnsServerList = AllocatePool (Len);
 458     if (Dst->DnsServerList == NULL) {
 459       Dns4CleanConfigure (Dst);
 460       return EFI_OUT_OF_RESOURCES;
 461     }
 462
 463     for (Index = 0; Index < Src->DnsServerListCount; Index++) {
 464       CopyMem (&Dst->DnsServerList[Index], &Src->DnsServerList[Index], sizeof (EFI_IPv4_ADDRESS));
 465     }
 466   }
 467
 468   return EFI_SUCCESS;
 469 }
 470
 471 /**
 472   Allocate memory for configure parameter such as timeout value for Dst,
 473   then copy the configure parameter from Src to Dst.
 474
 475   @param[out]  Dst               The destination DHCP configure data.
 476   @param[in]   Src               The source DHCP configure data.
 477
 478   @retval EFI_OUT_OF_RESOURCES   Failed to allocate memory.
 479   @retval EFI_SUCCESS            The configure is copied.
 480
 481 **/
 482 EFI_STATUS
 483 Dns6CopyConfigure (
 484   OUT EFI_DNS6_CONFIG_DATA  *Dst,
 485   IN  EFI_DNS6_CONFIG_DATA  *Src
 486   )
 487 {
 488   UINTN                     Len;
 489   UINT32                    Index;
 490
 491   CopyMem (Dst, Src, sizeof (*Dst));
 492   Dst->DnsServerList = NULL;
 493
 494   //
 495   // Allocate a memory then copy DnsServerList to it
 496   //
 497   if (Src->DnsServerList != NULL) {
 498     Len                = Src->DnsServerCount * sizeof (EFI_IPv6_ADDRESS);
 499     Dst->DnsServerList = AllocatePool (Len);
 500     if (Dst->DnsServerList == NULL) {
 501       Dns6CleanConfigure (Dst);
 502       return EFI_OUT_OF_RESOURCES;
 503     }
 504
 505     for (Index = 0; Index < Src->DnsServerCount; Index++) {
 506       CopyMem (&Dst->DnsServerList[Index], &Src->DnsServerList[Index], sizeof (EFI_IPv6_ADDRESS));
 507     }
 508   }
 509
 510   return EFI_SUCCESS;
 511 }
 512
 513 /**
 514   Callback of Dns packet. Does nothing.
 515
 516   @param Arg           The context.
 517
 518 **/
 519 VOID
 520 EFIAPI
 521 DnsDummyExtFree (
 522   IN VOID                   *Arg
 523   )
 524 {
 525 }
 526
 527 /**
 528   Poll the UDP to get the IP4 default address, which may be retrieved
 529   by DHCP.
 530
 531   The default time out value is 5 seconds. If IP has retrieved the default address,
 532   the UDP is reconfigured.
 533
 534   @param  Instance               The DNS instance
 535   @param  UdpIo                  The UDP_IO to poll
 536   @param  UdpCfgData             The UDP configure data to reconfigure the UDP_IO
 537
 538   @retval TRUE                   The default address is retrieved and UDP is reconfigured.
 539   @retval FALSE                  Some error occured.
 540
 541 **/
 542 BOOLEAN
 543 Dns4GetMapping (
 544   IN DNS_INSTANCE           *Instance,
 545   IN UDP_IO                 *UdpIo,
 546   IN EFI_UDP4_CONFIG_DATA   *UdpCfgData
 547   )
 548 {
 549   DNS_SERVICE               *Service;
 550   EFI_IP4_MODE_DATA         Ip4Mode;
 551   EFI_UDP4_PROTOCOL         *Udp;
 552   EFI_STATUS                Status;
 553
 554   ASSERT (Instance->Dns4CfgData.UseDefaultSetting);
 555
 556   Service = Instance->Service;
 557   Udp     = UdpIo->Protocol.Udp4;
 558
 559   Status = gBS->SetTimer (
 560                   Service->TimerToGetMap,
 561                   TimerRelative,
 562                   DNS_TIME_TO_GETMAP * TICKS_PER_SECOND
 563                   );
 564   if (EFI_ERROR (Status)) {
 565     return FALSE;
 566   }
 567
 568   while (!EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {
 569     Udp->Poll (Udp);
 570
 571     if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip4Mode, NULL, NULL)) &&
 572         Ip4Mode.IsConfigured) {
 573
 574       Udp->Configure (Udp, NULL);
 575       return (BOOLEAN) (Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS);
 576     }
 577   }
 578
 579   return FALSE;
 580 }
 581
 582 /**
 583   Configure the opened Udp6 instance until the corresponding Ip6 instance
 584   has been configured.
 585
 586   @param  Instance               The DNS instance
 587   @param  UdpIo                  The UDP_IO to poll
 588   @param  UdpCfgData             The UDP configure data to reconfigure the UDP_IO
 589
 590   @retval TRUE                   Configure the Udp6 instance successfully.
 591   @retval FALSE                  Some error occured.
 592
 593 **/
 594 BOOLEAN
 595 Dns6GetMapping (
 596   IN DNS_INSTANCE           *Instance,
 597   IN UDP_IO                 *UdpIo,
 598   IN EFI_UDP6_CONFIG_DATA   *UdpCfgData
 599   )
 600 {
 601   DNS_SERVICE               *Service;
 602   EFI_IP6_MODE_DATA         Ip6Mode;
 603   EFI_UDP6_PROTOCOL         *Udp;
 604   EFI_STATUS                Status;
 605
 606   Service = Instance->Service;
 607   Udp     = UdpIo->Protocol.Udp6;
 608
 609   Status = gBS->SetTimer (
 610                   Service->TimerToGetMap,
 611                   TimerRelative,
 612                   DNS_TIME_TO_GETMAP * TICKS_PER_SECOND
 613                   );
 614   if (EFI_ERROR (Status)) {
 615     return FALSE;
 616   }
 617
 618   while (!EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {
 619     Udp->Poll (Udp);
 620
 621     if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip6Mode, NULL, NULL)) &&
 622         Ip6Mode.IsConfigured) {
 623
 624       Udp->Configure (Udp, NULL);
 625       return (BOOLEAN) (Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS);
 626     }
 627   }
 628
 629   return FALSE;
 630 }
 631
 632 /**
 633   Configure the UDP.
 634
 635   @param  Instance               The DNS session
 636   @param  UdpIo                  The UDP_IO instance
 637
 638   @retval EFI_SUCCESS            The UDP is successfully configured for the
 639                                  session.
 640
 641 **/
 642 EFI_STATUS
 643 Dns4ConfigUdp (
 644   IN DNS_INSTANCE           *Instance,
 645   IN UDP_IO                 *UdpIo
 646   )
 647 {
 648   EFI_DNS4_CONFIG_DATA      *Config;
 649   EFI_UDP4_CONFIG_DATA      UdpConfig;
 650   EFI_STATUS                Status;
 651
 652   Config = &Instance->Dns4CfgData;
 653
 654   UdpConfig.AcceptBroadcast    = FALSE;
 655   UdpConfig.AcceptPromiscuous  = FALSE;
 656   UdpConfig.AcceptAnyPort      = FALSE;
 657   UdpConfig.AllowDuplicatePort = FALSE;
 658   UdpConfig.TypeOfService      = 0;
 659   UdpConfig.TimeToLive         = 128;
 660   UdpConfig.DoNotFragment      = FALSE;
 661   UdpConfig.ReceiveTimeout     = 0;
 662   UdpConfig.TransmitTimeout    = 0;
 663   UdpConfig.UseDefaultAddress  = Config->UseDefaultSetting;
 664   UdpConfig.SubnetMask         = Config->SubnetMask;
 665   UdpConfig.StationPort        = Config->LocalPort;
 666   UdpConfig.RemotePort         = DNS_SERVER_PORT;
 667
 668   CopyMem (&UdpConfig.StationAddress, &Config->StationIp, sizeof (EFI_IPv4_ADDRESS));
 669   CopyMem (&UdpConfig.RemoteAddress, &Instance->SessionDnsServer.v4, sizeof (EFI_IPv4_ADDRESS));
 670
 671   Status = UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, &UdpConfig);
 672
 673   if ((Status == EFI_NO_MAPPING) && Dns4GetMapping (Instance, UdpIo, &UdpConfig)) {
 674     return EFI_SUCCESS;
 675   }
 676
 677   return Status;
 678 }
 679
 680 /**
 681   Configure the UDP.
 682
 683   @param  Instance               The DNS session
 684   @param  UdpIo                  The UDP_IO instance
 685
 686   @retval EFI_SUCCESS            The UDP is successfully configured for the
 687                                  session.
 688
 689 **/
 690 EFI_STATUS
 691 Dns6ConfigUdp (
 692   IN DNS_INSTANCE           *Instance,
 693   IN UDP_IO                 *UdpIo
 694   )
 695 {
 696   EFI_DNS6_CONFIG_DATA      *Config;
 697   EFI_UDP6_CONFIG_DATA      UdpConfig;
 698   EFI_STATUS                Status;
 699
 700   Config = &Instance->Dns6CfgData;
 701
 702   UdpConfig.AcceptPromiscuous  = FALSE;
 703   UdpConfig.AcceptAnyPort      = FALSE;
 704   UdpConfig.AllowDuplicatePort = FALSE;
 705   UdpConfig.TrafficClass       = 0;
 706   UdpConfig.HopLimit           = 128;
 707   UdpConfig.ReceiveTimeout     = 0;
 708   UdpConfig.TransmitTimeout    = 0;
 709   UdpConfig.StationPort        = Config->LocalPort;
 710   UdpConfig.RemotePort         = DNS_SERVER_PORT;
 711   CopyMem (&UdpConfig.StationAddress, &Config->StationIp, sizeof (EFI_IPv6_ADDRESS));
 712   CopyMem (&UdpConfig.RemoteAddress, &Instance->SessionDnsServer.v6, sizeof (EFI_IPv6_ADDRESS));
 713
 714   Status = UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, &UdpConfig);
 715
 716   if ((Status == EFI_NO_MAPPING) && Dns6GetMapping (Instance, UdpIo, &UdpConfig)) {
 717     return EFI_SUCCESS;
 718   }
 719
 720   return Status;
 721 }
 722
 723 /**
 724   Update Dns4 cache to shared list of caches of all DNSv4 instances.
 725
 726   @param  Dns4CacheList      All Dns4 cache list.
 727   @param  DeleteFlag         If FALSE, this function is to add one entry to the DNS Cache.
 728                              If TRUE, this function will delete matching DNS Cache entry.
 729   @param  Override           If TRUE, the matching DNS cache entry will be overwritten with the supplied parameter.
 730                              If FALSE, EFI_ACCESS_DENIED will be returned if the entry to be added is already exists.
 731   @param  DnsCacheEntry      Entry Pointer to DNS Cache entry.
 732
 733   @retval EFI_SUCCESS        Update Dns4 cache successfully.
 734   @retval Others             Failed to update Dns4 cache.
 735
 736 **/
 737 EFI_STATUS
 738 EFIAPI
 739 UpdateDns4Cache (
 740   IN LIST_ENTRY             *Dns4CacheList,
 741   IN BOOLEAN                DeleteFlag,
 742   IN BOOLEAN                Override,
 743   IN EFI_DNS4_CACHE_ENTRY   DnsCacheEntry
 744   )
 745 {
 746   DNS4_CACHE    *NewDnsCache;
 747   DNS4_CACHE    *Item;
 748   LIST_ENTRY    *Entry;
 749   LIST_ENTRY    *Next;
 750
 751   NewDnsCache = NULL;
 752   Item        = NULL;
 753
 754   //
 755   // Search the database for the matching EFI_DNS_CACHE_ENTRY
 756   //
 757   NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns4CacheList) {
 758     Item = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
 759     if (StrCmp (DnsCacheEntry.HostName, Item->DnsCache.HostName) == 0 && \
 760         CompareMem (DnsCacheEntry.IpAddress, Item->DnsCache.IpAddress, sizeof (EFI_IPv4_ADDRESS)) == 0) {
 761       //
 762       // This is the Dns cache entry
 763       //
 764       if (DeleteFlag) {
 765         //
 766         // Delete matching DNS Cache entry
 767         //
 768         RemoveEntryList (&Item->AllCacheLink);
 769
 770         return EFI_SUCCESS;
 771       } else if (Override) {
 772         //
 773         // Update this one
 774         //
 775         Item->DnsCache.Timeout = DnsCacheEntry.Timeout;
 776
 777         return EFI_SUCCESS;
 778       }else {
 779         return EFI_ACCESS_DENIED;
 780       }
 781     }
 782   }
 783
 784   //
 785   // Add new one
 786   //
 787   NewDnsCache = AllocatePool (sizeof (DNS4_CACHE));
 788   if (NewDnsCache == NULL) {
 789     return EFI_OUT_OF_RESOURCES;
 790   }
 791
 792   InitializeListHead (&NewDnsCache->AllCacheLink);
 793
 794   NewDnsCache->DnsCache.HostName = AllocatePool (StrSize (DnsCacheEntry.HostName));
 795   if (NewDnsCache->DnsCache.HostName == NULL) {
 796     return EFI_OUT_OF_RESOURCES;
 797   }
 798
 799   CopyMem (NewDnsCache->DnsCache.HostName, DnsCacheEntry.HostName, StrSize (DnsCacheEntry.HostName));
 800
 801   NewDnsCache->DnsCache.IpAddress = AllocatePool (sizeof (EFI_IPv4_ADDRESS));
 802   if (NewDnsCache->DnsCache.IpAddress == NULL) {
 803     return EFI_OUT_OF_RESOURCES;
 804   }
 805
 806   CopyMem (NewDnsCache->DnsCache.IpAddress, DnsCacheEntry.IpAddress, sizeof (EFI_IPv4_ADDRESS));
 807
 808   NewDnsCache->DnsCache.Timeout = DnsCacheEntry.Timeout;
 809
 810   InsertTailList (Dns4CacheList, &NewDnsCache->AllCacheLink);
 811
 812   return EFI_SUCCESS;
 813 }
 814
 815 /**
 816   Update Dns6 cache to shared list of caches of all DNSv6 instances.
 817
 818   @param  Dns6CacheList      All Dns6 cache list.
 819   @param  DeleteFlag         If FALSE, this function is to add one entry to the DNS Cache.
 820                              If TRUE, this function will delete matching DNS Cache entry.
 821   @param  Override           If TRUE, the matching DNS cache entry will be overwritten with the supplied parameter.
 822                              If FALSE, EFI_ACCESS_DENIED will be returned if the entry to be added is already exists.
 823   @param  DnsCacheEntry      Entry Pointer to DNS Cache entry.
 824
 825   @retval EFI_SUCCESS        Update Dns6 cache successfully.
 826   @retval Others             Failed to update Dns6 cache.
 827 **/
 828 EFI_STATUS
 829 EFIAPI
 830 UpdateDns6Cache (
 831   IN LIST_ENTRY             *Dns6CacheList,
 832   IN BOOLEAN                DeleteFlag,
 833   IN BOOLEAN                Override,
 834   IN EFI_DNS6_CACHE_ENTRY   DnsCacheEntry
 835   )
 836 {
 837   DNS6_CACHE    *NewDnsCache;
 838   DNS6_CACHE    *Item;
 839   LIST_ENTRY    *Entry;
 840   LIST_ENTRY    *Next;
 841
 842   NewDnsCache = NULL;
 843   Item        = NULL;
 844
 845   //
 846   // Search the database for the matching EFI_DNS_CACHE_ENTRY
 847   //
 848   NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns6CacheList) {
 849     Item = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
 850     if (StrCmp (DnsCacheEntry.HostName, Item->DnsCache.HostName) == 0 && \
 851         CompareMem (DnsCacheEntry.IpAddress, Item->DnsCache.IpAddress, sizeof (EFI_IPv6_ADDRESS)) == 0) {
 852       //
 853       // This is the Dns cache entry
 854       //
 855       if (DeleteFlag) {
 856         //
 857         // Delete matching DNS Cache entry
 858         //
 859         RemoveEntryList (&Item->AllCacheLink);
 860
 861         return EFI_SUCCESS;
 862       } else if (Override) {
 863         //
 864         // Update this one
 865         //
 866         Item->DnsCache.Timeout = DnsCacheEntry.Timeout;
 867
 868         return EFI_SUCCESS;
 869       }else {
 870         return EFI_ACCESS_DENIED;
 871       }
 872     }
 873   }
 874
 875   //
 876   // Add new one
 877   //
 878   NewDnsCache = AllocatePool (sizeof (DNS6_CACHE));
 879   if (NewDnsCache == NULL) {
 880     return EFI_OUT_OF_RESOURCES;
 881   }
 882
 883   InitializeListHead (&NewDnsCache->AllCacheLink);
 884
 885   NewDnsCache->DnsCache.HostName = AllocatePool (StrSize (DnsCacheEntry.HostName));
 886   if (NewDnsCache->DnsCache.HostName == NULL) {
 887     return EFI_OUT_OF_RESOURCES;
 888   }
 889
 890   CopyMem (NewDnsCache->DnsCache.HostName, DnsCacheEntry.HostName, StrSize (DnsCacheEntry.HostName));
 891
 892   NewDnsCache->DnsCache.IpAddress = AllocatePool (sizeof (EFI_IPv6_ADDRESS));
 893   if (NewDnsCache->DnsCache.IpAddress == NULL) {
 894     return EFI_OUT_OF_RESOURCES;
 895   }
 896
 897   CopyMem (NewDnsCache->DnsCache.IpAddress, DnsCacheEntry.IpAddress, sizeof (EFI_IPv6_ADDRESS));
 898
 899   NewDnsCache->DnsCache.Timeout = DnsCacheEntry.Timeout;
 900
 901   InsertTailList (Dns6CacheList, &NewDnsCache->AllCacheLink);
 902
 903   return EFI_SUCCESS;
 904 }
 905
 906 /**
 907   Add Dns4 ServerIp to common list of addresses of all configured DNSv4 server.
 908
 909   @param  Dns4ServerList    Common list of addresses of all configured DNSv4 server.
 910   @param  ServerIp          DNS server Ip.
 911
 912   @retval EFI_SUCCESS       Add Dns4 ServerIp to common list successfully.
 913   @retval Others            Failed to add Dns4 ServerIp to common list.
 914
 915 **/
 916 EFI_STATUS
 917 EFIAPI
 918 AddDns4ServerIp (
 919   IN LIST_ENTRY                *Dns4ServerList,
 920   IN EFI_IPv4_ADDRESS           ServerIp
 921   )
 922 {
 923   DNS4_SERVER_IP    *NewServerIp;
 924   DNS4_SERVER_IP    *Item;
 925   LIST_ENTRY        *Entry;
 926   LIST_ENTRY        *Next;
 927
 928   NewServerIp = NULL;
 929   Item        = NULL;
 930
 931   //
 932   // Search the database for the matching ServerIp
 933   //
 934   NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns4ServerList) {
 935     Item = NET_LIST_USER_STRUCT (Entry, DNS4_SERVER_IP, AllServerLink);
 936     if (CompareMem (&Item->Dns4ServerIp, &ServerIp, sizeof (EFI_IPv4_ADDRESS)) == 0) {
 937       //
 938       // Already done.
 939       //
 940       return EFI_SUCCESS;
 941     }
 942   }
 943
 944   //
 945   // Add new one
 946   //
 947   NewServerIp = AllocatePool (sizeof (DNS4_SERVER_IP));
 948   if (NewServerIp == NULL) {
 949     return EFI_OUT_OF_RESOURCES;
 950   }
 951
 952   InitializeListHead (&NewServerIp->AllServerLink);
 953
 954   CopyMem (&NewServerIp->Dns4ServerIp, &ServerIp, sizeof (EFI_IPv4_ADDRESS));
 955
 956   InsertTailList (Dns4ServerList, &NewServerIp->AllServerLink);
 957
 958   return EFI_SUCCESS;
 959 }
 960
 961 /**
 962   Add Dns6 ServerIp to common list of addresses of all configured DNSv6 server.
 963
 964   @param  Dns6ServerList    Common list of addresses of all configured DNSv6 server.
 965   @param  ServerIp          DNS server Ip.
 966
 967   @retval EFI_SUCCESS       Add Dns6 ServerIp to common list successfully.
 968   @retval Others            Failed to add Dns6 ServerIp to common list.
 969
 970 **/
 971 EFI_STATUS
 972 EFIAPI
 973 AddDns6ServerIp (
 974   IN LIST_ENTRY                *Dns6ServerList,
 975   IN EFI_IPv6_ADDRESS           ServerIp
 976   )
 977 {
 978   DNS6_SERVER_IP    *NewServerIp;
 979   DNS6_SERVER_IP    *Item;
 980   LIST_ENTRY        *Entry;
 981   LIST_ENTRY        *Next;
 982
 983   NewServerIp = NULL;
 984   Item        = NULL;
 985
 986   //
 987   // Search the database for the matching ServerIp
 988   //
 989   NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns6ServerList) {
 990     Item = NET_LIST_USER_STRUCT (Entry, DNS6_SERVER_IP, AllServerLink);
 991     if (CompareMem (&Item->Dns6ServerIp, &ServerIp, sizeof (EFI_IPv6_ADDRESS)) == 0) {
 992       //
 993       // Already done.
 994       //
 995       return EFI_SUCCESS;
 996     }
 997   }
 998
 999   //
1000   // Add new one
1001   //
1002   NewServerIp = AllocatePool (sizeof (DNS6_SERVER_IP));
1003   if (NewServerIp == NULL) {
1004     return EFI_OUT_OF_RESOURCES;
1005   }
1006
1007   InitializeListHead (&NewServerIp->AllServerLink);
1008
1009   CopyMem (&NewServerIp->Dns6ServerIp, &ServerIp, sizeof (EFI_IPv6_ADDRESS));
1010
1011   InsertTailList (Dns6ServerList, &NewServerIp->AllServerLink);
1012
1013   return EFI_SUCCESS;
1014 }
1015
1016 /**
1017   Find out whether the response is valid or invalid.
1018
1019   @param  TokensMap       All DNS transmittal Tokens entry.
1020   @param  Identification  Identification for queried packet.
1021   @param  Type            Type for queried packet.
1022   @param  Item            Return corresponding Token entry.
1023
1024   @retval TRUE            The response is valid.
1025   @retval FALSE           The response is invalid.
1026
1027 **/
1028 BOOLEAN
1029 IsValidDnsResponse (
1030   IN     NET_MAP      *TokensMap,
1031   IN     UINT16       Identification,
1032   IN     UINT16       Type,
1033      OUT NET_MAP_ITEM **Item
1034   )
1035 {
1036   LIST_ENTRY              *Entry;
1037
1038   NET_BUF                 *Packet;
1039   UINT8                   *TxString;
1040   DNS_HEADER              *DnsHeader;
1041   CHAR8                   *QueryName;
1042   DNS_QUERY_SECTION       *QuerySection;
1043
1044   NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {
1045     *Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1046     Packet = (NET_BUF *) ((*Item)->Value);
1047     if (Packet == NULL){
1048
1049       continue;
1050     } else {
1051       TxString = NetbufGetByte (Packet, 0, NULL);
1052       ASSERT (TxString != NULL);
1053       DnsHeader = (DNS_HEADER *) TxString;
1054       QueryName = (CHAR8 *) (TxString + sizeof (*DnsHeader));
1055       QuerySection = (DNS_QUERY_SECTION *) (QueryName + AsciiStrLen (QueryName) + 1);
1056
1057       DnsHeader->Identification = NTOHS (DnsHeader->Identification);
1058       QuerySection->Type = NTOHS (QuerySection->Type);
1059
1060       if (DnsHeader->Identification == Identification && QuerySection->Type == Type) {
1061         return TRUE;
1062       }
1063     }
1064   }
1065
1066   *Item =NULL;
1067
1068   return FALSE;
1069 }
1070
1071 /**
1072   Parse Dns Response.
1073
1074   @param  Instance              The DNS instance
1075   @param  RxString              Received buffer.
1076   @param  Completed             Flag to indicate that Dns response is valid.
1077
1078   @retval EFI_SUCCESS           Parse Dns Response successfully.
1079   @retval Others                Failed to parse Dns Response.
1080
1081 **/
1082 EFI_STATUS
1083 ParseDnsResponse (
1084   IN OUT DNS_INSTANCE              *Instance,
1085   IN     UINT8                     *RxString,
1086      OUT BOOLEAN                   *Completed
1087   )
1088 {
1089   DNS_HEADER            *DnsHeader;
1090
1091   CHAR8                 *QueryName;
1092   DNS_QUERY_SECTION     *QuerySection;
1093
1094   CHAR8                 *AnswerName;
1095   DNS_ANSWER_SECTION    *AnswerSection;
1096   UINT8                 *AnswerData;
1097
1098   NET_MAP_ITEM          *Item;
1099   DNS4_TOKEN_ENTRY      *Dns4TokenEntry;
1100   DNS6_TOKEN_ENTRY      *Dns6TokenEntry;
1101
1102   UINT32                IpCount;
1103   UINT32                AnswerSectionNum;
1104
1105   EFI_IPv4_ADDRESS      *HostAddr4;
1106   EFI_IPv6_ADDRESS      *HostAddr6;
1107
1108   EFI_DNS4_CACHE_ENTRY  *Dns4CacheEntry;
1109   EFI_DNS6_CACHE_ENTRY  *Dns6CacheEntry;
1110
1111   EFI_STATUS            Status;
1112
1113   EFI_TPL               OldTpl;
1114
1115   Item             = NULL;
1116   Dns4TokenEntry   = NULL;
1117   Dns6TokenEntry   = NULL;
1118
1119   IpCount          = 0;
1120   AnswerSectionNum = 0;
1121
1122   HostAddr4        = NULL;
1123   HostAddr6        = NULL;
1124
1125   Dns4CacheEntry   = NULL;
1126   Dns6CacheEntry   = NULL;
1127
1128   *Completed       = TRUE;
1129   Status           = EFI_SUCCESS;
1130
1131   //
1132   // Get header
1133   //
1134   DnsHeader = (DNS_HEADER *) RxString;
1135
1136   DnsHeader->Identification = NTOHS (DnsHeader->Identification);
1137   DnsHeader->Flags.Uint16 = NTOHS (DnsHeader->Flags.Uint16);
1138   DnsHeader->QuestionsNum = NTOHS (DnsHeader->QuestionsNum);
1139   DnsHeader->AnswersNum = NTOHS (DnsHeader->AnswersNum);
1140   DnsHeader->AuthorityNum = NTOHS (DnsHeader->AuthorityNum);
1141   DnsHeader->AditionalNum = NTOHS (DnsHeader->AditionalNum);
1142
1143   //
1144   // Get Query name
1145   //
1146   QueryName = (CHAR8 *) (RxString + sizeof (*DnsHeader));
1147
1148   //
1149   // Get query section
1150   //
1151   QuerySection = (DNS_QUERY_SECTION *) (QueryName + AsciiStrLen (QueryName) + 1);
1152   QuerySection->Type = NTOHS (QuerySection->Type);
1153   QuerySection->Class = NTOHS (QuerySection->Class);
1154
1155   //
1156   // Get Answer name
1157   //
1158   AnswerName = (CHAR8 *) QuerySection + sizeof (*QuerySection);
1159
1160   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1161
1162   //
1163   // Check DnsResponse Validity, if so, also get a valid NET_MAP_ITEM.
1164   //
1165   if (Instance->Service->IpVersion == IP_VERSION_4) {
1166     if (!IsValidDnsResponse (&Instance->Dns4TxTokens, DnsHeader->Identification, QuerySection->Type, &Item)) {
1167       *Completed = FALSE;
1168       Status = EFI_ABORTED;
1169       goto ON_EXIT;
1170     }
1171     ASSERT (Item != NULL);
1172     Dns4TokenEntry = (DNS4_TOKEN_ENTRY *) (Item->Key);
1173   } else {
1174     if (!IsValidDnsResponse (&Instance->Dns6TxTokens, DnsHeader->Identification, QuerySection->Type, &Item)) {
1175       *Completed = FALSE;
1176       Status = EFI_ABORTED;
1177       goto ON_EXIT;
1178     }
1179     ASSERT (Item != NULL);
1180     Dns6TokenEntry = (DNS6_TOKEN_ENTRY *) (Item->Key);
1181   }
1182
1183   //
1184   // Continue Check Some Errors.
1185   //
1186   if (DnsHeader->Flags.Bits.RCode != DNS_FLAGS_RCODE_NO_ERROR || DnsHeader->AnswersNum < 1 || \
1187       DnsHeader->Flags.Bits.QR != DNS_FLAGS_QR_RESPONSE || QuerySection->Class != DNS_CLASS_INET) {
1188       Status = EFI_ABORTED;
1189       goto ON_EXIT;
1190   }
1191
1192   //
1193   // Free the sending packet.
1194   //
1195   if (Item->Value != NULL) {
1196     NetbufFree ((NET_BUF *) (Item->Value));
1197   }
1198
1199   //
1200   // Check the Query type, do some buffer allocations.
1201   //
1202   if (QuerySection->Type == DNS_TYPE_A) {
1203     Dns4TokenEntry->Token->RspData.H2AData = AllocatePool (sizeof (DNS_HOST_TO_ADDR_DATA));
1204     ASSERT (Dns4TokenEntry->Token->RspData.H2AData != NULL);
1205     Dns4TokenEntry->Token->RspData.H2AData->IpList = AllocatePool (DnsHeader->AnswersNum * sizeof (EFI_IPv4_ADDRESS));
1206     ASSERT (Dns4TokenEntry->Token->RspData.H2AData->IpList != NULL);
1207   } else if (QuerySection->Type == DNS_TYPE_AAAA) {
1208     Dns6TokenEntry->Token->RspData.H2AData = AllocatePool (sizeof (DNS6_HOST_TO_ADDR_DATA));
1209     ASSERT (Dns6TokenEntry->Token->RspData.H2AData != NULL);
1210     Dns6TokenEntry->Token->RspData.H2AData->IpList = AllocatePool (DnsHeader->AnswersNum * sizeof (EFI_IPv6_ADDRESS));
1211     ASSERT (Dns6TokenEntry->Token->RspData.H2AData->IpList != NULL);
1212   } else {
1213     Status = EFI_UNSUPPORTED;
1214     goto ON_EXIT;
1215   }
1216
1217   //
1218   // Processing AnswerSection.
1219   //
1220   while (AnswerSectionNum < DnsHeader->AnswersNum) {
1221     //
1222     // Answer name should be PTR.
1223     //
1224     ASSERT ((*(UINT8 *) AnswerName & 0xC0) == 0xC0);
1225
1226     //
1227     // Get Answer section.
1228     //
1229     AnswerSection = (DNS_ANSWER_SECTION *) (AnswerName + sizeof (UINT16));
1230     AnswerSection->Type = NTOHS (AnswerSection->Type);
1231     AnswerSection->Class = NTOHS (AnswerSection->Class);
1232     AnswerSection->Ttl = NTOHL (AnswerSection->Ttl);
1233     AnswerSection->DataLength = NTOHS (AnswerSection->DataLength);
1234
1235     ASSERT (AnswerSection->Class == DNS_CLASS_INET);
1236
1237     if (AnswerSection->Type == QuerySection->Type) {
1238       switch (AnswerSection->Type) {
1239       case DNS_TYPE_A:
1240         //
1241         // This is address entry, get Data.
1242         //
1243         ASSERT (AnswerSection->DataLength == 4);
1244
1245         HostAddr4 = Dns4TokenEntry->Token->RspData.H2AData->IpList;
1246         AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1247         CopyMem (&HostAddr4[IpCount], AnswerData, sizeof (EFI_IPv4_ADDRESS));
1248
1249         //
1250         // Update DNS cache dynamically.
1251         //
1252         if (Dns4CacheEntry != NULL) {
1253           if (Dns4CacheEntry->HostName != NULL) {
1254             FreePool (Dns4CacheEntry->HostName);
1255           }
1256
1257           if (Dns4CacheEntry->IpAddress != NULL) {
1258             FreePool (Dns4CacheEntry->IpAddress);
1259           }
1260
1261           FreePool (Dns4CacheEntry);
1262         }
1263
1264         //
1265         // Allocate new CacheEntry pool.
1266         //
1267         Dns4CacheEntry = AllocateZeroPool (sizeof (EFI_DNS4_CACHE_ENTRY));
1268         ASSERT (Dns4CacheEntry != NULL);
1269         Dns4CacheEntry->HostName = AllocateZeroPool (2 * (StrLen(Dns4TokenEntry->QueryHostName) + 1));
1270         ASSERT (Dns4CacheEntry->HostName != NULL);
1271         CopyMem (Dns4CacheEntry->HostName, Dns4TokenEntry->QueryHostName, 2 * (StrLen(Dns4TokenEntry->QueryHostName) + 1));
1272         Dns4CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv4_ADDRESS));
1273         ASSERT (Dns4CacheEntry->IpAddress != NULL);
1274         CopyMem (Dns4CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv4_ADDRESS));
1275         Dns4CacheEntry->Timeout = AnswerSection->Ttl;
1276
1277         UpdateDns4Cache (&mDriverData->Dns4CacheList, FALSE, TRUE, *Dns4CacheEntry);
1278
1279         IpCount ++;
1280         break;
1281       case DNS_TYPE_AAAA:
1282         //
1283         // This is address entry, get Data.
1284         //
1285         ASSERT (AnswerSection->DataLength == 16);
1286
1287         HostAddr6 = Dns6TokenEntry->Token->RspData.H2AData->IpList;
1288         AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1289         CopyMem (&HostAddr6[IpCount], AnswerData, sizeof (EFI_IPv6_ADDRESS));
1290
1291         //
1292         // Update DNS cache dynamically.
1293         //
1294         if (Dns6CacheEntry != NULL) {
1295           if (Dns6CacheEntry->HostName != NULL) {
1296             FreePool (Dns6CacheEntry->HostName);
1297           }
1298
1299           if (Dns6CacheEntry->IpAddress != NULL) {
1300             FreePool (Dns6CacheEntry->IpAddress);
1301           }
1302
1303           FreePool (Dns6CacheEntry);
1304         }
1305
1306         //
1307         // Allocate new CacheEntry pool.
1308         //
1309         Dns6CacheEntry = AllocateZeroPool (sizeof (EFI_DNS6_CACHE_ENTRY));
1310         ASSERT (Dns6CacheEntry != NULL);
1311         Dns6CacheEntry->HostName = AllocateZeroPool (2 * (StrLen(Dns6TokenEntry->QueryHostName) + 1));
1312         ASSERT (Dns6CacheEntry->HostName != NULL);
1313         CopyMem (Dns6CacheEntry->HostName, Dns6TokenEntry->QueryHostName, 2 * (StrLen(Dns6TokenEntry->QueryHostName) + 1));
1314         Dns6CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv6_ADDRESS));
1315         ASSERT (Dns6CacheEntry->IpAddress != NULL);
1316         CopyMem (Dns6CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv6_ADDRESS));
1317         Dns6CacheEntry->Timeout = AnswerSection->Ttl;
1318
1319         UpdateDns6Cache (&mDriverData->Dns6CacheList, FALSE, TRUE, *Dns6CacheEntry);
1320
1321         IpCount ++;
1322         break;
1323       default:
1324         Status = EFI_UNSUPPORTED;
1325         goto ON_EXIT;
1326       }
1327     }
1328
1329     //
1330     // Find next one
1331     //
1332     AnswerName = (CHAR8 *) AnswerSection + sizeof (*AnswerSection) + AnswerSection->DataLength;
1333     AnswerSectionNum ++;
1334   }
1335
1336   if (QuerySection->Type == DNS_TYPE_A) {
1337     Dns4TokenEntry->Token->RspData.H2AData->IpCount = IpCount;
1338   } else if (QuerySection->Type == DNS_TYPE_AAAA) {
1339     Dns6TokenEntry->Token->RspData.H2AData->IpCount = IpCount;
1340   }
1341
1342   //
1343   // Parsing is complete, SignalEvent here.
1344   //
1345   if (Instance->Service->IpVersion == IP_VERSION_4) {
1346     Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);
1347     Dns4TokenEntry->Token->Status = EFI_SUCCESS;
1348     if (Dns4TokenEntry->Token->Event != NULL) {
1349       gBS->SignalEvent (Dns4TokenEntry->Token->Event);
1350       DispatchDpc ();
1351     }
1352   } else {
1353     Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);
1354     Dns6TokenEntry->Token->Status = EFI_SUCCESS;
1355     if (Dns6TokenEntry->Token->Event != NULL) {
1356       gBS->SignalEvent (Dns6TokenEntry->Token->Event);
1357       DispatchDpc ();
1358     }
1359   }
1360
1361   //
1362   // Free allocated CacheEntry pool.
1363   //
1364   if (Dns4CacheEntry != NULL) {
1365     if (Dns4CacheEntry->HostName != NULL) {
1366       FreePool (Dns4CacheEntry->HostName);
1367     }
1368
1369     if (Dns4CacheEntry->IpAddress != NULL) {
1370       FreePool (Dns4CacheEntry->IpAddress);
1371     }
1372
1373     FreePool (Dns4CacheEntry);
1374   }
1375
1376   if (Dns6CacheEntry != NULL) {
1377     if (Dns6CacheEntry->HostName != NULL) {
1378       FreePool (Dns6CacheEntry->HostName);
1379     }
1380
1381     if (Dns6CacheEntry->IpAddress != NULL) {
1382       FreePool (Dns6CacheEntry->IpAddress);
1383     }
1384
1385     FreePool (Dns6CacheEntry);
1386   }
1387
1388 ON_EXIT:
1389   gBS->RestoreTPL (OldTpl);
1390   return Status;
1391 }
1392
1393 /**
1394   Parse response packet.
1395
1396   @param  Packet                The packets received.
1397   @param  EndPoint              The local/remote UDP access point
1398   @param  IoStatus              The status of the UDP receive
1399   @param  Context               The opaque parameter to the function.
1400
1401 **/
1402 VOID
1403 EFIAPI
1404 DnsOnPacketReceived (
1405   NET_BUF                   *Packet,
1406   UDP_END_POINT             *EndPoint,
1407   EFI_STATUS                IoStatus,
1408   VOID                      *Context
1409   )
1410 {
1411   DNS_INSTANCE              *Instance;
1412
1413   UINT8                     *RcvString;
1414
1415   BOOLEAN                   Completed;
1416
1417   Instance  = (DNS_INSTANCE *) Context;
1418   NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);
1419
1420   RcvString = NULL;
1421   Completed = FALSE;
1422
1423   if (EFI_ERROR (IoStatus)) {
1424     goto ON_EXIT;
1425   }
1426
1427   ASSERT (Packet != NULL);
1428
1429   RcvString = NetbufGetByte (Packet, 0, NULL);
1430   ASSERT (RcvString != NULL);
1431
1432   //
1433   // Parse Dns Response
1434   //
1435   ParseDnsResponse (Instance, RcvString, &Completed);
1436
1437   ON_EXIT:
1438
1439     if (Packet != NULL) {
1440       NetbufFree (Packet);
1441     }
1442
1443     if (!Completed) {
1444       UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);
1445     }
1446 }
1447
1448 /**
1449   Release the net buffer when packet is sent.
1450
1451   @param  Packet                The packets received.
1452   @param  EndPoint              The local/remote UDP access point
1453   @param  IoStatus              The status of the UDP receive
1454   @param  Context               The opaque parameter to the function.
1455
1456 **/
1457 VOID
1458 EFIAPI
1459 DnsOnPacketSent (
1460   NET_BUF                   *Packet,
1461   UDP_END_POINT             *EndPoint,
1462   EFI_STATUS                IoStatus,
1463   VOID                      *Context
1464   )
1465 {
1466   DNS_INSTANCE              *Instance;
1467   LIST_ENTRY                *Entry;
1468   NET_MAP_ITEM              *Item;
1469   DNS4_TOKEN_ENTRY          *Dns4TokenEntry;
1470   DNS6_TOKEN_ENTRY          *Dns6TokenEntry;
1471
1472   Dns4TokenEntry = NULL;
1473   Dns6TokenEntry = NULL;
1474
1475   Instance  = (DNS_INSTANCE *) Context;
1476   NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);
1477
1478   if (Instance->Service->IpVersion == IP_VERSION_4) {
1479     NET_LIST_FOR_EACH (Entry, &Instance->Dns4TxTokens.Used) {
1480       Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1481       if (Packet == (NET_BUF *)(Item->Value)) {
1482         Dns4TokenEntry = ((DNS4_TOKEN_ENTRY *)Item->Key);
1483         Dns4TokenEntry->PacketToLive = Dns4TokenEntry->Token->RetryInterval;
1484         break;
1485       }
1486     }
1487   } else {
1488     NET_LIST_FOR_EACH (Entry, &Instance->Dns6TxTokens.Used) {
1489       Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1490       if (Packet == (NET_BUF *)(Item->Value)) {
1491         Dns6TokenEntry = ((DNS6_TOKEN_ENTRY *)Item->Key);
1492         Dns6TokenEntry->PacketToLive = Dns6TokenEntry->Token->RetryInterval;
1493         break;
1494       }
1495     }
1496   }
1497
1498   NetbufFree (Packet);
1499 }
1500
1501 /**
1502   Query request information.
1503
1504   @param  Instance              The DNS instance
1505   @param  Packet                The packet for querying request information.
1506
1507   @retval EFI_SUCCESS           Query request information successfully.
1508   @retval Others                Failed to query request information.
1509
1510 **/
1511 EFI_STATUS
1512 DoDnsQuery (
1513   IN  DNS_INSTANCE              *Instance,
1514   IN  NET_BUF                   *Packet
1515   )
1516 {
1517   EFI_STATUS      Status;
1518
1519   //
1520   // Ready to receive the DNS response.
1521   //
1522   if (Instance->UdpIo->RecvRequest == NULL) {
1523     Status = UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);
1524     if (EFI_ERROR (Status)) {
1525       return Status;
1526     }
1527   }
1528
1529   //
1530   // Transmit the DNS packet.
1531   //
1532   NET_GET_REF (Packet);
1533
1534   Status = UdpIoSendDatagram (Instance->UdpIo, Packet, NULL, NULL, DnsOnPacketSent, Instance);
1535
1536   return Status;
1537 }
1538
1539 /**
1540   Construct the Packet to query Ip.
1541
1542   @param  Instance              The DNS instance
1543   @param  HostName              Queried HostName
1544   @param  Type                  DNS query Type
1545   @param  Packet                The packet for querying Ip
1546
1547   @retval EFI_SUCCESS           The packet is constructed.
1548   @retval Others                Failed to construct the Packet.
1549
1550 **/
1551 EFI_STATUS
1552 ConstructDNSQueryIp (
1553   IN  DNS_INSTANCE              *Instance,
1554   IN  CHAR16                    *HostName,
1555   IN  UINT16                    Type,
1556   OUT NET_BUF                   **Packet
1557   )
1558 {
1559   NET_FRAGMENT        Frag;
1560   DNS_HEADER          *DnsHeader;
1561   CHAR8               *QueryName;
1562   DNS_QUERY_SECTION   *QuerySection;
1563   CHAR8               *Header;
1564   CHAR8               *Tail;
1565   UINTN               Len;
1566   UINTN               Index;
1567
1568
1569   Frag.Bulk = AllocatePool (DNS_DEFAULT_BLKSIZE * sizeof (UINT8));
1570   if (Frag.Bulk == NULL) {
1571     return EFI_OUT_OF_RESOURCES;
1572   }
1573
1574   //
1575   // Fill header
1576   //
1577   DnsHeader = (DNS_HEADER *) Frag.Bulk;
1578   DnsHeader->Identification = (UINT16)NET_RANDOM (NetRandomInitSeed());
1579   DnsHeader->Flags.Uint16 = 0x0000;
1580   DnsHeader->Flags.Bits.RD = 1;
1581   DnsHeader->Flags.Bits.OpCode = DNS_FLAGS_OPCODE_STANDARD;
1582   DnsHeader->Flags.Bits.QR = DNS_FLAGS_QR_QUERY;
1583   DnsHeader->QuestionsNum = 1;
1584   DnsHeader->AnswersNum = 0;
1585   DnsHeader->AuthorityNum = 0;
1586   DnsHeader->AditionalNum = 0;
1587
1588   DnsHeader->Identification = HTONS (DnsHeader->Identification);
1589   DnsHeader->Flags.Uint16 = HTONS (DnsHeader->Flags.Uint16);
1590   DnsHeader->QuestionsNum = HTONS (DnsHeader->QuestionsNum);
1591   DnsHeader->AnswersNum = HTONS (DnsHeader->AnswersNum);
1592   DnsHeader->AuthorityNum = HTONS (DnsHeader->AuthorityNum);
1593   DnsHeader->AditionalNum = HTONS (DnsHeader->AditionalNum);
1594
1595   Frag.Len = sizeof (*DnsHeader);
1596
1597   //
1598   // Fill Query name
1599   //
1600   QueryName = (CHAR8 *) (Frag.Bulk + Frag.Len);
1601   Header = QueryName;
1602   Tail = Header + 1;
1603   Len = 0;
1604   for (Index = 0; HostName[Index] != 0; Index++) {
1605     *Tail = (CHAR8) HostName[Index];
1606     if (*Tail == '.') {
1607       *Header = (CHAR8) Len;
1608       Header = Tail;
1609       Tail ++;
1610       Len = 0;
1611     } else {
1612       Tail++;
1613       Len++;
1614     }
1615   }
1616   *Header = (CHAR8) Len;
1617   *Tail = 0;
1618   Frag.Len = (UINT32) (Frag.Len + StrLen (HostName) + 2); /// 1 for header, 1 for tail.
1619
1620   //
1621   // Rest query section
1622   //
1623   QuerySection = (DNS_QUERY_SECTION *) (Frag.Bulk + Frag.Len);
1624   QuerySection->Type = Type;
1625   QuerySection->Class = DNS_CLASS_INET;
1626
1627   QuerySection->Type = HTONS (QuerySection->Type);
1628   QuerySection->Class = HTONS (QuerySection->Class);
1629
1630   Frag.Len += sizeof (*QuerySection);
1631
1632   //
1633   // Wrap the Frag in a net buffer.
1634   //
1635   *Packet = NetbufFromExt (&Frag, 1, 0, 0, DnsDummyExtFree, NULL);
1636   if (*Packet == NULL) {
1637     FreePool (Frag.Bulk);
1638     return EFI_OUT_OF_RESOURCES;
1639   }
1640
1641   //
1642   // Store the UdpIo in ProtoData.
1643   //
1644   *((UINTN *) &((*Packet)->ProtoData[0])) = (UINTN) (Instance->UdpIo);
1645
1646   return EFI_SUCCESS;
1647 }
1648
1649 /**
1650   Retransmit the packet.
1651
1652   @param  Instance              The DNS instance
1653   @param  Packet                Retransmit the packet
1654
1655   @retval EFI_SUCCESS           The packet is retransmitted.
1656   @retval Others                Failed to retransmit.
1657
1658 **/
1659 EFI_STATUS
1660 DnsRetransmit (
1661   IN DNS_INSTANCE        *Instance,
1662   IN NET_BUF             *Packet
1663   )
1664 {
1665   EFI_STATUS      Status;
1666
1667   UINT8           *Buffer;
1668
1669   ASSERT (Packet != NULL);
1670
1671   //
1672   // Set the requests to the listening port, other packets to the connected port
1673   //
1674   Buffer = NetbufGetByte (Packet, 0, NULL);
1675   ASSERT (Buffer != NULL);
1676
1677   NET_GET_REF (Packet);
1678
1679   Status = UdpIoSendDatagram (
1680              Instance->UdpIo,
1681              Packet,
1682              NULL,
1683              NULL,
1684              DnsOnPacketSent,
1685              Instance
1686              );
1687
1688   if (EFI_ERROR (Status)) {
1689     NET_PUT_REF (Packet);
1690   }
1691
1692   return Status;
1693 }
1694
1695 /**
1696   The timer ticking function for the DNS services.
1697
1698   @param  Event                 The ticking event
1699   @param  Context               The DNS service instance
1700
1701 **/
1702 VOID
1703 EFIAPI
1704 DnsOnTimerRetransmit (
1705   IN EFI_EVENT              Event,
1706   IN VOID                   *Context
1707   )
1708 {
1709   DNS_SERVICE                *Service;
1710
1711   LIST_ENTRY                 *Entry;
1712   LIST_ENTRY                 *Next;
1713
1714   DNS_INSTANCE               *Instance;
1715   LIST_ENTRY                 *EntryNetMap;
1716   NET_MAP_ITEM               *ItemNetMap;
1717   DNS4_TOKEN_ENTRY           *Dns4TokenEntry;
1718   DNS6_TOKEN_ENTRY           *Dns6TokenEntry;
1719
1720   Dns4TokenEntry = NULL;
1721   Dns6TokenEntry = NULL;
1722
1723   Service = (DNS_SERVICE *) Context;
1724
1725
1726   if (Service->IpVersion == IP_VERSION_4) {
1727     //
1728     // Iterate through all the children of the DNS service instance. Time
1729     // out the packet. If maximum retries reached, clean the Token up.
1730     //
1731     NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns4ChildrenList) {
1732       Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);
1733
1734       EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;
1735       while (EntryNetMap != &Instance->Dns4TxTokens.Used) {
1736         ItemNetMap = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);
1737         Dns4TokenEntry = (DNS4_TOKEN_ENTRY *)(ItemNetMap->Key);
1738         if (Dns4TokenEntry->PacketToLive == 0 || (--Dns4TokenEntry->PacketToLive > 0)) {
1739           EntryNetMap = EntryNetMap->ForwardLink;
1740           continue;
1741         }
1742
1743         //
1744         // Retransmit the packet if haven't reach the maxmium retry count,
1745         // otherwise exit the transfer.
1746         //
1747         if (++Dns4TokenEntry->Token->RetryCount < Instance->MaxRetry) {
1748           DnsRetransmit (Instance, (NET_BUF *)ItemNetMap->Value);
1749           EntryNetMap = EntryNetMap->ForwardLink;
1750         } else {
1751           //
1752           // Maximum retries reached, clean the Token up.
1753           //
1754           Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);
1755           Dns4TokenEntry->Token->Status = EFI_TIMEOUT;
1756           gBS->SignalEvent (Dns4TokenEntry->Token->Event);
1757           DispatchDpc ();
1758
1759           //
1760           // Free the sending packet.
1761           //
1762           if (ItemNetMap->Value != NULL) {
1763             NetbufFree ((NET_BUF *)(ItemNetMap->Value));
1764           }
1765
1766           EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;
1767         }
1768       }
1769     }
1770   }else {
1771     //
1772     // Iterate through all the children of the DNS service instance. Time
1773     // out the packet. If maximum retries reached, clean the Token up.
1774     //
1775     NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns6ChildrenList) {
1776       Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);
1777
1778       EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;
1779       while (EntryNetMap != &Instance->Dns6TxTokens.Used) {
1780         ItemNetMap = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);
1781         Dns6TokenEntry = (DNS6_TOKEN_ENTRY *) (ItemNetMap->Key);
1782         if (Dns6TokenEntry->PacketToLive == 0 || (--Dns6TokenEntry->PacketToLive > 0)) {
1783           EntryNetMap = EntryNetMap->ForwardLink;
1784           continue;
1785         }
1786
1787         //
1788         // Retransmit the packet if haven't reach the maxmium retry count,
1789         // otherwise exit the transfer.
1790         //
1791         if (++Dns6TokenEntry->Token->RetryCount < Instance->MaxRetry) {
1792           DnsRetransmit (Instance, (NET_BUF *) ItemNetMap->Value);
1793           EntryNetMap = EntryNetMap->ForwardLink;
1794         } else {
1795           //
1796           // Maximum retries reached, clean the Token up.
1797           //
1798           Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);
1799           Dns6TokenEntry->Token->Status = EFI_TIMEOUT;
1800           gBS->SignalEvent (Dns6TokenEntry->Token->Event);
1801           DispatchDpc ();
1802
1803           //
1804           // Free the sending packet.
1805           //
1806           if (ItemNetMap->Value != NULL) {
1807             NetbufFree ((NET_BUF *) (ItemNetMap->Value));
1808           }
1809
1810           EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;
1811         }
1812       }
1813     }
1814   }
1815 }
1816
1817 /**
1818   The timer ticking function for the DNS driver.
1819
1820   @param  Event                 The ticking event
1821   @param  Context               NULL
1822
1823 **/
1824 VOID
1825 EFIAPI
1826 DnsOnTimerUpdate (
1827   IN EFI_EVENT              Event,
1828   IN VOID                   *Context
1829   )
1830 {
1831   LIST_ENTRY                 *Entry;
1832   LIST_ENTRY                 *Next;
1833   DNS4_CACHE                 *Item4;
1834   DNS6_CACHE                 *Item6;
1835
1836   Item4 = NULL;
1837   Item6 = NULL;
1838
1839   //
1840   // Iterate through all the DNS4 cache list.
1841   //
1842   NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns4CacheList) {
1843     Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
1844     Item4->DnsCache.Timeout--;
1845   }
1846
1847   Entry = mDriverData->Dns4CacheList.ForwardLink;
1848   while (Entry != &mDriverData->Dns4CacheList) {
1849     Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
1850     if (Item4->DnsCache.Timeout<=0) {
1851       RemoveEntryList (&Item4->AllCacheLink);
1852       Entry = mDriverData->Dns4CacheList.ForwardLink;
1853     } else {
1854       Entry = Entry->ForwardLink;
1855     }
1856   }
1857
1858   //
1859   // Iterate through all the DNS6 cache list.
1860   //
1861   NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns6CacheList) {
1862     Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
1863     Item6->DnsCache.Timeout--;
1864   }
1865
1866   Entry = mDriverData->Dns6CacheList.ForwardLink;
1867   while (Entry != &mDriverData->Dns6CacheList) {
1868     Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
1869     if (Item6->DnsCache.Timeout<=0) {
1870       RemoveEntryList (&Item6->AllCacheLink);
1871       Entry = mDriverData->Dns6CacheList.ForwardLink;
1872     } else {
1873       Entry = Entry->ForwardLink;
1874     }
1875   }
1876 }
1877