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       DnsHeader = (DNS_HEADER *) TxString;
1053       QueryName = (CHAR8 *) (TxString + sizeof (*DnsHeader));
1054       QuerySection = (DNS_QUERY_SECTION *) (QueryName + AsciiStrLen (QueryName) + 1);
1055
1056       DnsHeader->Identification = NTOHS (DnsHeader->Identification);
1057       QuerySection->Type = NTOHS (QuerySection->Type);
1058
1059       if (DnsHeader->Identification == Identification && QuerySection->Type == Type) {
1060         return TRUE;
1061       }
1062     }
1063   }
1064
1065   *Item =NULL;
1066
1067   return FALSE;
1068 }
1069
1070 /**
1071   Parse Dns Response.
1072
1073   @param  Instance              The DNS instance
1074   @param  RxString              Received buffer.
1075   @param  Completed             Flag to indicate that Dns response is valid.
1076
1077   @retval EFI_SUCCESS           Parse Dns Response successfully.
1078   @retval Others                Failed to parse Dns Response.
1079
1080 **/
1081 EFI_STATUS
1082 ParseDnsResponse (
1083   IN OUT DNS_INSTANCE              *Instance,
1084   IN     UINT8                     *RxString,
1085      OUT BOOLEAN                   *Completed
1086   )
1087 {
1088   DNS_HEADER            *DnsHeader;
1089
1090   CHAR8                 *QueryName;
1091   DNS_QUERY_SECTION     *QuerySection;
1092
1093   CHAR8                 *AnswerName;
1094   DNS_ANSWER_SECTION    *AnswerSection;
1095   UINT8                 *AnswerData;
1096
1097   NET_MAP_ITEM          *Item;
1098   DNS4_TOKEN_ENTRY      *Dns4TokenEntry;
1099   DNS6_TOKEN_ENTRY      *Dns6TokenEntry;
1100
1101   UINT32                IpCount;
1102   UINT32                AnswerSectionNum;
1103
1104   EFI_IPv4_ADDRESS      *HostAddr4;
1105   EFI_IPv6_ADDRESS      *HostAddr6;
1106
1107   EFI_DNS4_CACHE_ENTRY  *Dns4CacheEntry;
1108   EFI_DNS6_CACHE_ENTRY  *Dns6CacheEntry;
1109
1110   EFI_STATUS            Status;
1111
1112   EFI_TPL               OldTpl;
1113
1114   Item             = NULL;
1115   Dns4TokenEntry   = NULL;
1116   Dns6TokenEntry   = NULL;
1117
1118   IpCount          = 0;
1119   AnswerSectionNum = 0;
1120
1121   HostAddr4        = NULL;
1122   HostAddr6        = NULL;
1123
1124   Dns4CacheEntry   = NULL;
1125   Dns6CacheEntry   = NULL;
1126
1127   *Completed       = TRUE;
1128   Status           = EFI_SUCCESS;
1129
1130   //
1131   // Get header
1132   //
1133   DnsHeader = (DNS_HEADER *) RxString;
1134
1135   DnsHeader->Identification = NTOHS (DnsHeader->Identification);
1136   DnsHeader->Flags.Uint16 = NTOHS (DnsHeader->Flags.Uint16);
1137   DnsHeader->QuestionsNum = NTOHS (DnsHeader->QuestionsNum);
1138   DnsHeader->AnswersNum = NTOHS (DnsHeader->AnswersNum);
1139   DnsHeader->AuthorityNum = NTOHS (DnsHeader->AuthorityNum);
1140   DnsHeader->AditionalNum = NTOHS (DnsHeader->AditionalNum);
1141
1142   //
1143   // Get Query name
1144   //
1145   QueryName = (CHAR8 *) (RxString + sizeof (*DnsHeader));
1146
1147   //
1148   // Get query section
1149   //
1150   QuerySection = (DNS_QUERY_SECTION *) (QueryName + AsciiStrLen (QueryName) + 1);
1151   QuerySection->Type = NTOHS (QuerySection->Type);
1152   QuerySection->Class = NTOHS (QuerySection->Class);
1153
1154   //
1155   // Get Answer name
1156   //
1157   AnswerName = (CHAR8 *) QuerySection + sizeof (*QuerySection);
1158
1159   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1160
1161   //
1162   // Check DnsResponse Validity, if so, also get a valid NET_MAP_ITEM.
1163   //
1164   if (Instance->Service->IpVersion == IP_VERSION_4) {
1165     if (!IsValidDnsResponse (&Instance->Dns4TxTokens, DnsHeader->Identification, QuerySection->Type, &Item)) {
1166       *Completed = FALSE;
1167       Status = EFI_ABORTED;
1168       goto ON_EXIT;
1169     }
1170     ASSERT (Item != NULL);
1171     Dns4TokenEntry = (DNS4_TOKEN_ENTRY *) (Item->Key);
1172   } else {
1173     if (!IsValidDnsResponse (&Instance->Dns6TxTokens, DnsHeader->Identification, QuerySection->Type, &Item)) {
1174       *Completed = FALSE;
1175       Status = EFI_ABORTED;
1176       goto ON_EXIT;
1177     }
1178     ASSERT (Item != NULL);
1179     Dns6TokenEntry = (DNS6_TOKEN_ENTRY *) (Item->Key);
1180   }
1181
1182   //
1183   // Continue Check Some Errors.
1184   //
1185   if (DnsHeader->Flags.Bits.RCode != DNS_FLAGS_RCODE_NO_ERROR || DnsHeader->AnswersNum < 1 || \
1186       DnsHeader->Flags.Bits.QR != DNS_FLAGS_QR_RESPONSE || QuerySection->Class != DNS_CLASS_INET) {
1187       Status = EFI_ABORTED;
1188       goto ON_EXIT;
1189   }
1190
1191   //
1192   // Free the sending packet.
1193   //
1194   if (Item->Value != NULL) {
1195     NetbufFree ((NET_BUF *) (Item->Value));
1196   }
1197
1198   //
1199   // Check the Query type, do some buffer allocations.
1200   //
1201   if (QuerySection->Type == DNS_TYPE_A) {
1202     Dns4TokenEntry->Token->RspData.H2AData = AllocatePool (sizeof (DNS_HOST_TO_ADDR_DATA));
1203     ASSERT (Dns4TokenEntry->Token->RspData.H2AData != NULL);
1204     Dns4TokenEntry->Token->RspData.H2AData->IpList = AllocatePool (DnsHeader->AnswersNum * sizeof (EFI_IPv4_ADDRESS));
1205     ASSERT (Dns4TokenEntry->Token->RspData.H2AData->IpList != NULL);
1206   } else if (QuerySection->Type == DNS_TYPE_AAAA) {
1207     Dns6TokenEntry->Token->RspData.H2AData = AllocatePool (sizeof (DNS6_HOST_TO_ADDR_DATA));
1208     ASSERT (Dns6TokenEntry->Token->RspData.H2AData != NULL);
1209     Dns6TokenEntry->Token->RspData.H2AData->IpList = AllocatePool (DnsHeader->AnswersNum * sizeof (EFI_IPv6_ADDRESS));
1210     ASSERT (Dns6TokenEntry->Token->RspData.H2AData->IpList != NULL);
1211   } else {
1212     Status = EFI_UNSUPPORTED;
1213     goto ON_EXIT;
1214   }
1215
1216   //
1217   // Processing AnswerSection.
1218   //
1219   while (AnswerSectionNum < DnsHeader->AnswersNum) {
1220     //
1221     // Answer name should be PTR.
1222     //
1223     ASSERT ((*(UINT8 *) AnswerName & 0xC0) == 0xC0);
1224
1225     //
1226     // Get Answer section.
1227     //
1228     AnswerSection = (DNS_ANSWER_SECTION *) (AnswerName + sizeof (UINT16));
1229     AnswerSection->Type = NTOHS (AnswerSection->Type);
1230     AnswerSection->Class = NTOHS (AnswerSection->Class);
1231     AnswerSection->Ttl = NTOHL (AnswerSection->Ttl);
1232     AnswerSection->DataLength = NTOHS (AnswerSection->DataLength);
1233
1234     ASSERT (AnswerSection->Class == DNS_CLASS_INET);
1235
1236     if (AnswerSection->Type == QuerySection->Type) {
1237       switch (AnswerSection->Type) {
1238       case DNS_TYPE_A:
1239         //
1240         // This is address entry, get Data.
1241         //
1242         ASSERT (AnswerSection->DataLength == 4);
1243
1244         HostAddr4 = Dns4TokenEntry->Token->RspData.H2AData->IpList;
1245         AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1246         CopyMem (&HostAddr4[IpCount], AnswerData, sizeof (EFI_IPv4_ADDRESS));
1247
1248         //
1249         // Update DNS cache dynamically.
1250         //
1251         if (Dns4CacheEntry != NULL) {
1252           if (Dns4CacheEntry->HostName != NULL) {
1253             FreePool (Dns4CacheEntry->HostName);
1254           }
1255
1256           if (Dns4CacheEntry->IpAddress != NULL) {
1257             FreePool (Dns4CacheEntry->IpAddress);
1258           }
1259
1260           FreePool (Dns4CacheEntry);
1261         }
1262
1263         //
1264         // Allocate new CacheEntry pool.
1265         //
1266         Dns4CacheEntry = AllocateZeroPool (sizeof (EFI_DNS4_CACHE_ENTRY));
1267         ASSERT (Dns4CacheEntry != NULL);
1268         Dns4CacheEntry->HostName = AllocateZeroPool (2 * (StrLen(Dns4TokenEntry->QueryHostName) + 1));
1269         ASSERT (Dns4CacheEntry->HostName != NULL);
1270         CopyMem (Dns4CacheEntry->HostName, Dns4TokenEntry->QueryHostName, 2 * (StrLen(Dns4TokenEntry->QueryHostName) + 1));
1271         Dns4CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv4_ADDRESS));
1272         ASSERT (Dns4CacheEntry->IpAddress != NULL);
1273         CopyMem (Dns4CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv4_ADDRESS));
1274         Dns4CacheEntry->Timeout = AnswerSection->Ttl;
1275
1276         UpdateDns4Cache (&mDriverData->Dns4CacheList, FALSE, TRUE, *Dns4CacheEntry);
1277
1278         IpCount ++;
1279         break;
1280       case DNS_TYPE_AAAA:
1281         //
1282         // This is address entry, get Data.
1283         //
1284         ASSERT (AnswerSection->DataLength == 16);
1285
1286         HostAddr6 = Dns6TokenEntry->Token->RspData.H2AData->IpList;
1287         AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1288         CopyMem (&HostAddr6[IpCount], AnswerData, sizeof (EFI_IPv6_ADDRESS));
1289
1290         //
1291         // Update DNS cache dynamically.
1292         //
1293         if (Dns6CacheEntry != NULL) {
1294           if (Dns6CacheEntry->HostName != NULL) {
1295             FreePool (Dns6CacheEntry->HostName);
1296           }
1297
1298           if (Dns6CacheEntry->IpAddress != NULL) {
1299             FreePool (Dns6CacheEntry->IpAddress);
1300           }
1301
1302           FreePool (Dns6CacheEntry);
1303         }
1304
1305         //
1306         // Allocate new CacheEntry pool.
1307         //
1308         Dns6CacheEntry = AllocateZeroPool (sizeof (EFI_DNS6_CACHE_ENTRY));
1309         ASSERT (Dns6CacheEntry != NULL);
1310         Dns6CacheEntry->HostName = AllocateZeroPool (2 * (StrLen(Dns6TokenEntry->QueryHostName) + 1));
1311         ASSERT (Dns6CacheEntry->HostName != NULL);
1312         CopyMem (Dns6CacheEntry->HostName, Dns6TokenEntry->QueryHostName, 2 * (StrLen(Dns6TokenEntry->QueryHostName) + 1));
1313         Dns6CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv6_ADDRESS));
1314         ASSERT (Dns6CacheEntry->IpAddress != NULL);
1315         CopyMem (Dns6CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv6_ADDRESS));
1316         Dns6CacheEntry->Timeout = AnswerSection->Ttl;
1317
1318         UpdateDns6Cache (&mDriverData->Dns6CacheList, FALSE, TRUE, *Dns6CacheEntry);
1319
1320         IpCount ++;
1321         break;
1322       default:
1323         Status = EFI_UNSUPPORTED;
1324         goto ON_EXIT;
1325       }
1326     }
1327
1328     //
1329     // Find next one
1330     //
1331     AnswerName = (CHAR8 *) AnswerSection + sizeof (*AnswerSection) + AnswerSection->DataLength;
1332     AnswerSectionNum ++;
1333   }
1334
1335   if (QuerySection->Type == DNS_TYPE_A) {
1336     Dns4TokenEntry->Token->RspData.H2AData->IpCount = IpCount;
1337   } else if (QuerySection->Type == DNS_TYPE_AAAA) {
1338     Dns6TokenEntry->Token->RspData.H2AData->IpCount = IpCount;
1339   }
1340
1341   //
1342   // Parsing is complete, SignalEvent here.
1343   //
1344   if (Instance->Service->IpVersion == IP_VERSION_4) {
1345     Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);
1346     Dns4TokenEntry->Token->Status = EFI_SUCCESS;
1347     if (Dns4TokenEntry->Token->Event != NULL) {
1348       gBS->SignalEvent (Dns4TokenEntry->Token->Event);
1349       DispatchDpc ();
1350     }
1351   } else {
1352     Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);
1353     Dns6TokenEntry->Token->Status = EFI_SUCCESS;
1354     if (Dns6TokenEntry->Token->Event != NULL) {
1355       gBS->SignalEvent (Dns6TokenEntry->Token->Event);
1356       DispatchDpc ();
1357     }
1358   }
1359
1360   //
1361   // Free allocated CacheEntry pool.
1362   //
1363   if (Dns4CacheEntry != NULL) {
1364     if (Dns4CacheEntry->HostName != NULL) {
1365       FreePool (Dns4CacheEntry->HostName);
1366     }
1367
1368     if (Dns4CacheEntry->IpAddress != NULL) {
1369       FreePool (Dns4CacheEntry->IpAddress);
1370     }
1371
1372     FreePool (Dns4CacheEntry);
1373   }
1374
1375   if (Dns6CacheEntry != NULL) {
1376     if (Dns6CacheEntry->HostName != NULL) {
1377       FreePool (Dns6CacheEntry->HostName);
1378     }
1379
1380     if (Dns6CacheEntry->IpAddress != NULL) {
1381       FreePool (Dns6CacheEntry->IpAddress);
1382     }
1383
1384     FreePool (Dns6CacheEntry);
1385   }
1386
1387 ON_EXIT:
1388   gBS->RestoreTPL (OldTpl);
1389   return Status;
1390 }
1391
1392 /**
1393   Parse response packet.
1394
1395   @param  Packet                The packets received.
1396   @param  EndPoint              The local/remote UDP access point
1397   @param  IoStatus              The status of the UDP receive
1398   @param  Context               The opaque parameter to the function.
1399
1400 **/
1401 VOID
1402 EFIAPI
1403 DnsOnPacketReceived (
1404   NET_BUF                   *Packet,
1405   UDP_END_POINT             *EndPoint,
1406   EFI_STATUS                IoStatus,
1407   VOID                      *Context
1408   )
1409 {
1410   DNS_INSTANCE              *Instance;
1411
1412   UINT8                     *RcvString;
1413
1414   BOOLEAN                   Completed;
1415
1416   Instance  = (DNS_INSTANCE *) Context;
1417   NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);
1418
1419   RcvString = NULL;
1420   Completed = FALSE;
1421
1422   if (EFI_ERROR (IoStatus)) {
1423     goto ON_EXIT;
1424   }
1425
1426   ASSERT (Packet != NULL);
1427
1428   RcvString = NetbufGetByte (Packet, 0, NULL);
1429
1430   //
1431   // Parse Dns Response
1432   //
1433   ParseDnsResponse (Instance, RcvString, &Completed);
1434
1435   ON_EXIT:
1436
1437     if (Packet != NULL) {
1438       NetbufFree (Packet);
1439     }
1440
1441     if (!Completed) {
1442       UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);
1443     }
1444 }
1445
1446 /**
1447   Release the net buffer when packet is sent.
1448
1449   @param  Packet                The packets received.
1450   @param  EndPoint              The local/remote UDP access point
1451   @param  IoStatus              The status of the UDP receive
1452   @param  Context               The opaque parameter to the function.
1453
1454 **/
1455 VOID
1456 EFIAPI
1457 DnsOnPacketSent (
1458   NET_BUF                   *Packet,
1459   UDP_END_POINT             *EndPoint,
1460   EFI_STATUS                IoStatus,
1461   VOID                      *Context
1462   )
1463 {
1464   DNS_INSTANCE              *Instance;
1465   LIST_ENTRY                *Entry;
1466   NET_MAP_ITEM              *Item;
1467   DNS4_TOKEN_ENTRY          *Dns4TokenEntry;
1468   DNS6_TOKEN_ENTRY          *Dns6TokenEntry;
1469
1470   Dns4TokenEntry = NULL;
1471   Dns6TokenEntry = NULL;
1472
1473   Instance  = (DNS_INSTANCE *) Context;
1474   NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);
1475
1476   if (Instance->Service->IpVersion == IP_VERSION_4) {
1477     NET_LIST_FOR_EACH (Entry, &Instance->Dns4TxTokens.Used) {
1478       Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1479       if (Packet == (NET_BUF *)(Item->Value)) {
1480         Dns4TokenEntry = ((DNS4_TOKEN_ENTRY *)Item->Key);
1481         Dns4TokenEntry->PacketToLive = Dns4TokenEntry->Token->RetryInterval;
1482         break;
1483       }
1484     }
1485   } else {
1486     NET_LIST_FOR_EACH (Entry, &Instance->Dns6TxTokens.Used) {
1487       Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1488       if (Packet == (NET_BUF *)(Item->Value)) {
1489         Dns6TokenEntry = ((DNS6_TOKEN_ENTRY *)Item->Key);
1490         Dns6TokenEntry->PacketToLive = Dns6TokenEntry->Token->RetryInterval;
1491         break;
1492       }
1493     }
1494   }
1495
1496   NetbufFree (Packet);
1497 }
1498
1499 /**
1500   Query request information.
1501
1502   @param  Instance              The DNS instance
1503   @param  Packet                The packet for querying request information.
1504
1505   @retval EFI_SUCCESS           Query request information successfully.
1506   @retval Others                Failed to query request information.
1507
1508 **/
1509 EFI_STATUS
1510 DoDnsQuery (
1511   IN  DNS_INSTANCE              *Instance,
1512   IN  NET_BUF                   *Packet
1513   )
1514 {
1515   EFI_STATUS      Status;
1516
1517   //
1518   // Ready to receive the DNS response.
1519   //
1520   if (Instance->UdpIo->RecvRequest == NULL) {
1521     Status = UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);
1522     if (EFI_ERROR (Status)) {
1523       return Status;
1524     }
1525   }
1526
1527   //
1528   // Transmit the DNS packet.
1529   //
1530   NET_GET_REF (Packet);
1531
1532   Status = UdpIoSendDatagram (Instance->UdpIo, Packet, NULL, NULL, DnsOnPacketSent, Instance);
1533
1534   return Status;
1535 }
1536
1537 /**
1538   Construct the Packet to query Ip.
1539
1540   @param  Instance              The DNS instance
1541   @param  HostName              Queried HostName
1542   @param  Type                  DNS query Type
1543   @param  Packet                The packet for querying Ip
1544
1545   @retval EFI_SUCCESS           The packet is constructed.
1546   @retval Others                Failed to construct the Packet.
1547
1548 **/
1549 EFI_STATUS
1550 ConstructDNSQueryIp (
1551   IN  DNS_INSTANCE              *Instance,
1552   IN  CHAR16                    *HostName,
1553   IN  UINT16                    Type,
1554   OUT NET_BUF                   **Packet
1555   )
1556 {
1557   NET_FRAGMENT        Frag;
1558   DNS_HEADER          *DnsHeader;
1559   CHAR8               *QueryName;
1560   DNS_QUERY_SECTION   *QuerySection;
1561   CHAR8               *Header;
1562   CHAR8               *Tail;
1563   UINTN               Len;
1564   UINTN               Index;
1565
1566
1567   Frag.Bulk = AllocatePool (DNS_DEFAULT_BLKSIZE * sizeof (UINT8));
1568   if (Frag.Bulk == NULL) {
1569     return EFI_OUT_OF_RESOURCES;
1570   }
1571
1572   //
1573   // Fill header
1574   //
1575   DnsHeader = (DNS_HEADER *)Frag.Bulk;
1576   DnsHeader->Identification = (UINT16)AsmReadTsc ();
1577   DnsHeader->Flags.Uint16 = 0x0000;
1578   DnsHeader->Flags.Bits.RD = 1;
1579   DnsHeader->Flags.Bits.OpCode = DNS_FLAGS_OPCODE_STANDARD;
1580   DnsHeader->Flags.Bits.QR = DNS_FLAGS_QR_QUERY;
1581   DnsHeader->QuestionsNum = 1;
1582   DnsHeader->AnswersNum = 0;
1583   DnsHeader->AuthorityNum = 0;
1584   DnsHeader->AditionalNum = 0;
1585
1586   DnsHeader->Identification = HTONS(DnsHeader->Identification);
1587   DnsHeader->Flags.Uint16 = HTONS(DnsHeader->Flags.Uint16);
1588   DnsHeader->QuestionsNum = HTONS(DnsHeader->QuestionsNum);
1589   DnsHeader->AnswersNum = HTONS(DnsHeader->AnswersNum);
1590   DnsHeader->AuthorityNum = HTONS(DnsHeader->AuthorityNum);
1591   DnsHeader->AditionalNum = HTONS(DnsHeader->AditionalNum);
1592
1593   Frag.Len = sizeof (*DnsHeader);
1594
1595   //
1596   // Fill Query name
1597   //
1598   QueryName = (CHAR8 *) (Frag.Bulk + Frag.Len);
1599   Header = QueryName;
1600   Tail = Header + 1;
1601   Len = 0;
1602   for (Index = 0; HostName[Index] != 0; Index++) {
1603     *Tail = (CHAR8) HostName[Index];
1604     if (*Tail == '.') {
1605       *Header = (CHAR8) Len;
1606       Header = Tail;
1607       Tail ++;
1608       Len = 0;
1609     } else {
1610       Tail++;
1611       Len++;
1612     }
1613   }
1614   *Header = (CHAR8) Len;
1615   *Tail = 0;
1616   Frag.Len = (UINT32) (Frag.Len + StrLen (HostName) + 2); /// 1 for header, 1 for tail.
1617
1618   //
1619   // Rest query section
1620   //
1621   QuerySection = (DNS_QUERY_SECTION *) (Frag.Bulk + Frag.Len);
1622   QuerySection->Type = Type;
1623   QuerySection->Class = DNS_CLASS_INET;
1624
1625   QuerySection->Type = HTONS (QuerySection->Type);
1626   QuerySection->Class = HTONS (QuerySection->Class);
1627
1628   Frag.Len += sizeof (*QuerySection);
1629
1630   //
1631   // Wrap the Frag in a net buffer.
1632   //
1633   *Packet = NetbufFromExt (&Frag, 1, 0, 0, DnsDummyExtFree, NULL);
1634   if (*Packet == NULL) {
1635     FreePool (Frag.Bulk);
1636     return EFI_OUT_OF_RESOURCES;
1637   }
1638
1639   //
1640   // Store the UdpIo in ProtoData.
1641   //
1642   *((UINTN *) &((*Packet)->ProtoData[0])) = (UINTN) (Instance->UdpIo);
1643
1644   return EFI_SUCCESS;
1645 }
1646
1647 /**
1648   Retransmit the packet.
1649
1650   @param  Instance              The DNS instance
1651   @param  Packet                Retransmit the packet
1652
1653   @retval EFI_SUCCESS           The packet is retransmitted.
1654   @retval Others                Failed to retransmit.
1655
1656 **/
1657 EFI_STATUS
1658 DnsRetransmit (
1659   IN DNS_INSTANCE        *Instance,
1660   IN NET_BUF             *Packet
1661   )
1662 {
1663   EFI_STATUS      Status;
1664
1665   UINT8           *Buffer;
1666
1667   ASSERT (Packet != NULL);
1668
1669   //
1670   // Set the requests to the listening port, other packets to the connected port
1671   //
1672   Buffer = NetbufGetByte (Packet, 0, NULL);
1673   ASSERT (Buffer != NULL);
1674
1675   NET_GET_REF (Packet);
1676
1677   Status = UdpIoSendDatagram (
1678              Instance->UdpIo,
1679              Packet,
1680              NULL,
1681              NULL,
1682              DnsOnPacketSent,
1683              Instance
1684              );
1685
1686   if (EFI_ERROR (Status)) {
1687     NET_PUT_REF (Packet);
1688   }
1689
1690   return Status;
1691 }
1692
1693 /**
1694   The timer ticking function for the DNS services.
1695
1696   @param  Event                 The ticking event
1697   @param  Context               The DNS service instance
1698
1699 **/
1700 VOID
1701 EFIAPI
1702 DnsOnTimerRetransmit (
1703   IN EFI_EVENT              Event,
1704   IN VOID                   *Context
1705   )
1706 {
1707   DNS_SERVICE                *Service;
1708
1709   LIST_ENTRY                 *Entry;
1710   LIST_ENTRY                 *Next;
1711
1712   DNS_INSTANCE               *Instance;
1713   LIST_ENTRY                 *EntryNetMap;
1714   NET_MAP_ITEM               *ItemNetMap;
1715   DNS4_TOKEN_ENTRY           *Dns4TokenEntry;
1716   DNS6_TOKEN_ENTRY           *Dns6TokenEntry;
1717
1718   Dns4TokenEntry = NULL;
1719   Dns6TokenEntry = NULL;
1720
1721   Service = (DNS_SERVICE *) Context;
1722
1723
1724   if (Service->IpVersion == IP_VERSION_4) {
1725     //
1726     // Iterate through all the children of the DNS service instance. Time
1727     // out the packet. If maximum retries reached, clean the Token up.
1728     //
1729     NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns4ChildrenList) {
1730       Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);
1731
1732       EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;
1733       while (EntryNetMap != &Instance->Dns4TxTokens.Used) {
1734         ItemNetMap = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);
1735         Dns4TokenEntry = (DNS4_TOKEN_ENTRY *)(ItemNetMap->Key);
1736         if (Dns4TokenEntry->PacketToLive == 0 || (--Dns4TokenEntry->PacketToLive > 0)) {
1737           EntryNetMap = EntryNetMap->ForwardLink;
1738           continue;
1739         }
1740
1741         //
1742         // Retransmit the packet if haven't reach the maxmium retry count,
1743         // otherwise exit the transfer.
1744         //
1745         if (++Dns4TokenEntry->Token->RetryCount < Instance->MaxRetry) {
1746           DnsRetransmit (Instance, (NET_BUF *)ItemNetMap->Value);
1747           EntryNetMap = EntryNetMap->ForwardLink;
1748         } else {
1749           //
1750           // Maximum retries reached, clean the Token up.
1751           //
1752           Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);
1753           Dns4TokenEntry->Token->Status = EFI_TIMEOUT;
1754           gBS->SignalEvent (Dns4TokenEntry->Token->Event);
1755           DispatchDpc ();
1756
1757           //
1758           // Free the sending packet.
1759           //
1760           if (ItemNetMap->Value != NULL) {
1761             NetbufFree ((NET_BUF *)(ItemNetMap->Value));
1762           }
1763
1764           EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;
1765         }
1766       }
1767     }
1768   }else {
1769     //
1770     // Iterate through all the children of the DNS service instance. Time
1771     // out the packet. If maximum retries reached, clean the Token up.
1772     //
1773     NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns6ChildrenList) {
1774       Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);
1775
1776       EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;
1777       while (EntryNetMap != &Instance->Dns6TxTokens.Used) {
1778         ItemNetMap = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);
1779         Dns6TokenEntry = (DNS6_TOKEN_ENTRY *) (ItemNetMap->Key);
1780         if (Dns6TokenEntry->PacketToLive == 0 || (--Dns6TokenEntry->PacketToLive > 0)) {
1781           EntryNetMap = EntryNetMap->ForwardLink;
1782           continue;
1783         }
1784
1785         //
1786         // Retransmit the packet if haven't reach the maxmium retry count,
1787         // otherwise exit the transfer.
1788         //
1789         if (++Dns6TokenEntry->Token->RetryCount < Instance->MaxRetry) {
1790           DnsRetransmit (Instance, (NET_BUF *) ItemNetMap->Value);
1791           EntryNetMap = EntryNetMap->ForwardLink;
1792         } else {
1793           //
1794           // Maximum retries reached, clean the Token up.
1795           //
1796           Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);
1797           Dns6TokenEntry->Token->Status = EFI_TIMEOUT;
1798           gBS->SignalEvent (Dns6TokenEntry->Token->Event);
1799           DispatchDpc ();
1800
1801           //
1802           // Free the sending packet.
1803           //
1804           if (ItemNetMap->Value != NULL) {
1805             NetbufFree ((NET_BUF *) (ItemNetMap->Value));
1806           }
1807
1808           EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;
1809         }
1810       }
1811     }
1812   }
1813 }
1814
1815 /**
1816   The timer ticking function for the DNS driver.
1817
1818   @param  Event                 The ticking event
1819   @param  Context               NULL
1820
1821 **/
1822 VOID
1823 EFIAPI
1824 DnsOnTimerUpdate (
1825   IN EFI_EVENT              Event,
1826   IN VOID                   *Context
1827   )
1828 {
1829   LIST_ENTRY                 *Entry;
1830   LIST_ENTRY                 *Next;
1831   DNS4_CACHE                 *Item4;
1832   DNS6_CACHE                 *Item6;
1833
1834   Item4 = NULL;
1835   Item6 = NULL;
1836
1837   //
1838   // Iterate through all the DNS4 cache list.
1839   //
1840   NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns4CacheList) {
1841     Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
1842     Item4->DnsCache.Timeout--;
1843   }
1844
1845   Entry = mDriverData->Dns4CacheList.ForwardLink;
1846   while (Entry != &mDriverData->Dns4CacheList) {
1847     Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
1848     if (Item4->DnsCache.Timeout<=0) {
1849       RemoveEntryList (&Item4->AllCacheLink);
1850       Entry = mDriverData->Dns4CacheList.ForwardLink;
1851     } else {
1852       Entry = Entry->ForwardLink;
1853     }
1854   }
1855
1856   //
1857   // Iterate through all the DNS6 cache list.
1858   //
1859   NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns6CacheList) {
1860     Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
1861     Item6->DnsCache.Timeout--;
1862   }
1863
1864   Entry = mDriverData->Dns6CacheList.ForwardLink;
1865   while (Entry != &mDriverData->Dns6CacheList) {
1866     Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
1867     if (Item6->DnsCache.Timeout<=0) {
1868       RemoveEntryList (&Item6->AllCacheLink);
1869       Entry = mDriverData->Dns6CacheList.ForwardLink;
1870     } else {
1871       Entry = Entry->ForwardLink;
1872     }
1873   }
1874 }
1875