NetworkPkg/UefiPxeBcDxe/PxeBcDriver.c

   1 /** @file
   2   Driver Binding functions implementationfor for UefiPxeBc Driver.
   3
   4   (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php.
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "PxeBcImpl.h"
  18
  19
  20 EFI_DRIVER_BINDING_PROTOCOL gPxeBcIp4DriverBinding = {
  21   PxeBcIp4DriverBindingSupported,
  22   PxeBcIp4DriverBindingStart,
  23   PxeBcIp4DriverBindingStop,
  24   0xa,
  25   NULL,
  26   NULL
  27 };
  28
  29 EFI_DRIVER_BINDING_PROTOCOL gPxeBcIp6DriverBinding = {
  30   PxeBcIp6DriverBindingSupported,
  31   PxeBcIp6DriverBindingStart,
  32   PxeBcIp6DriverBindingStop,
  33   0xa,
  34   NULL,
  35   NULL
  36 };
  37
  38 /**
  39   Get the Nic handle using any child handle in the IPv4 stack.
  40
  41   @param[in]  ControllerHandle    Pointer to child handle over IPv4.
  42
  43   @return NicHandle               The pointer to the Nic handle.
  44
  45 **/
  46 EFI_HANDLE
  47 PxeBcGetNicByIp4Children (
  48   IN EFI_HANDLE                 ControllerHandle
  49   )
  50 {
  51   EFI_HANDLE                    NicHandle;
  52
  53   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
  54   if (NicHandle == NULL) {
  55     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
  56     if (NicHandle == NULL) {
  57       NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp4ProtocolGuid);
  58       if (NicHandle == NULL) {
  59         NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp4ProtocolGuid);
  60         if (NicHandle == NULL) {
  61           NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiMtftp4ProtocolGuid);
  62           if (NicHandle == NULL) {
  63             return NULL;
  64           }
  65         }
  66       }
  67     }
  68   }
  69
  70   return NicHandle;
  71 }
  72
  73
  74 /**
  75   Get the Nic handle using any child handle in the IPv6 stack.
  76
  77   @param[in]  ControllerHandle    Pointer to child handle over IPv6.
  78
  79   @return NicHandle               The pointer to the Nic handle.
  80
  81 **/
  82 EFI_HANDLE
  83 PxeBcGetNicByIp6Children (
  84   IN EFI_HANDLE                  ControllerHandle
  85   )
  86 {
  87   EFI_HANDLE                     NicHandle;
  88
  89   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp6ProtocolGuid);
  90   if (NicHandle == NULL) {
  91     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp6ProtocolGuid);
  92     if (NicHandle == NULL) {
  93       NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp6ProtocolGuid);
  94       if (NicHandle == NULL) {
  95         NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiMtftp6ProtocolGuid);
  96         if (NicHandle == NULL) {
  97           return NULL;
  98         }
  99       }
 100     }
 101   }
 102
 103   return NicHandle;
 104 }
 105
 106
 107 /**
 108   Destroy the opened instances based on IPv4.
 109
 110   @param[in]  This              Pointer to the EFI_DRIVER_BINDING_PROTOCOL.
 111   @param[in]  Private           Pointer to PXEBC_PRIVATE_DATA.
 112
 113 **/
 114 VOID
 115 PxeBcDestroyIp4Children (
 116   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 117   IN PXEBC_PRIVATE_DATA           *Private
 118   )
 119 {
 120   ASSERT(Private != NULL);
 121
 122   if (Private->ArpChild != NULL) {
 123     //
 124     // Close Arp for PxeBc->Arp and destroy the instance.
 125     //
 126     gBS->CloseProtocol (
 127            Private->ArpChild,
 128            &gEfiArpProtocolGuid,
 129            This->DriverBindingHandle,
 130            Private->Controller
 131            );
 132
 133     NetLibDestroyServiceChild (
 134       Private->Controller,
 135       This->DriverBindingHandle,
 136       &gEfiArpServiceBindingProtocolGuid,
 137       Private->ArpChild
 138       );
 139   }
 140
 141   if (Private->Ip4Child != NULL) {
 142     //
 143     // Close Ip4 for background ICMP error message and destroy the instance.
 144     //
 145     gBS->CloseProtocol (
 146            Private->Ip4Child,
 147            &gEfiIp4ProtocolGuid,
 148            This->DriverBindingHandle,
 149            Private->Controller
 150            );
 151
 152     NetLibDestroyServiceChild (
 153       Private->Controller,
 154       This->DriverBindingHandle,
 155       &gEfiIp4ServiceBindingProtocolGuid,
 156       Private->Ip4Child
 157       );
 158   }
 159
 160   if (Private->Udp4WriteChild != NULL) {
 161     //
 162     // Close Udp4 for PxeBc->UdpWrite and destroy the instance.
 163     //
 164     gBS->CloseProtocol (
 165            Private->Udp4WriteChild,
 166            &gEfiUdp4ProtocolGuid,
 167            This->DriverBindingHandle,
 168            Private->Controller
 169            );
 170
 171     NetLibDestroyServiceChild (
 172       Private->Controller,
 173       This->DriverBindingHandle,
 174       &gEfiUdp4ServiceBindingProtocolGuid,
 175       Private->Udp4WriteChild
 176       );
 177   }
 178
 179   if (Private->Udp4ReadChild != NULL) {
 180     //
 181     // Close Udp4 for PxeBc->UdpRead and destroy the instance.
 182     //
 183     gBS->CloseProtocol (
 184           Private->Udp4ReadChild,
 185           &gEfiUdp4ProtocolGuid,
 186           This->DriverBindingHandle,
 187           Private->Controller
 188           );
 189
 190     NetLibDestroyServiceChild (
 191       Private->Controller,
 192       This->DriverBindingHandle,
 193       &gEfiUdp4ServiceBindingProtocolGuid,
 194       Private->Udp4ReadChild
 195       );
 196   }
 197
 198   if (Private->Mtftp4Child != NULL) {
 199     //
 200     // Close Mtftp4 for PxeBc->Mtftp4 and destroy the instance.
 201     //
 202     gBS->CloseProtocol (
 203           Private->Mtftp4Child,
 204           &gEfiMtftp4ProtocolGuid,
 205           This->DriverBindingHandle,
 206           Private->Controller
 207           );
 208
 209     NetLibDestroyServiceChild (
 210       Private->Controller,
 211       This->DriverBindingHandle,
 212       &gEfiMtftp4ServiceBindingProtocolGuid,
 213       Private->Mtftp4Child
 214       );
 215   }
 216
 217   if (Private->Dhcp4Child != NULL) {
 218     //
 219     // Close Dhcp4 for PxeBc->Dhcp4 and destroy the instance.
 220     //
 221     gBS->CloseProtocol (
 222           Private->Dhcp4Child,
 223           &gEfiDhcp4ProtocolGuid,
 224           This->DriverBindingHandle,
 225           Private->Controller
 226           );
 227
 228     NetLibDestroyServiceChild (
 229       Private->Controller,
 230       This->DriverBindingHandle,
 231       &gEfiDhcp4ServiceBindingProtocolGuid,
 232       Private->Dhcp4Child
 233       );
 234   }
 235
 236   if (Private->Ip4Nic != NULL) {
 237     //
 238     // Close PxeBcPrivate from the parent Nic handle and destroy the virtual handle.
 239     //
 240     gBS->CloseProtocol (
 241            Private->Controller,
 242            &gEfiCallerIdGuid,
 243            This->DriverBindingHandle,
 244            Private->Ip4Nic->Controller
 245            );
 246
 247     gBS->UninstallMultipleProtocolInterfaces (
 248            Private->Ip4Nic->Controller,
 249            &gEfiDevicePathProtocolGuid,
 250            Private->Ip4Nic->DevicePath,
 251            &gEfiLoadFileProtocolGuid,
 252            &Private->Ip4Nic->LoadFile,
 253            &gEfiPxeBaseCodeProtocolGuid,
 254            &Private->PxeBc,
 255            NULL
 256            );
 257
 258     if (Private->Snp != NULL) {
 259       //
 260       // Close SNP from the child virtual handle
 261       //
 262       gBS->CloseProtocol (
 263              Private->Ip4Nic->Controller,
 264              &gEfiSimpleNetworkProtocolGuid,
 265              This->DriverBindingHandle,
 266              Private->Ip4Nic->Controller
 267              );
 268
 269       gBS->UninstallProtocolInterface (
 270              Private->Ip4Nic->Controller,
 271              &gEfiSimpleNetworkProtocolGuid,
 272              Private->Snp
 273              );
 274     }
 275     FreePool (Private->Ip4Nic);
 276   }
 277
 278   Private->ArpChild         = NULL;
 279   Private->Ip4Child         = NULL;
 280   Private->Udp4WriteChild   = NULL;
 281   Private->Udp4ReadChild    = NULL;
 282   Private->Mtftp4Child      = NULL;
 283   Private->Dhcp4Child       = NULL;
 284   Private->Ip4Nic           = NULL;
 285 }
 286
 287
 288 /**
 289   Destroy the opened instances based on IPv6.
 290
 291   @param[in]  This              Pointer to the EFI_DRIVER_BINDING_PROTOCOL.
 292   @param[in]  Private           Pointer to PXEBC_PRIVATE_DATA.
 293
 294 **/
 295 VOID
 296 PxeBcDestroyIp6Children (
 297   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 298   IN PXEBC_PRIVATE_DATA           *Private
 299   )
 300 {
 301   ASSERT(Private != NULL);
 302
 303   if (Private->Ip6Child != NULL) {
 304     //
 305     // Close Ip6 for Ip6->Ip6Config and destroy the instance.
 306     //
 307     gBS->CloseProtocol (
 308           Private->Ip6Child,
 309           &gEfiIp6ProtocolGuid,
 310           This->DriverBindingHandle,
 311           Private->Controller
 312           );
 313
 314     NetLibDestroyServiceChild (
 315       Private->Controller,
 316       This->DriverBindingHandle,
 317       &gEfiIp6ServiceBindingProtocolGuid,
 318       Private->Ip6Child
 319       );
 320   }
 321
 322   if (Private->Udp6WriteChild != NULL) {
 323     //
 324     // Close Udp6 for PxeBc->UdpWrite and destroy the instance.
 325     //
 326     gBS->CloseProtocol (
 327            Private->Udp6WriteChild,
 328            &gEfiUdp6ProtocolGuid,
 329            This->DriverBindingHandle,
 330            Private->Controller
 331            );
 332     NetLibDestroyServiceChild (
 333       Private->Controller,
 334       This->DriverBindingHandle,
 335       &gEfiUdp6ServiceBindingProtocolGuid,
 336       Private->Udp6WriteChild
 337       );
 338   }
 339
 340   if (Private->Udp6ReadChild != NULL) {
 341     //
 342     // Close Udp6 for PxeBc->UdpRead and destroy the instance.
 343     //
 344     gBS->CloseProtocol (
 345           Private->Udp6ReadChild,
 346           &gEfiUdp6ProtocolGuid,
 347           This->DriverBindingHandle,
 348           Private->Controller
 349           );
 350     NetLibDestroyServiceChild (
 351       Private->Controller,
 352       This->DriverBindingHandle,
 353       &gEfiUdp6ServiceBindingProtocolGuid,
 354       Private->Udp6ReadChild
 355       );
 356   }
 357
 358   if (Private->Mtftp6Child != NULL) {
 359     //
 360     // Close Mtftp6 for PxeBc->Mtftp and destroy the instance.
 361     //
 362     gBS->CloseProtocol (
 363           Private->Mtftp6Child,
 364           &gEfiMtftp6ProtocolGuid,
 365           This->DriverBindingHandle,
 366           Private->Controller
 367           );
 368
 369     NetLibDestroyServiceChild (
 370       Private->Controller,
 371       This->DriverBindingHandle,
 372       &gEfiMtftp6ServiceBindingProtocolGuid,
 373       Private->Mtftp6Child
 374       );
 375   }
 376
 377   if (Private->Dhcp6Child != NULL) {
 378     //
 379     // Close Dhcp6 for PxeBc->Dhcp and destroy the instance.
 380     //
 381     gBS->CloseProtocol (
 382           Private->Dhcp6Child,
 383           &gEfiDhcp6ProtocolGuid,
 384           This->DriverBindingHandle,
 385           Private->Controller
 386           );
 387
 388     NetLibDestroyServiceChild (
 389       Private->Controller,
 390       This->DriverBindingHandle,
 391       &gEfiDhcp6ServiceBindingProtocolGuid,
 392       Private->Dhcp6Child
 393       );
 394   }
 395
 396   if (Private->Ip6Nic != NULL) {
 397     //
 398     // Close PxeBcPrivate from the parent Nic handle and destroy the virtual handle.
 399     //
 400     gBS->CloseProtocol (
 401            Private->Controller,
 402            &gEfiCallerIdGuid,
 403            This->DriverBindingHandle,
 404            Private->Ip6Nic->Controller
 405            );
 406
 407     gBS->UninstallMultipleProtocolInterfaces (
 408            Private->Ip6Nic->Controller,
 409            &gEfiDevicePathProtocolGuid,
 410            Private->Ip6Nic->DevicePath,
 411            &gEfiLoadFileProtocolGuid,
 412            &Private->Ip6Nic->LoadFile,
 413            &gEfiPxeBaseCodeProtocolGuid,
 414            &Private->PxeBc,
 415            NULL
 416            );
 417     if (Private->Snp != NULL) {
 418       //
 419       // Close SNP from the child virtual handle
 420       //
 421       gBS->CloseProtocol (
 422              Private->Ip6Nic->Controller,
 423              &gEfiSimpleNetworkProtocolGuid,
 424              This->DriverBindingHandle,
 425              Private->Ip6Nic->Controller
 426              );
 427       gBS->UninstallProtocolInterface (
 428              Private->Ip6Nic->Controller,
 429              &gEfiSimpleNetworkProtocolGuid,
 430              Private->Snp
 431              );
 432     }
 433     FreePool (Private->Ip6Nic);
 434   }
 435
 436   Private->Ip6Child           = NULL;
 437   Private->Udp6WriteChild     = NULL;
 438   Private->Udp6ReadChild      = NULL;
 439   Private->Mtftp6Child        = NULL;
 440   Private->Dhcp6Child         = NULL;
 441   Private->Ip6Nic             = NULL;
 442   Private->Mode.Ipv6Available = FALSE;
 443 }
 444
 445 /**
 446   Check whether UNDI protocol supports IPv6.
 447
 448   @param[in]   ControllerHandle  Controller handle.
 449   @param[in]   Private           Pointer to PXEBC_PRIVATE_DATA.
 450   @param[out]  Ipv6Support       TRUE if UNDI supports IPv6.
 451
 452   @retval EFI_SUCCESS            Get the result whether UNDI supports IPv6 by NII or AIP protocol successfully.
 453   @retval EFI_NOT_FOUND          Don't know whether UNDI supports IPv6 since NII or AIP is not available.
 454
 455 **/
 456 EFI_STATUS
 457 PxeBcCheckIpv6Support (
 458   IN  EFI_HANDLE                   ControllerHandle,
 459   IN  PXEBC_PRIVATE_DATA           *Private,
 460   OUT BOOLEAN                      *Ipv6Support
 461   )
 462 {
 463   EFI_HANDLE                       Handle;
 464   EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
 465   EFI_STATUS                       Status;
 466   EFI_GUID                         *InfoTypesBuffer;
 467   UINTN                            InfoTypeBufferCount;
 468   UINTN                            TypeIndex;
 469   BOOLEAN                          Supported;
 470   VOID                             *InfoBlock;
 471   UINTN                            InfoBlockSize;
 472
 473   ASSERT (Private != NULL && Ipv6Support != NULL);
 474
 475   //
 476   // Check whether the UNDI supports IPv6 by NII protocol.
 477   //
 478   if (Private->Nii != NULL) {
 479     *Ipv6Support = Private->Nii->Ipv6Supported;
 480     return EFI_SUCCESS;
 481   }
 482
 483   //
 484   // Check whether the UNDI supports IPv6 by AIP protocol.
 485   //
 486
 487   //
 488   // Get the NIC handle by SNP protocol.
 489   //
 490   Handle = NetLibGetSnpHandle (ControllerHandle, NULL);
 491   if (Handle == NULL) {
 492     return EFI_NOT_FOUND;
 493   }
 494
 495   Aip    = NULL;
 496   Status = gBS->HandleProtocol (
 497                   Handle,
 498                   &gEfiAdapterInformationProtocolGuid,
 499                   (VOID *) &Aip
 500                   );
 501   if (EFI_ERROR (Status) || Aip == NULL) {
 502     return EFI_NOT_FOUND;
 503   }
 504
 505   InfoTypesBuffer     = NULL;
 506   InfoTypeBufferCount = 0;
 507   Status = Aip->GetSupportedTypes (Aip, &InfoTypesBuffer, &InfoTypeBufferCount);
 508   if (EFI_ERROR (Status) || InfoTypesBuffer == NULL) {
 509     FreePool (InfoTypesBuffer);
 510     return EFI_NOT_FOUND;
 511   }
 512
 513   Supported = FALSE;
 514   for (TypeIndex = 0; TypeIndex < InfoTypeBufferCount; TypeIndex++) {
 515     if (CompareGuid (&InfoTypesBuffer[TypeIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {
 516       Supported = TRUE;
 517       break;
 518     }
 519   }
 520
 521   FreePool (InfoTypesBuffer);
 522   if (!Supported) {
 523     return EFI_NOT_FOUND;
 524   }
 525
 526   //
 527   // We now have adapter information block.
 528   //
 529   InfoBlock     = NULL;
 530   InfoBlockSize = 0;
 531   Status = Aip->GetInformation (Aip, &gEfiAdapterInfoUndiIpv6SupportGuid, &InfoBlock, &InfoBlockSize);
 532   if (EFI_ERROR (Status) || InfoBlock == NULL) {
 533     FreePool (InfoBlock);
 534     return EFI_NOT_FOUND;
 535   }
 536
 537   *Ipv6Support = ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *) InfoBlock)->Ipv6Support;
 538   FreePool (InfoBlock);
 539   return EFI_SUCCESS;
 540
 541 }
 542
 543 /**
 544   Create the opened instances based on IPv4.
 545
 546   @param[in]  This              Pointer to EFI_DRIVER_BINDING_PROTOCOL.
 547   @param[in]  ControllerHandle  Handle of the child to destroy.
 548   @param[in]  Private Handle    Pointer to PXEBC_PRIVATE_DATA.
 549
 550   @retval EFI_SUCCESS           The instances based on IPv4 were all created successfully.
 551   @retval Others                An unexpected error occurred.
 552
 553 **/
 554 EFI_STATUS
 555 PxeBcCreateIp4Children (
 556   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 557   IN EFI_HANDLE                   ControllerHandle,
 558   IN PXEBC_PRIVATE_DATA           *Private
 559   )
 560 {
 561   EFI_STATUS                      Status;
 562   IPv4_DEVICE_PATH                Ip4Node;
 563   EFI_PXE_BASE_CODE_MODE          *Mode;
 564   EFI_UDP4_CONFIG_DATA            *Udp4CfgData;
 565   EFI_IP4_CONFIG_DATA             *Ip4CfgData;
 566   EFI_IP4_MODE_DATA               Ip4ModeData;
 567   PXEBC_PRIVATE_PROTOCOL          *Id;
 568   EFI_SIMPLE_NETWORK_PROTOCOL     *Snp;
 569
 570   if (Private->Ip4Nic != NULL) {
 571     //
 572     // Already created before.
 573     //
 574     return EFI_SUCCESS;
 575   }
 576
 577   //
 578   // Create Dhcp4 child and open Dhcp4 protocol for PxeBc->Dhcp.
 579   //
 580   Status = NetLibCreateServiceChild (
 581              ControllerHandle,
 582              This->DriverBindingHandle,
 583              &gEfiDhcp4ServiceBindingProtocolGuid,
 584              &Private->Dhcp4Child
 585              );
 586   if (EFI_ERROR (Status)) {
 587     goto ON_ERROR;
 588   }
 589
 590   Status = gBS->OpenProtocol (
 591                   Private->Dhcp4Child,
 592                   &gEfiDhcp4ProtocolGuid,
 593                   (VOID **) &Private->Dhcp4,
 594                   This->DriverBindingHandle,
 595                   ControllerHandle,
 596                   EFI_OPEN_PROTOCOL_BY_DRIVER
 597                   );
 598   if (EFI_ERROR (Status)) {
 599     goto ON_ERROR;
 600   }
 601
 602   //
 603   // Create Mtftp4 child and open Mtftp4 protocol for PxeBc->Mtftp.
 604   //
 605   Status = NetLibCreateServiceChild (
 606              ControllerHandle,
 607              This->DriverBindingHandle,
 608              &gEfiMtftp4ServiceBindingProtocolGuid,
 609              &Private->Mtftp4Child
 610              );
 611   if (EFI_ERROR (Status)) {
 612     goto ON_ERROR;
 613   }
 614
 615   Status = gBS->OpenProtocol (
 616                   Private->Mtftp4Child,
 617                   &gEfiMtftp4ProtocolGuid,
 618                   (VOID **) &Private->Mtftp4,
 619                   This->DriverBindingHandle,
 620                   ControllerHandle,
 621                   EFI_OPEN_PROTOCOL_BY_DRIVER
 622                   );
 623   if (EFI_ERROR (Status)) {
 624     goto ON_ERROR;
 625   }
 626
 627   //
 628   // Create Udp4 child and open Udp4 protocol for PxeBc->UdpRead.
 629   //
 630   Status = NetLibCreateServiceChild (
 631              ControllerHandle,
 632              This->DriverBindingHandle,
 633              &gEfiUdp4ServiceBindingProtocolGuid,
 634              &Private->Udp4ReadChild
 635              );
 636   if (EFI_ERROR (Status)) {
 637     goto ON_ERROR;
 638   }
 639
 640   Status = gBS->OpenProtocol (
 641                   Private->Udp4ReadChild,
 642                   &gEfiUdp4ProtocolGuid,
 643                   (VOID **) &Private->Udp4Read,
 644                   This->DriverBindingHandle,
 645                   ControllerHandle,
 646                   EFI_OPEN_PROTOCOL_BY_DRIVER
 647                   );
 648   if (EFI_ERROR (Status)) {
 649     goto ON_ERROR;
 650   }
 651
 652   //
 653   // Create Udp4 child and open Udp4 protocol for PxeBc->UdpWrite.
 654   //
 655   Status = NetLibCreateServiceChild (
 656              ControllerHandle,
 657              This->DriverBindingHandle,
 658              &gEfiUdp4ServiceBindingProtocolGuid,
 659              &Private->Udp4WriteChild
 660              );
 661   if (EFI_ERROR (Status)) {
 662     goto ON_ERROR;
 663   }
 664
 665   Status = gBS->OpenProtocol (
 666                   Private->Udp4WriteChild,
 667                   &gEfiUdp4ProtocolGuid,
 668                   (VOID **) &Private->Udp4Write,
 669                   This->DriverBindingHandle,
 670                   ControllerHandle,
 671                   EFI_OPEN_PROTOCOL_BY_DRIVER
 672                   );
 673   if (EFI_ERROR (Status)) {
 674     goto ON_ERROR;
 675   }
 676
 677   //
 678   // Create Arp child and open Arp protocol for PxeBc->Arp.
 679   //
 680   Status = NetLibCreateServiceChild (
 681              ControllerHandle,
 682              This->DriverBindingHandle,
 683              &gEfiArpServiceBindingProtocolGuid,
 684              &Private->ArpChild
 685              );
 686   if (EFI_ERROR (Status)) {
 687     goto ON_ERROR;
 688   }
 689
 690   Status = gBS->OpenProtocol (
 691                   Private->ArpChild,
 692                   &gEfiArpProtocolGuid,
 693                   (VOID **) &Private->Arp,
 694                   This->DriverBindingHandle,
 695                   ControllerHandle,
 696                   EFI_OPEN_PROTOCOL_BY_DRIVER
 697                   );
 698   if (EFI_ERROR (Status)) {
 699     goto ON_ERROR;
 700   }
 701
 702   //
 703   // Create Ip4 child and open Ip4 protocol for background ICMP packets.
 704   //
 705   Status = NetLibCreateServiceChild (
 706              ControllerHandle,
 707              This->DriverBindingHandle,
 708              &gEfiIp4ServiceBindingProtocolGuid,
 709              &Private->Ip4Child
 710              );
 711   if (EFI_ERROR (Status)) {
 712     goto ON_ERROR;
 713   }
 714
 715   Status = gBS->OpenProtocol (
 716                   Private->Ip4Child,
 717                   &gEfiIp4ProtocolGuid,
 718                   (VOID **) &Private->Ip4,
 719                   This->DriverBindingHandle,
 720                   ControllerHandle,
 721                   EFI_OPEN_PROTOCOL_BY_DRIVER
 722                   );
 723   if (EFI_ERROR (Status)) {
 724     goto ON_ERROR;
 725   }
 726
 727   //
 728   // Get max packet size from Ip4 to calculate block size for Tftp later.
 729   //
 730   Status = Private->Ip4->GetModeData (Private->Ip4, &Ip4ModeData, NULL, NULL);
 731   if (EFI_ERROR (Status)) {
 732     goto ON_ERROR;
 733   }
 734
 735   Private->Ip4MaxPacketSize = Ip4ModeData.MaxPacketSize;
 736
 737   Private->Ip4Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC));
 738   if (Private->Ip4Nic == NULL) {
 739     return EFI_OUT_OF_RESOURCES;
 740   }
 741
 742   Private->Ip4Nic->Private   = Private;
 743   Private->Ip4Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE;
 744
 745    //
 746   // Locate Ip4->Ip4Config2 and store it for set IPv4 Policy.
 747   //
 748   Status = gBS->HandleProtocol (
 749                   ControllerHandle,
 750                   &gEfiIp4Config2ProtocolGuid,
 751                   (VOID **) &Private->Ip4Config2
 752                   );
 753   if (EFI_ERROR (Status)) {
 754     goto ON_ERROR;
 755   }
 756
 757   //
 758   // Create a device path node for Ipv4 virtual nic, and append it.
 759   //
 760   ZeroMem (&Ip4Node, sizeof (IPv4_DEVICE_PATH));
 761   Ip4Node.Header.Type     = MESSAGING_DEVICE_PATH;
 762   Ip4Node.Header.SubType  = MSG_IPv4_DP;
 763   Ip4Node.StaticIpAddress = FALSE;
 764
 765   SetDevicePathNodeLength (&Ip4Node.Header, sizeof (Ip4Node));
 766
 767   Private->Ip4Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip4Node.Header);
 768
 769   if (Private->Ip4Nic->DevicePath == NULL) {
 770     Status = EFI_OUT_OF_RESOURCES;
 771     goto ON_ERROR;
 772   }
 773
 774   CopyMem (
 775     &Private->Ip4Nic->LoadFile,
 776     &gLoadFileProtocolTemplate,
 777     sizeof (EFI_LOAD_FILE_PROTOCOL)
 778     );
 779
 780   //
 781   // Create a new handle for IPv4 virtual nic,
 782   // and install PxeBaseCode, LoadFile and DevicePath protocols.
 783   //
 784   Status = gBS->InstallMultipleProtocolInterfaces (
 785                   &Private->Ip4Nic->Controller,
 786                   &gEfiDevicePathProtocolGuid,
 787                   Private->Ip4Nic->DevicePath,
 788                   &gEfiLoadFileProtocolGuid,
 789                   &Private->Ip4Nic->LoadFile,
 790                   &gEfiPxeBaseCodeProtocolGuid,
 791                   &Private->PxeBc,
 792                   NULL
 793                   );
 794   if (EFI_ERROR (Status)) {
 795     goto ON_ERROR;
 796   }
 797
 798   if (Private->Snp != NULL) {
 799     //
 800     // Install SNP protocol on purpose is for some OS loader backward
 801     // compatibility consideration.
 802     //
 803     Status = gBS->InstallProtocolInterface (
 804                     &Private->Ip4Nic->Controller,
 805                     &gEfiSimpleNetworkProtocolGuid,
 806                     EFI_NATIVE_INTERFACE,
 807                     Private->Snp
 808                     );
 809     if (EFI_ERROR (Status)) {
 810       goto ON_ERROR;
 811     }
 812
 813     //
 814     // Open SNP on the child handle BY_DRIVER. It will prevent any additionally
 815     // layering to perform the experiment.
 816     //
 817     Status = gBS->OpenProtocol (
 818                     Private->Ip4Nic->Controller,
 819                     &gEfiSimpleNetworkProtocolGuid,
 820                     (VOID **) &Snp,
 821                     This->DriverBindingHandle,
 822                     Private->Ip4Nic->Controller,
 823                     EFI_OPEN_PROTOCOL_BY_DRIVER
 824                     );
 825     if (EFI_ERROR (Status)) {
 826       goto ON_ERROR;
 827     }
 828   }
 829
 830   //
 831   // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between
 832   // real NIC handle and the virtual IPv4 NIC handle.
 833   //
 834   Status = gBS->OpenProtocol (
 835                   ControllerHandle,
 836                   &gEfiCallerIdGuid,
 837                   (VOID **) &Id,
 838                   This->DriverBindingHandle,
 839                   Private->Ip4Nic->Controller,
 840                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 841                   );
 842   if (EFI_ERROR (Status)) {
 843     goto ON_ERROR;
 844   }
 845
 846   //
 847   // Set default configure data for Udp4Read and Ip4 instance.
 848   //
 849   Mode                            = Private->PxeBc.Mode;
 850   Udp4CfgData                     = &Private->Udp4CfgData;
 851   Ip4CfgData                      = &Private->Ip4CfgData;
 852
 853   Udp4CfgData->AcceptBroadcast    = FALSE;
 854   Udp4CfgData->AcceptAnyPort      = TRUE;
 855   Udp4CfgData->AllowDuplicatePort = TRUE;
 856   Udp4CfgData->TypeOfService      = Mode->ToS;
 857   Udp4CfgData->TimeToLive         = Mode->TTL;
 858   Udp4CfgData->ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;
 859   Udp4CfgData->TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;
 860
 861   Ip4CfgData->AcceptIcmpErrors    = TRUE;
 862   Ip4CfgData->DefaultProtocol     = EFI_IP_PROTO_ICMP;
 863   Ip4CfgData->TypeOfService       = Mode->ToS;
 864   Ip4CfgData->TimeToLive          = Mode->TTL;
 865   Ip4CfgData->ReceiveTimeout      = PXEBC_DEFAULT_LIFETIME;
 866   Ip4CfgData->TransmitTimeout     = PXEBC_DEFAULT_LIFETIME;
 867
 868   return EFI_SUCCESS;
 869
 870 ON_ERROR:
 871   PxeBcDestroyIp4Children (This, Private);
 872   return Status;
 873 }
 874
 875
 876 /**
 877   Create the opened instances based on IPv6.
 878
 879   @param[in]  This              Pointer to EFI_DRIVER_BINDING_PROTOCOL.
 880   @param[in]  ControllerHandle  Handle of the child to destroy.
 881   @param[in]  Private Handle    Pointer to PXEBC_PRIVATE_DATA.
 882
 883   @retval EFI_SUCCESS           The instances based on IPv6 were all created successfully.
 884   @retval Others                An unexpected error occurred.
 885
 886 **/
 887 EFI_STATUS
 888 PxeBcCreateIp6Children (
 889   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 890   IN EFI_HANDLE                   ControllerHandle,
 891   IN PXEBC_PRIVATE_DATA           *Private
 892   )
 893 {
 894   EFI_STATUS                      Status;
 895   IPv6_DEVICE_PATH                Ip6Node;
 896   EFI_UDP6_CONFIG_DATA            *Udp6CfgData;
 897   EFI_IP6_CONFIG_DATA             *Ip6CfgData;
 898   EFI_IP6_MODE_DATA               Ip6ModeData;
 899   PXEBC_PRIVATE_PROTOCOL          *Id;
 900   EFI_SIMPLE_NETWORK_PROTOCOL     *Snp;
 901   UINTN                           Index;
 902
 903   if (Private->Ip6Nic != NULL) {
 904     //
 905     // Already created before.
 906     //
 907     return EFI_SUCCESS;
 908   }
 909
 910   Private->Ip6Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC));
 911
 912   if (Private->Ip6Nic == NULL) {
 913     return EFI_OUT_OF_RESOURCES;
 914   }
 915
 916   Private->Ip6Nic->Private   = Private;
 917   Private->Ip6Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE;
 918
 919   //
 920   // Create Dhcp6 child and open Dhcp6 protocol for PxeBc->Dhcp.
 921   //
 922   Status = NetLibCreateServiceChild (
 923              ControllerHandle,
 924              This->DriverBindingHandle,
 925              &gEfiDhcp6ServiceBindingProtocolGuid,
 926              &Private->Dhcp6Child
 927              );
 928   if (EFI_ERROR (Status)) {
 929     goto ON_ERROR;
 930   }
 931
 932   Status = gBS->OpenProtocol (
 933                   Private->Dhcp6Child,
 934                   &gEfiDhcp6ProtocolGuid,
 935                   (VOID **) &Private->Dhcp6,
 936                   This->DriverBindingHandle,
 937                   ControllerHandle,
 938                   EFI_OPEN_PROTOCOL_BY_DRIVER
 939                   );
 940   if (EFI_ERROR (Status)) {
 941     goto ON_ERROR;
 942   }
 943
 944   //
 945   // Generate a random IAID for the Dhcp6 assigned address.
 946   //
 947   Private->IaId = NET_RANDOM (NetRandomInitSeed ());
 948   if (Private->Snp != NULL) {
 949     for (Index = 0; Index < Private->Snp->Mode->HwAddressSize; Index++) {
 950       Private->IaId |= (Private->Snp->Mode->CurrentAddress.Addr[Index] << ((Index << 3) & 31));
 951     }
 952   }
 953
 954   //
 955   // Create Mtftp6 child and open Mtftp6 protocol for PxeBc->Mtftp.
 956   //
 957   Status = NetLibCreateServiceChild (
 958              ControllerHandle,
 959              This->DriverBindingHandle,
 960              &gEfiMtftp6ServiceBindingProtocolGuid,
 961              &Private->Mtftp6Child
 962              );
 963   if (EFI_ERROR (Status)) {
 964     goto ON_ERROR;
 965   }
 966
 967   Status = gBS->OpenProtocol (
 968                   Private->Mtftp6Child,
 969                   &gEfiMtftp6ProtocolGuid,
 970                   (VOID **) &Private->Mtftp6,
 971                   This->DriverBindingHandle,
 972                   ControllerHandle,
 973                   EFI_OPEN_PROTOCOL_BY_DRIVER
 974                   );
 975   if (EFI_ERROR (Status)) {
 976     goto ON_ERROR;
 977   }
 978
 979   //
 980   // Create Udp6 child and open Udp6 protocol for PxeBc->UdpRead.
 981   //
 982   Status = NetLibCreateServiceChild (
 983              ControllerHandle,
 984              This->DriverBindingHandle,
 985              &gEfiUdp6ServiceBindingProtocolGuid,
 986              &Private->Udp6ReadChild
 987              );
 988   if (EFI_ERROR (Status)) {
 989     goto ON_ERROR;
 990   }
 991
 992   Status = gBS->OpenProtocol (
 993                   Private->Udp6ReadChild,
 994                   &gEfiUdp6ProtocolGuid,
 995                   (VOID **) &Private->Udp6Read,
 996                   This->DriverBindingHandle,
 997                   ControllerHandle,
 998                   EFI_OPEN_PROTOCOL_BY_DRIVER
 999                   );
1000   if (EFI_ERROR (Status)) {
1001     goto ON_ERROR;
1002   }
1003
1004   //
1005   // Create Udp6 child and open Udp6 protocol for PxeBc->UdpWrite.
1006   //
1007   Status = NetLibCreateServiceChild (
1008              ControllerHandle,
1009              This->DriverBindingHandle,
1010              &gEfiUdp6ServiceBindingProtocolGuid,
1011              &Private->Udp6WriteChild
1012              );
1013   if (EFI_ERROR (Status)) {
1014     goto ON_ERROR;
1015   }
1016
1017   Status = gBS->OpenProtocol (
1018                   Private->Udp6WriteChild,
1019                   &gEfiUdp6ProtocolGuid,
1020                   (VOID **) &Private->Udp6Write,
1021                   This->DriverBindingHandle,
1022                   ControllerHandle,
1023                   EFI_OPEN_PROTOCOL_BY_DRIVER
1024                   );
1025   if (EFI_ERROR (Status)) {
1026     goto ON_ERROR;
1027   }
1028
1029   //
1030   // Create Ip6 child and open Ip6 protocol for background ICMP6 packets.
1031   //
1032   Status = NetLibCreateServiceChild (
1033              ControllerHandle,
1034              This->DriverBindingHandle,
1035              &gEfiIp6ServiceBindingProtocolGuid,
1036              &Private->Ip6Child
1037              );
1038   if (EFI_ERROR (Status)) {
1039     goto ON_ERROR;
1040   }
1041
1042   Status = gBS->OpenProtocol (
1043                   Private->Ip6Child,
1044                   &gEfiIp6ProtocolGuid,
1045                   (VOID **) &Private->Ip6,
1046                   This->DriverBindingHandle,
1047                   ControllerHandle,
1048                   EFI_OPEN_PROTOCOL_BY_DRIVER
1049                   );
1050   if (EFI_ERROR (Status)) {
1051     goto ON_ERROR;
1052   }
1053
1054   //
1055   // Get max packet size from Ip6 to calculate block size for Tftp later.
1056   //
1057   Status = Private->Ip6->GetModeData (Private->Ip6, &Ip6ModeData, NULL, NULL);
1058   if (EFI_ERROR (Status)) {
1059     goto ON_ERROR;
1060   }
1061
1062   Private->Ip6MaxPacketSize = Ip6ModeData.MaxPacketSize;
1063
1064   if (Ip6ModeData.AddressList != NULL) {
1065     FreePool (Ip6ModeData.AddressList);
1066   }
1067
1068   if (Ip6ModeData.GroupTable != NULL) {
1069     FreePool (Ip6ModeData.GroupTable);
1070   }
1071
1072   if (Ip6ModeData.RouteTable != NULL) {
1073     FreePool (Ip6ModeData.RouteTable);
1074   }
1075
1076   if (Ip6ModeData.NeighborCache != NULL) {
1077     FreePool (Ip6ModeData.NeighborCache);
1078   }
1079
1080   if (Ip6ModeData.PrefixTable != NULL) {
1081     FreePool (Ip6ModeData.PrefixTable);
1082   }
1083
1084   if (Ip6ModeData.IcmpTypeList != NULL) {
1085     FreePool (Ip6ModeData.IcmpTypeList);
1086   }
1087
1088   //
1089   // Locate Ip6->Ip6Config and store it for set IPv6 address.
1090   //
1091   Status = gBS->HandleProtocol (
1092                   ControllerHandle,
1093                   &gEfiIp6ConfigProtocolGuid,
1094                   (VOID **) &Private->Ip6Cfg
1095                   );
1096   if (EFI_ERROR (Status)) {
1097     goto ON_ERROR;
1098   }
1099
1100   //
1101   // Create a device path node for Ipv6 virtual nic, and append it.
1102   //
1103   ZeroMem (&Ip6Node, sizeof (IPv6_DEVICE_PATH));
1104   Ip6Node.Header.Type     = MESSAGING_DEVICE_PATH;
1105   Ip6Node.Header.SubType  = MSG_IPv6_DP;
1106   Ip6Node.PrefixLength    = IP6_PREFIX_LENGTH;
1107
1108   SetDevicePathNodeLength (&Ip6Node.Header, sizeof (Ip6Node));
1109
1110   Private->Ip6Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip6Node.Header);
1111
1112   if (Private->Ip6Nic->DevicePath == NULL) {
1113     Status = EFI_OUT_OF_RESOURCES;
1114     goto ON_ERROR;
1115   }
1116
1117   CopyMem (
1118     &Private->Ip6Nic->LoadFile,
1119     &gLoadFileProtocolTemplate,
1120     sizeof (EFI_LOAD_FILE_PROTOCOL)
1121     );
1122
1123   //
1124   // Create a new handle for IPv6 virtual nic,
1125   // and install PxeBaseCode, LoadFile and DevicePath protocols.
1126   //
1127   Status = gBS->InstallMultipleProtocolInterfaces (
1128                   &Private->Ip6Nic->Controller,
1129                   &gEfiDevicePathProtocolGuid,
1130                   Private->Ip6Nic->DevicePath,
1131                   &gEfiLoadFileProtocolGuid,
1132                   &Private->Ip6Nic->LoadFile,
1133                   &gEfiPxeBaseCodeProtocolGuid,
1134                   &Private->PxeBc,
1135                   NULL
1136                   );
1137   if (EFI_ERROR (Status)) {
1138     goto ON_ERROR;
1139   }
1140
1141   if (Private->Snp != NULL) {
1142     //
1143     // Install SNP protocol on purpose is for some OS loader backward
1144     // compatibility consideration.
1145     //
1146     Status = gBS->InstallProtocolInterface (
1147                     &Private->Ip6Nic->Controller,
1148                     &gEfiSimpleNetworkProtocolGuid,
1149                     EFI_NATIVE_INTERFACE,
1150                     Private->Snp
1151                     );
1152     if (EFI_ERROR (Status)) {
1153       goto ON_ERROR;
1154     }
1155
1156     //
1157     // Open SNP on the child handle BY_DRIVER. It will prevent any additionally
1158     // layering to perform the experiment.
1159     //
1160     Status = gBS->OpenProtocol (
1161                     Private->Ip6Nic->Controller,
1162                     &gEfiSimpleNetworkProtocolGuid,
1163                     (VOID **) &Snp,
1164                     This->DriverBindingHandle,
1165                     Private->Ip6Nic->Controller,
1166                     EFI_OPEN_PROTOCOL_BY_DRIVER
1167                     );
1168     if (EFI_ERROR (Status)) {
1169       goto ON_ERROR;
1170     }
1171   }
1172
1173   //
1174   // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between
1175   // real NIC handle and the virtual IPv6 NIC handle.
1176   //
1177   Status = gBS->OpenProtocol (
1178                   ControllerHandle,
1179                   &gEfiCallerIdGuid,
1180                   (VOID **) &Id,
1181                   This->DriverBindingHandle,
1182                   Private->Ip6Nic->Controller,
1183                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
1184                   );
1185   if (EFI_ERROR (Status)) {
1186     goto ON_ERROR;
1187   }
1188
1189   //
1190   // Set IPv6 avaiable flag and set default configure data for
1191   // Udp6Read and Ip6 instance.
1192   //
1193   Status = PxeBcCheckIpv6Support (ControllerHandle, Private, &Private->Mode.Ipv6Available);
1194   if (EFI_ERROR (Status)) {
1195     //
1196     // Fail to get the data whether UNDI supports IPv6. Set default value.
1197     //
1198     Private->Mode.Ipv6Available   = TRUE;
1199   }
1200
1201   if (!Private->Mode.Ipv6Available) {
1202     goto ON_ERROR;
1203   }
1204
1205   Udp6CfgData                     = &Private->Udp6CfgData;
1206   Ip6CfgData                      = &Private->Ip6CfgData;
1207
1208   Udp6CfgData->AcceptAnyPort      = TRUE;
1209   Udp6CfgData->AllowDuplicatePort = TRUE;
1210   Udp6CfgData->HopLimit           = PXEBC_DEFAULT_HOPLIMIT;
1211   Udp6CfgData->ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;
1212   Udp6CfgData->TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;
1213
1214   Ip6CfgData->AcceptIcmpErrors    = TRUE;
1215   Ip6CfgData->DefaultProtocol     = IP6_ICMP;
1216   Ip6CfgData->HopLimit            = PXEBC_DEFAULT_HOPLIMIT;
1217   Ip6CfgData->ReceiveTimeout      = PXEBC_DEFAULT_LIFETIME;
1218   Ip6CfgData->TransmitTimeout     = PXEBC_DEFAULT_LIFETIME;
1219
1220   return EFI_SUCCESS;
1221
1222 ON_ERROR:
1223   PxeBcDestroyIp6Children (This, Private);
1224   return Status;
1225 }
1226
1227
1228 /**
1229   The entry point for UefiPxeBc driver that installs the driver
1230   binding and component name protocol on its image.
1231
1232   @param[in]  ImageHandle          The Image handle of the driver.
1233   @param[in]  SystemTable          The system table.
1234
1235   @return EFI_SUCCESS
1236   @return Others
1237
1238 **/
1239 EFI_STATUS
1240 EFIAPI
1241 PxeBcDriverEntryPoint (
1242   IN EFI_HANDLE             ImageHandle,
1243   IN EFI_SYSTEM_TABLE       *SystemTable
1244   )
1245 {
1246   EFI_STATUS  Status;
1247
1248   Status = EfiLibInstallDriverBindingComponentName2 (
1249              ImageHandle,
1250              SystemTable,
1251              &gPxeBcIp4DriverBinding,
1252              ImageHandle,
1253              &gPxeBcComponentName,
1254              &gPxeBcComponentName2
1255              );
1256   if (EFI_ERROR (Status)) {
1257     return Status;
1258   }
1259
1260   Status = EfiLibInstallDriverBindingComponentName2 (
1261              ImageHandle,
1262              SystemTable,
1263              &gPxeBcIp6DriverBinding,
1264              NULL,
1265              &gPxeBcComponentName,
1266              &gPxeBcComponentName2
1267              );
1268   if (EFI_ERROR (Status)) {
1269     gBS->UninstallMultipleProtocolInterfaces (
1270            ImageHandle,
1271            &gEfiDriverBindingProtocolGuid,
1272            &gPxeBcIp4DriverBinding,
1273            &gEfiComponentName2ProtocolGuid,
1274            &gPxeBcComponentName2,
1275            &gEfiComponentNameProtocolGuid,
1276            &gPxeBcComponentName,
1277            NULL
1278            );
1279   }
1280
1281   return Status;
1282 }
1283
1284 /**
1285   Test to see if this driver supports ControllerHandle. This is the worker function for
1286   PxeBcIp4(6)DriverBindingSupported.
1287
1288   @param[in]  This                The pointer to the driver binding protocol.
1289   @param[in]  ControllerHandle    The handle of device to be tested.
1290   @param[in]  RemainingDevicePath Optional parameter used to pick a specific child
1291                                   device to be started.
1292   @param[in]  IpVersion           IP_VERSION_4 or IP_VERSION_6.
1293
1294   @retval EFI_SUCCESS         This driver supports this device.
1295   @retval EFI_UNSUPPORTED     This driver does not support this device.
1296
1297 **/
1298 EFI_STATUS
1299 EFIAPI
1300 PxeBcSupported (
1301   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1302   IN EFI_HANDLE                   ControllerHandle,
1303   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL,
1304   IN UINT8                        IpVersion
1305   )
1306 {
1307   EFI_STATUS                      Status;
1308   EFI_GUID                        *DhcpServiceBindingGuid;
1309   EFI_GUID                        *MtftpServiceBindingGuid;
1310
1311   if (IpVersion == IP_VERSION_4) {
1312     DhcpServiceBindingGuid  = &gEfiDhcp4ServiceBindingProtocolGuid;
1313     MtftpServiceBindingGuid = &gEfiMtftp4ServiceBindingProtocolGuid;
1314   } else {
1315     DhcpServiceBindingGuid  = &gEfiDhcp6ServiceBindingProtocolGuid;
1316     MtftpServiceBindingGuid = &gEfiMtftp6ServiceBindingProtocolGuid;
1317   }
1318
1319   //
1320   // Try to open the Mtftp and Dhcp protocol to test whether IP stack is ready.
1321   //
1322   Status = gBS->OpenProtocol (
1323                      ControllerHandle,
1324                      DhcpServiceBindingGuid,
1325                      NULL,
1326                      This->DriverBindingHandle,
1327                      ControllerHandle,
1328                      EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1329                      );
1330   if (!EFI_ERROR (Status)) {
1331     Status = gBS->OpenProtocol (
1332                        ControllerHandle,
1333                        MtftpServiceBindingGuid,
1334                        NULL,
1335                        This->DriverBindingHandle,
1336                        ControllerHandle,
1337                        EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1338                        );
1339   }
1340
1341   //
1342   // It's unsupported case if IP stack are not ready.
1343   //
1344   if (EFI_ERROR (Status)) {
1345     return EFI_UNSUPPORTED;
1346   }
1347
1348   return EFI_SUCCESS;
1349 }
1350
1351 /**
1352   Start this driver on ControllerHandle. This is the worker function for
1353   PxeBcIp4(6)DriverBindingStart.
1354
1355   @param[in]  This                 The pointer to the driver binding protocol.
1356   @param[in]  ControllerHandle     The handle of device to be started.
1357   @param[in]  RemainingDevicePath  Optional parameter used to pick a specific child
1358                                    device to be started.
1359   @param[in]  IpVersion            IP_VERSION_4 or IP_VERSION_6.
1360
1361
1362   @retval EFI_SUCCESS          This driver is installed to ControllerHandle.
1363   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
1364   @retval other                This driver does not support this device.
1365
1366 **/
1367 EFI_STATUS
1368 EFIAPI
1369 PxeBcStart (
1370   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1371   IN EFI_HANDLE                   ControllerHandle,
1372   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL,
1373   IN UINT8                        IpVersion
1374   )
1375 {
1376   PXEBC_PRIVATE_DATA              *Private;
1377   EFI_STATUS                      Status;
1378   PXEBC_PRIVATE_PROTOCOL          *Id;
1379   BOOLEAN                         FirstStart;
1380
1381   FirstStart = FALSE;
1382   Status = gBS->OpenProtocol (
1383                   ControllerHandle,
1384                   &gEfiCallerIdGuid,
1385                   (VOID **) &Id,
1386                   This->DriverBindingHandle,
1387                   ControllerHandle,
1388                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1389                   );
1390   if (!EFI_ERROR (Status)) {
1391     //
1392     // Skip the initialization if the driver has been started already.
1393     //
1394     Private = PXEBC_PRIVATE_DATA_FROM_ID (Id);
1395   } else {
1396     FirstStart = TRUE;
1397     //
1398     // If the driver has not been started yet, it should do initialization.
1399     //
1400     Private = AllocateZeroPool (sizeof (PXEBC_PRIVATE_DATA));
1401     if (Private == NULL) {
1402       return EFI_OUT_OF_RESOURCES;
1403     }
1404
1405     CopyMem (
1406       &Private->PxeBc,
1407       &gPxeBcProtocolTemplate,
1408       sizeof (EFI_PXE_BASE_CODE_PROTOCOL)
1409       );
1410
1411     Private->Signature          = PXEBC_PRIVATE_DATA_SIGNATURE;
1412     Private->Controller         = ControllerHandle;
1413     Private->Image              = This->ImageHandle;
1414     Private->PxeBc.Mode         = &Private->Mode;
1415     Private->Mode.Ipv6Supported = TRUE;
1416     Private->Mode.AutoArp       = TRUE;
1417     Private->Mode.TTL           = DEFAULT_TTL;
1418     Private->Mode.ToS           = DEFAULT_ToS;
1419
1420     //
1421     // Open device path to prepare for appending virtual NIC node.
1422     //
1423     Status = gBS->OpenProtocol (
1424                     ControllerHandle,
1425                     &gEfiDevicePathProtocolGuid,
1426                     (VOID **) &Private->DevicePath,
1427                     This->DriverBindingHandle,
1428                     ControllerHandle,
1429                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1430                     );
1431
1432     if (EFI_ERROR (Status)) {
1433       goto ON_ERROR;
1434     }
1435
1436     //
1437     // Get the NII interface if it exists, it's not required.
1438     //
1439     Status = gBS->OpenProtocol (
1440                     ControllerHandle,
1441                     &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
1442                     (VOID **) &Private->Nii,
1443                     This->DriverBindingHandle,
1444                     ControllerHandle,
1445                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1446                     );
1447     if (EFI_ERROR (Status)) {
1448       Private->Nii = NULL;
1449     }
1450
1451     //
1452     // Install PxeBaseCodePrivate protocol onto the real NIC handler.
1453     // PxeBaseCodePrivate protocol is only used to keep the relationship between
1454     // NIC handle and virtual child handles.
1455     // gEfiCallerIdGuid will be used as its protocol guid.
1456     //
1457     Status = gBS->InstallProtocolInterface (
1458                     &ControllerHandle,
1459                     &gEfiCallerIdGuid,
1460                     EFI_NATIVE_INTERFACE,
1461                     &Private->Id
1462                     );
1463     if (EFI_ERROR (Status)) {
1464       goto ON_ERROR;
1465     }
1466
1467     //
1468     // Try to locate SNP protocol.
1469     //
1470     NetLibGetSnpHandle(ControllerHandle, &Private->Snp);
1471   }
1472
1473   if (IpVersion == IP_VERSION_4) {
1474     //
1475     // Try to create virtual NIC handle for IPv4.
1476     //
1477     Status = PxeBcCreateIp4Children (This, ControllerHandle, Private);
1478   } else {
1479     //
1480     // Try to create virtual NIC handle for IPv6.
1481     //
1482     Status = PxeBcCreateIp6Children (This, ControllerHandle, Private);
1483   }
1484   if (EFI_ERROR (Status)) {
1485     //
1486     // Failed to start PXE driver if IPv4 and IPv6 stack are both not available.
1487     //
1488     Status = EFI_DEVICE_ERROR;
1489     goto ON_ERROR;
1490   }
1491
1492   return EFI_SUCCESS;
1493
1494 ON_ERROR:
1495   if (FirstStart) {
1496     gBS->UninstallProtocolInterface (
1497            ControllerHandle,
1498            &gEfiCallerIdGuid,
1499            &Private->Id
1500            );
1501   }
1502
1503   if (IpVersion == IP_VERSION_4) {
1504     PxeBcDestroyIp4Children (This, Private);
1505   } else {
1506     PxeBcDestroyIp6Children (This, Private);
1507   }
1508
1509   if (FirstStart && Private != NULL) {
1510     FreePool (Private);
1511   }
1512
1513   return Status;
1514 }
1515
1516
1517 /**
1518   Stop this driver on ControllerHandle. This is the worker function for
1519   PxeBcIp4(6)DriverBindingStop.
1520
1521   @param[in]  This              Protocol instance pointer.
1522   @param[in]  ControllerHandle  Handle of device to stop driver on.
1523   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1524                                 children is zero stop the entire bus driver.
1525   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
1526   @param[in]  IpVersion         IP_VERSION_4 or IP_VERSION_6.
1527
1528   @retval EFI_SUCCESS           This driver was removed ControllerHandle.
1529   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
1530   @retval Others                This driver was not removed from this device
1531
1532 **/
1533 EFI_STATUS
1534 EFIAPI
1535 PxeBcStop (
1536   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1537   IN EFI_HANDLE                   ControllerHandle,
1538   IN UINTN                        NumberOfChildren,
1539   IN EFI_HANDLE                   *ChildHandleBuffer,
1540   IN UINT8                        IpVersion
1541   )
1542 {
1543   PXEBC_PRIVATE_DATA              *Private;
1544   PXEBC_VIRTUAL_NIC               *VirtualNic;
1545   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1546   EFI_STATUS                      Status;
1547   EFI_HANDLE                      NicHandle;
1548   PXEBC_PRIVATE_PROTOCOL          *Id;
1549
1550   Private    = NULL;
1551   NicHandle  = NULL;
1552   VirtualNic = NULL;
1553   LoadFile   = NULL;
1554   Id         = NULL;
1555
1556   Status = gBS->OpenProtocol (
1557                   ControllerHandle,
1558                   &gEfiLoadFileProtocolGuid,
1559                   (VOID **) &LoadFile,
1560                   This->DriverBindingHandle,
1561                   ControllerHandle,
1562                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1563                   );
1564   if (EFI_ERROR (Status)) {
1565     //
1566     // Get the Nic handle by any pass-over service child handle.
1567     //
1568     if (IpVersion == IP_VERSION_4) {
1569       NicHandle = PxeBcGetNicByIp4Children (ControllerHandle);
1570     } else {
1571       NicHandle = PxeBcGetNicByIp6Children (ControllerHandle);
1572     }
1573     if (NicHandle == NULL) {
1574       return EFI_SUCCESS;
1575     }
1576
1577     //
1578     // Try to retrieve the private data by PxeBcPrivate protocol.
1579     //
1580     Status = gBS->OpenProtocol (
1581                     NicHandle,
1582                     &gEfiCallerIdGuid,
1583                     (VOID **) &Id,
1584                     This->DriverBindingHandle,
1585                     ControllerHandle,
1586                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1587                     );
1588     if (EFI_ERROR (Status)) {
1589       return Status;
1590     }
1591     Private = PXEBC_PRIVATE_DATA_FROM_ID (Id);
1592
1593   } else {
1594     //
1595     // It's a virtual handle with LoadFileProtocol.
1596     //
1597     Status = gBS->OpenProtocol (
1598                     ControllerHandle,
1599                     &gEfiLoadFileProtocolGuid,
1600                     (VOID **) &LoadFile,
1601                     This->DriverBindingHandle,
1602                     ControllerHandle,
1603                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1604                     );
1605     if (EFI_ERROR (Status)) {
1606       return Status;
1607     }
1608
1609     VirtualNic = PXEBC_VIRTUAL_NIC_FROM_LOADFILE (LoadFile);
1610     Private    = VirtualNic->Private;
1611     NicHandle  = Private->Controller;
1612   }
1613
1614   //
1615   // Stop functionality of PXE Base Code protocol
1616   //
1617   Status = Private->PxeBc.Stop (&Private->PxeBc);
1618   if (Status != EFI_SUCCESS && Status != EFI_NOT_STARTED) {
1619     return Status;
1620   }
1621
1622
1623   if (Private->Ip4Nic != NULL && IpVersion == IP_VERSION_4) {
1624     PxeBcDestroyIp4Children (This, Private);
1625   }
1626
1627   if (Private->Ip6Nic != NULL && IpVersion == IP_VERSION_6) {
1628     PxeBcDestroyIp6Children (This, Private);
1629   }
1630
1631   if (Private->Ip4Nic == NULL && Private->Ip6Nic == NULL) {
1632     gBS->UninstallProtocolInterface (
1633            NicHandle,
1634            &gEfiCallerIdGuid,
1635            &Private->Id
1636            );
1637     FreePool (Private);
1638   }
1639
1640   return EFI_SUCCESS;
1641 }
1642
1643 /**
1644   Test to see if this driver supports ControllerHandle. This service
1645   is called by the EFI boot service ConnectController(). In
1646   order to make drivers as small as possible, there are a few calling
1647   restrictions for this service. ConnectController() must
1648   follow these calling restrictions. If any other agent wishes to call
1649   Supported() it must also follow these calling restrictions.
1650
1651   @param[in]  This                The pointer to the driver binding protocol.
1652   @param[in]  ControllerHandle    The handle of device to be tested.
1653   @param[in]  RemainingDevicePath Optional parameter used to pick a specific child
1654                                   device to be started.
1655
1656   @retval EFI_SUCCESS         This driver supports this device.
1657   @retval EFI_UNSUPPORTED     This driver does not support this device.
1658
1659 **/
1660 EFI_STATUS
1661 EFIAPI
1662 PxeBcIp4DriverBindingSupported (
1663   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1664   IN EFI_HANDLE                   ControllerHandle,
1665   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1666   )
1667 {
1668   return PxeBcSupported (
1669            This,
1670            ControllerHandle,
1671            RemainingDevicePath,
1672            IP_VERSION_4
1673            );
1674 }
1675
1676 /**
1677   Start this driver on ControllerHandle. This service is called by the
1678   EFI boot service ConnectController(). In order to make
1679   drivers as small as possible, there are a few calling restrictions for
1680   this service. ConnectController() must follow these
1681   calling restrictions. If any other agent wishes to call Start() it
1682   must also follow these calling restrictions.
1683
1684   @param[in]  This                 The pointer to the driver binding protocol.
1685   @param[in]  ControllerHandle     The handle of device to be started.
1686   @param[in]  RemainingDevicePath  Optional parameter used to pick a specific child
1687                                    device to be started.
1688
1689   @retval EFI_SUCCESS          This driver is installed to ControllerHandle.
1690   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
1691   @retval other                This driver does not support this device.
1692
1693 **/
1694 EFI_STATUS
1695 EFIAPI
1696 PxeBcIp4DriverBindingStart (
1697   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1698   IN EFI_HANDLE                   ControllerHandle,
1699   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1700   )
1701 {
1702   return PxeBcStart (
1703            This,
1704            ControllerHandle,
1705            RemainingDevicePath,
1706            IP_VERSION_4
1707            );
1708 }
1709
1710 /**
1711   Stop this driver on ControllerHandle. This service is called by the
1712   EFI boot service DisconnectController(). In order to
1713   make drivers as small as possible, there are a few calling
1714   restrictions for this service. DisconnectController()
1715   must follow these calling restrictions. If any other agent wishes
1716   to call Stop() it must also follow these calling restrictions.
1717
1718   @param[in]  This              Protocol instance pointer.
1719   @param[in]  ControllerHandle  Handle of device to stop driver on
1720   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1721                                 children is zero stop the entire bus driver.
1722   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
1723
1724   @retval EFI_SUCCESS           This driver is removed ControllerHandle
1725   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
1726   @retval Others                This driver was not removed from this device.
1727
1728 **/
1729 EFI_STATUS
1730 EFIAPI
1731 PxeBcIp4DriverBindingStop (
1732   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1733   IN EFI_HANDLE                   ControllerHandle,
1734   IN UINTN                        NumberOfChildren,
1735   IN EFI_HANDLE                   *ChildHandleBuffer
1736   )
1737 {
1738   return PxeBcStop (
1739            This,
1740            ControllerHandle,
1741            NumberOfChildren,
1742            ChildHandleBuffer,
1743            IP_VERSION_4
1744            );
1745 }
1746
1747 /**
1748   Test to see if this driver supports ControllerHandle. This service
1749   is called by the EFI boot service ConnectController(). In
1750   order to make drivers as small as possible, there are a few calling
1751   restrictions for this service. ConnectController() must
1752   follow these calling restrictions. If any other agent wishes to call
1753   Supported() it must also follow these calling restrictions.
1754
1755   @param[in]  This                The pointer to the driver binding protocol.
1756   @param[in]  ControllerHandle    The handle of device to be tested.
1757   @param[in]  RemainingDevicePath Optional parameter use to pick a specific child
1758                                   device to be started.
1759
1760   @retval EFI_SUCCESS         This driver supports this device.
1761   @retval EFI_UNSUPPORTED     This driver does not support this device.
1762
1763 **/
1764 EFI_STATUS
1765 EFIAPI
1766 PxeBcIp6DriverBindingSupported (
1767   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1768   IN EFI_HANDLE                   ControllerHandle,
1769   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1770   )
1771 {
1772   return PxeBcSupported (
1773            This,
1774            ControllerHandle,
1775            RemainingDevicePath,
1776            IP_VERSION_6
1777            );
1778 }
1779
1780 /**
1781   Start this driver on ControllerHandle. This service is called by the
1782   EFI boot service ConnectController(). In order to make
1783   drivers as small as possible, there are a few calling restrictions for
1784   this service. ConnectController() must follow these
1785   calling restrictions. If any other agent wishes to call Start() it
1786   must also follow these calling restrictions.
1787
1788   @param[in]  This                 The pointer to the driver binding protocol.
1789   @param[in]  ControllerHandle     The handle of device to be started.
1790   @param[in]  RemainingDevicePath  Optional parameter used to pick a specific child
1791                                    device to be started.
1792
1793   @retval EFI_SUCCESS          This driver is installed to ControllerHandle.
1794   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
1795   @retval other                This driver does not support this device.
1796
1797 **/
1798 EFI_STATUS
1799 EFIAPI
1800 PxeBcIp6DriverBindingStart (
1801   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1802   IN EFI_HANDLE                   ControllerHandle,
1803   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1804   )
1805 {
1806   return PxeBcStart (
1807            This,
1808            ControllerHandle,
1809            RemainingDevicePath,
1810            IP_VERSION_6
1811            );
1812 }
1813
1814 /**
1815   Stop this driver on ControllerHandle. This service is called by the
1816   EFI boot service DisconnectController(). In order to
1817   make drivers as small as possible, there are a few calling
1818   restrictions for this service. DisconnectController()
1819   must follow these calling restrictions. If any other agent wishes
1820   to call Stop() it must also follow these calling restrictions.
1821
1822   @param[in]  This              Protocol instance pointer.
1823   @param[in]  ControllerHandle  Handle of device to stop driver on
1824   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1825                                 children is zero stop the entire bus driver.
1826   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
1827
1828   @retval EFI_SUCCESS           This driver is removed ControllerHandle
1829   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
1830   @retval Others                This driver was not removed from this device.
1831
1832 **/
1833 EFI_STATUS
1834 EFIAPI
1835 PxeBcIp6DriverBindingStop (
1836   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1837   IN EFI_HANDLE                   ControllerHandle,
1838   IN UINTN                        NumberOfChildren,
1839   IN EFI_HANDLE                   *ChildHandleBuffer
1840   )
1841 {
1842   return PxeBcStop (
1843            This,
1844            ControllerHandle,
1845            NumberOfChildren,
1846            ChildHandleBuffer,
1847            IP_VERSION_6
1848            );
1849 }