NetworkPkg/HttpBootDxe/HttpBootDxe.c

   1 /** @file
   2   Driver Binding functions implementation for UEFI HTTP boot.
   3
   4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials are licensed and made available under
   6 the terms and conditions of the BSD License that accompanies this distribution.
   7 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 "HttpBootDxe.h"
  16
  17 ///
  18 /// Driver Binding Protocol instance
  19 ///
  20 EFI_DRIVER_BINDING_PROTOCOL gHttpBootIp4DxeDriverBinding = {
  21   HttpBootIp4DxeDriverBindingSupported,
  22   HttpBootIp4DxeDriverBindingStart,
  23   HttpBootIp4DxeDriverBindingStop,
  24   HTTP_BOOT_DXE_VERSION,
  25   NULL,
  26   NULL
  27 };
  28
  29 EFI_DRIVER_BINDING_PROTOCOL gHttpBootIp6DxeDriverBinding = {
  30   HttpBootIp6DxeDriverBindingSupported,
  31   HttpBootIp6DxeDriverBindingStart,
  32   HttpBootIp6DxeDriverBindingStop,
  33   HTTP_BOOT_DXE_VERSION,
  34   NULL,
  35   NULL
  36 };
  37
  38 /**
  39   Destroy the HTTP child based on IPv4 stack.
  40
  41   @param[in]  This              Pointer to the EFI_DRIVER_BINDING_PROTOCOL.
  42   @param[in]  Private           Pointer to HTTP_BOOT_PRIVATE_DATA.
  43
  44 **/
  45 VOID
  46 HttpBootDestroyIp4Children (
  47   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  48   IN HTTP_BOOT_PRIVATE_DATA       *Private
  49   )
  50 {
  51   ASSERT (This != NULL);
  52   ASSERT (Private != NULL);
  53   ASSERT (Private->UsingIpv6 == FALSE);
  54
  55   if (Private->Dhcp4Child != NULL) {
  56     gBS->CloseProtocol (
  57            Private->Dhcp4Child,
  58            &gEfiDhcp4ProtocolGuid,
  59            This->DriverBindingHandle,
  60            Private->Controller
  61            );
  62
  63     NetLibDestroyServiceChild (
  64       Private->Controller,
  65       This->DriverBindingHandle,
  66       &gEfiDhcp4ServiceBindingProtocolGuid,
  67       Private->Dhcp4Child
  68       );
  69   }
  70
  71   if (Private->HttpCreated) {
  72     HttpIoDestroyIo (&Private->HttpIo);
  73     Private->HttpCreated = FALSE;
  74   }
  75
  76   if (Private->Ip4Nic != NULL) {
  77
  78     gBS->CloseProtocol (
  79            Private->Controller,
  80            &gEfiCallerIdGuid,
  81            This->DriverBindingHandle,
  82            Private->Ip4Nic->Controller
  83            );
  84
  85     gBS->UninstallMultipleProtocolInterfaces (
  86            Private->Ip4Nic->Controller,
  87            &gEfiLoadFileProtocolGuid,
  88            &Private->Ip4Nic->LoadFile,
  89            &gEfiDevicePathProtocolGuid,
  90            Private->Ip4Nic->DevicePath,
  91            NULL
  92            );
  93     FreePool (Private->Ip4Nic);
  94     Private->Ip4Nic = NULL;
  95   }
  96
  97 }
  98
  99 /**
 100   Destroy the HTTP child based on IPv6 stack.
 101
 102   @param[in]  This              Pointer to the EFI_DRIVER_BINDING_PROTOCOL.
 103   @param[in]  Private           Pointer to HTTP_BOOT_PRIVATE_DATA.
 104
 105 **/
 106 VOID
 107 HttpBootDestroyIp6Children (
 108   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 109   IN HTTP_BOOT_PRIVATE_DATA       *Private
 110   )
 111 {
 112   ASSERT (This != NULL);
 113   ASSERT (Private != NULL);
 114   ASSERT (Private->UsingIpv6 == TRUE);
 115
 116   if (Private->Ip6Child != NULL) {
 117     gBS->CloseProtocol (
 118            Private->Ip6Child,
 119            &gEfiIp6ProtocolGuid,
 120            This->DriverBindingHandle,
 121            Private->Controller
 122            );
 123
 124     NetLibDestroyServiceChild (
 125       Private->Controller,
 126       This->DriverBindingHandle,
 127       &gEfiIp6ServiceBindingProtocolGuid,
 128       Private->Ip6Child
 129       );
 130   }
 131
 132   if (Private->Dhcp6Child != NULL) {
 133     gBS->CloseProtocol (
 134            Private->Dhcp6Child,
 135            &gEfiDhcp6ProtocolGuid,
 136            This->DriverBindingHandle,
 137            Private->Controller
 138            );
 139
 140     NetLibDestroyServiceChild (
 141       Private->Controller,
 142       This->DriverBindingHandle,
 143       &gEfiDhcp6ServiceBindingProtocolGuid,
 144       Private->Dhcp6Child
 145       );
 146   }
 147
 148   if (Private->HttpCreated) {
 149     HttpIoDestroyIo(&Private->HttpIo);
 150     Private->HttpCreated = FALSE;
 151   }
 152
 153   if (Private->Ip6Nic != NULL) {
 154
 155     gBS->CloseProtocol (
 156            Private->Controller,
 157            &gEfiCallerIdGuid,
 158            This->DriverBindingHandle,
 159            Private->Ip6Nic->Controller
 160            );
 161
 162     gBS->UninstallMultipleProtocolInterfaces (
 163            Private->Ip6Nic->Controller,
 164            &gEfiLoadFileProtocolGuid,
 165            &Private->Ip6Nic->LoadFile,
 166            &gEfiDevicePathProtocolGuid,
 167            Private->Ip6Nic->DevicePath,
 168            NULL
 169            );
 170     FreePool (Private->Ip6Nic);
 171     Private->Ip6Nic = NULL;
 172   }
 173 }
 174
 175 /**
 176   Tests to see if this driver supports a given controller. If a child device is provided,
 177   it further tests to see if this driver supports creating a handle for the specified child device.
 178
 179   This function checks to see if the driver specified by This supports the device specified by
 180   ControllerHandle. Drivers will typically use the device path attached to
 181   ControllerHandle and/or the services from the bus I/O abstraction attached to
 182   ControllerHandle to determine if the driver supports ControllerHandle. This function
 183   may be called many times during platform initialization. In order to reduce boot times, the tests
 184   performed by this function must be very small, and take as little time as possible to execute. This
 185   function must not change the state of any hardware devices, and this function must be aware that the
 186   device specified by ControllerHandle may already be managed by the same driver or a
 187   different driver. This function must match its calls to AllocatePages() with FreePages(),
 188   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
 189   Because ControllerHandle may have been previously started by the same driver, if a protocol is
 190   already in the opened state, then it must not be closed with CloseProtocol(). This is required
 191   to guarantee the state of ControllerHandle is not modified by this function.
 192
 193   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 194   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 195                                    must support a protocol interface that supplies
 196                                    an I/O abstraction to the driver.
 197   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 198                                    parameter is ignored by device drivers, and is optional for bus
 199                                    drivers. For bus drivers, if this parameter is not NULL, then
 200                                    the bus driver must determine if the bus controller specified
 201                                    by ControllerHandle and the child controller specified
 202                                    by RemainingDevicePath are both supported by this
 203                                    bus driver.
 204
 205   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 206                                    RemainingDevicePath is supported by the driver specified by This.
 207   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 208                                    RemainingDevicePath is already being managed by the driver
 209                                    specified by This.
 210   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 211                                    RemainingDevicePath is already being managed by a different
 212                                    driver or an application that requires exclusive access.
 213                                    Currently not implemented.
 214   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 215                                    RemainingDevicePath is not supported by the driver specified by This.
 216 **/
 217 EFI_STATUS
 218 EFIAPI
 219 HttpBootIp4DxeDriverBindingSupported (
 220   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 221   IN EFI_HANDLE                   ControllerHandle,
 222   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 223   )
 224 {
 225   EFI_STATUS                    Status;
 226
 227   //
 228   // Try to open the DHCP4, HTTP4 and Device Path protocol.
 229   //
 230   Status = gBS->OpenProtocol (
 231                   ControllerHandle,
 232                   &gEfiDhcp4ServiceBindingProtocolGuid,
 233                   NULL,
 234                   This->DriverBindingHandle,
 235                   ControllerHandle,
 236                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 237                   );
 238   if (EFI_ERROR (Status)) {
 239     return Status;
 240   }
 241
 242   Status = gBS->OpenProtocol (
 243                   ControllerHandle,
 244                   &gEfiHttpServiceBindingProtocolGuid,
 245                   NULL,
 246                   This->DriverBindingHandle,
 247                   ControllerHandle,
 248                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 249                   );
 250   if (EFI_ERROR (Status)) {
 251     return Status;
 252   }
 253
 254   Status = gBS->OpenProtocol (
 255                   ControllerHandle,
 256                   &gEfiDevicePathProtocolGuid,
 257                   NULL,
 258                   This->DriverBindingHandle,
 259                   ControllerHandle,
 260                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 261                   );
 262
 263   return Status;
 264 }
 265
 266
 267 /**
 268   Starts a device controller or a bus controller.
 269
 270   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 271   As a result, much of the error checking on the parameters to Start() has been moved into this
 272   common boot service. It is legal to call Start() from other locations,
 273   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 274   1. ControllerHandle must be a valid EFI_HANDLE.
 275   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 276      EFI_DEVICE_PATH_PROTOCOL.
 277   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 278      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 279
 280   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 281   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 282                                    must support a protocol interface that supplies
 283                                    an I/O abstraction to the driver.
 284   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 285                                    parameter is ignored by device drivers, and is optional for bus
 286                                    drivers. For a bus driver, if this parameter is NULL, then handles
 287                                    for all the children of Controller are created by this driver.
 288                                    If this parameter is not NULL and the first Device Path Node is
 289                                    not the End of Device Path Node, then only the handle for the
 290                                    child device specified by the first Device Path Node of
 291                                    RemainingDevicePath is created by this driver.
 292                                    If the first Device Path Node of RemainingDevicePath is
 293                                    the End of Device Path Node, no child handle is created by this
 294                                    driver.
 295
 296   @retval EFI_SUCCESS              The device was started.
 297   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 298   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 299   @retval Others                   The driver failded to start the device.
 300
 301 **/
 302 EFI_STATUS
 303 EFIAPI
 304 HttpBootIp4DxeDriverBindingStart (
 305   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 306   IN EFI_HANDLE                   ControllerHandle,
 307   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 308   )
 309 {
 310   EFI_STATUS                 Status;
 311   HTTP_BOOT_PRIVATE_DATA     *Private;
 312   EFI_DEV_PATH               *Node;
 313   EFI_DEVICE_PATH_PROTOCOL   *DevicePath;
 314   UINT32                     *Id;
 315
 316   Status = gBS->OpenProtocol (
 317                   ControllerHandle,
 318                   &gEfiCallerIdGuid,
 319                   (VOID **) &Id,
 320                   This->DriverBindingHandle,
 321                   ControllerHandle,
 322                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 323                   );
 324
 325   if (!EFI_ERROR (Status)) {
 326       Private = HTTP_BOOT_PRIVATE_DATA_FROM_ID(Id);
 327   } else {
 328     //
 329     // Initialize the private data structure.
 330     //
 331     Private = AllocateZeroPool (sizeof (HTTP_BOOT_PRIVATE_DATA));
 332     if (Private == NULL) {
 333       return EFI_OUT_OF_RESOURCES;
 334     }
 335     Private->Signature = HTTP_BOOT_PRIVATE_DATA_SIGNATURE;
 336     Private->Controller = ControllerHandle;
 337     Private->Image = This->ImageHandle;
 338     InitializeListHead (&Private->CacheList);
 339     //
 340     // Get the NII interface if it exists, it's not required.
 341     //
 342     Status = gBS->OpenProtocol (
 343                     ControllerHandle,
 344                     &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 345                     (VOID **) &Private->Nii,
 346                     This->DriverBindingHandle,
 347                     ControllerHandle,
 348                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 349                     );
 350     if (EFI_ERROR (Status)) {
 351       Private->Nii = NULL;
 352     }
 353
 354     //
 355     // Open Device Path Protocol to prepare for appending IP and URI node.
 356     //
 357     Status = gBS->OpenProtocol (
 358                     ControllerHandle,
 359                     &gEfiDevicePathProtocolGuid,
 360                     (VOID **) &Private->ParentDevicePath,
 361                     This->DriverBindingHandle,
 362                     ControllerHandle,
 363                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 364                     );
 365     if (EFI_ERROR (Status)) {
 366       goto ON_ERROR;
 367     }
 368
 369     //
 370     // Install a protocol with Caller Id Guid to the NIC, this is just to build the relationship between
 371     // NIC handle and the private data.
 372     //
 373     Status = gBS->InstallProtocolInterface (
 374                     &ControllerHandle,
 375                     &gEfiCallerIdGuid,
 376                     EFI_NATIVE_INTERFACE,
 377                     &Private->Id
 378                     );
 379     if (EFI_ERROR (Status)) {
 380       goto ON_ERROR;
 381     }
 382
 383   }
 384
 385   if (Private->Ip4Nic != NULL) {
 386     //
 387     // Already created before
 388     //
 389     return EFI_SUCCESS;
 390   }
 391
 392   Private->Ip4Nic = AllocateZeroPool (sizeof (HTTP_BOOT_VIRTUAL_NIC));
 393   if (Private->Ip4Nic == NULL) {
 394     return EFI_OUT_OF_RESOURCES;
 395   }
 396   Private->Ip4Nic->Private   = Private;
 397   Private->Ip4Nic->Signature = HTTP_BOOT_VIRTUAL_NIC_SIGNATURE;
 398
 399   //
 400   // Create DHCP4 child instance.
 401   //
 402   Status = NetLibCreateServiceChild (
 403              ControllerHandle,
 404              This->DriverBindingHandle,
 405              &gEfiDhcp4ServiceBindingProtocolGuid,
 406              &Private->Dhcp4Child
 407              );
 408   if (EFI_ERROR (Status)) {
 409     goto ON_ERROR;
 410   }
 411
 412   Status = gBS->OpenProtocol (
 413                   Private->Dhcp4Child,
 414                   &gEfiDhcp4ProtocolGuid,
 415                   (VOID **) &Private->Dhcp4,
 416                   This->DriverBindingHandle,
 417                   ControllerHandle,
 418                   EFI_OPEN_PROTOCOL_BY_DRIVER
 419                   );
 420   if (EFI_ERROR (Status)) {
 421     goto ON_ERROR;
 422   }
 423
 424   //
 425   // Get the Ip4Config2 protocol, it's required to configure the default gateway address.
 426   //
 427   Status = gBS->OpenProtocol (
 428                   ControllerHandle,
 429                   &gEfiIp4Config2ProtocolGuid,
 430                   (VOID **) &Private->Ip4Config2,
 431                   This->DriverBindingHandle,
 432                   ControllerHandle,
 433                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 434                   );
 435   if (EFI_ERROR (Status)) {
 436     goto ON_ERROR;
 437   }
 438
 439   //
 440   // Append IPv4 device path node.
 441   //
 442   Node = AllocateZeroPool (sizeof (IPv4_DEVICE_PATH));
 443   if (Node == NULL) {
 444     Status = EFI_OUT_OF_RESOURCES;
 445     goto ON_ERROR;
 446   }
 447   Node->Ipv4.Header.Type = MESSAGING_DEVICE_PATH;
 448   Node->Ipv4.Header.SubType = MSG_IPv4_DP;
 449   SetDevicePathNodeLength (Node, sizeof (IPv4_DEVICE_PATH));
 450   Node->Ipv4.StaticIpAddress = FALSE;
 451   DevicePath = AppendDevicePathNode (Private->ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
 452   FreePool (Node);
 453   if (DevicePath == NULL) {
 454     Status = EFI_OUT_OF_RESOURCES;
 455     goto ON_ERROR;
 456   }
 457
 458   //
 459   // Append URI device path node.
 460   //
 461   Node = AllocateZeroPool (sizeof (EFI_DEVICE_PATH_PROTOCOL));
 462   if (Node == NULL) {
 463     Status = EFI_OUT_OF_RESOURCES;
 464     goto ON_ERROR;
 465   }
 466   Node->DevPath.Type = MESSAGING_DEVICE_PATH;
 467   Node->DevPath.SubType = MSG_URI_DP;
 468   SetDevicePathNodeLength (Node, sizeof (EFI_DEVICE_PATH_PROTOCOL));
 469   Private->Ip4Nic->DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
 470   FreePool (Node);
 471   FreePool (DevicePath);
 472   if (Private->Ip4Nic->DevicePath == NULL) {
 473     Status = EFI_OUT_OF_RESOURCES;
 474     goto ON_ERROR;
 475   }
 476
 477   //
 478   // Create a child handle for the HTTP boot and install DevPath and Load file protocol on it.
 479   //
 480   CopyMem (&Private->Ip4Nic->LoadFile, &gHttpBootDxeLoadFile, sizeof (EFI_LOAD_FILE_PROTOCOL));
 481   Status = gBS->InstallMultipleProtocolInterfaces (
 482                   &Private->Ip4Nic->Controller,
 483                   &gEfiLoadFileProtocolGuid,
 484                   &Private->Ip4Nic->LoadFile,
 485                   &gEfiDevicePathProtocolGuid,
 486                   Private->Ip4Nic->DevicePath,
 487                   NULL
 488                   );
 489   if (EFI_ERROR (Status)) {
 490     goto ON_ERROR;
 491   }
 492
 493   //
 494   // Open the Caller Id child to setup a parent-child relationship between
 495   // real NIC handle and the HTTP boot Ipv4 NIC handle.
 496   //
 497   Status = gBS->OpenProtocol (
 498                   ControllerHandle,
 499                   &gEfiCallerIdGuid,
 500                   (VOID **) &Id,
 501                   This->DriverBindingHandle,
 502                   Private->Ip4Nic->Controller,
 503                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 504                   );
 505   if (EFI_ERROR (Status)) {
 506     goto ON_ERROR;
 507   }
 508
 509   return EFI_SUCCESS;
 510
 511
 512 ON_ERROR:
 513
 514   HttpBootDestroyIp4Children (This, Private);
 515   FreePool (Private);
 516
 517   return Status;
 518 }
 519
 520
 521 /**
 522   Stops a device controller or a bus controller.
 523
 524   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
 525   As a result, much of the error checking on the parameters to Stop() has been moved
 526   into this common boot service. It is legal to call Stop() from other locations,
 527   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 528   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
 529      same driver's Start() function.
 530   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
 531      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
 532      Start() function, and the Start() function must have called OpenProtocol() on
 533      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 534
 535   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 536   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
 537                                 support a bus specific I/O protocol for the driver
 538                                 to use to stop the device.
 539   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
 540   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
 541                                 if NumberOfChildren is 0.
 542
 543   @retval EFI_SUCCESS           The device was stopped.
 544   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 545
 546 **/
 547 EFI_STATUS
 548 EFIAPI
 549 HttpBootIp4DxeDriverBindingStop (
 550   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 551   IN EFI_HANDLE                   ControllerHandle,
 552   IN UINTN                        NumberOfChildren,
 553   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 554   )
 555 {
 556   EFI_STATUS                      Status;
 557   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
 558   HTTP_BOOT_PRIVATE_DATA          *Private;
 559   EFI_HANDLE                      NicHandle;
 560   UINT32                          *Id;
 561
 562   //
 563   // Try to get the Load File Protocol from the controller handle.
 564   //
 565   Status = gBS->OpenProtocol (
 566                   ControllerHandle,
 567                   &gEfiLoadFileProtocolGuid,
 568                   (VOID **) &LoadFile,
 569                   This->DriverBindingHandle,
 570                   ControllerHandle,
 571                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 572                   );
 573   if (EFI_ERROR (Status)) {
 574     //
 575     // If failed, try to find the NIC handle for this controller.
 576     //
 577     NicHandle = HttpBootGetNicByIp4Children (ControllerHandle);
 578     if (NicHandle == NULL) {
 579       return EFI_SUCCESS;
 580     }
 581
 582     //
 583     // Try to retrieve the private data by the Caller Id Guid.
 584     //
 585     Status = gBS->OpenProtocol (
 586                     NicHandle,
 587                     &gEfiCallerIdGuid,
 588                     (VOID **) &Id,
 589                     This->DriverBindingHandle,
 590                     ControllerHandle,
 591                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 592                     );
 593     if (EFI_ERROR (Status)) {
 594       return Status;
 595     }
 596     Private = HTTP_BOOT_PRIVATE_DATA_FROM_ID (Id);
 597   } else {
 598     Private = HTTP_BOOT_PRIVATE_DATA_FROM_LOADFILE (LoadFile);
 599     NicHandle = Private->Controller;
 600   }
 601
 602   //
 603   // Disable the HTTP boot function.
 604   //
 605   Status = HttpBootStop (Private);
 606   if (Status != EFI_SUCCESS && Status != EFI_NOT_STARTED) {
 607     return Status;
 608   }
 609
 610   //
 611   // Destory all child instance and uninstall protocol interface.
 612   //
 613   HttpBootDestroyIp4Children (This, Private);
 614
 615   if (Private->Ip4Nic == NULL && Private->Ip6Nic == NULL) {
 616     //
 617     // Release the cached data.
 618     //
 619     HttpBootFreeCacheList (Private);
 620
 621     gBS->UninstallProtocolInterface (
 622            NicHandle,
 623            &gEfiCallerIdGuid,
 624            &Private->Id
 625            );
 626     FreePool (Private);
 627
 628   }
 629
 630   return EFI_SUCCESS;
 631 }
 632
 633 /**
 634   Tests to see if this driver supports a given controller. If a child device is provided,
 635   it further tests to see if this driver supports creating a handle for the specified child device.
 636
 637   This function checks to see if the driver specified by This supports the device specified by
 638   ControllerHandle. Drivers will typically use the device path attached to
 639   ControllerHandle and/or the services from the bus I/O abstraction attached to
 640   ControllerHandle to determine if the driver supports ControllerHandle. This function
 641   may be called many times during platform initialization. In order to reduce boot times, the tests
 642   performed by this function must be very small, and take as little time as possible to execute. This
 643   function must not change the state of any hardware devices, and this function must be aware that the
 644   device specified by ControllerHandle may already be managed by the same driver or a
 645   different driver. This function must match its calls to AllocatePages() with FreePages(),
 646   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
 647   Because ControllerHandle may have been previously started by the same driver, if a protocol is
 648   already in the opened state, then it must not be closed with CloseProtocol(). This is required
 649   to guarantee the state of ControllerHandle is not modified by this function.
 650
 651   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 652   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 653                                    must support a protocol interface that supplies
 654                                    an I/O abstraction to the driver.
 655   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 656                                    parameter is ignored by device drivers, and is optional for bus
 657                                    drivers. For bus drivers, if this parameter is not NULL, then
 658                                    the bus driver must determine if the bus controller specified
 659                                    by ControllerHandle and the child controller specified
 660                                    by RemainingDevicePath are both supported by this
 661                                    bus driver.
 662
 663   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 664                                    RemainingDevicePath is supported by the driver specified by This.
 665   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 666                                    RemainingDevicePath is already being managed by the driver
 667                                    specified by This.
 668   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 669                                    RemainingDevicePath is already being managed by a different
 670                                    driver or an application that requires exclusive access.
 671                                    Currently not implemented.
 672   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 673                                    RemainingDevicePath is not supported by the driver specified by This.
 674 **/
 675 EFI_STATUS
 676 EFIAPI
 677 HttpBootIp6DxeDriverBindingSupported (
 678   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 679   IN EFI_HANDLE                   ControllerHandle,
 680   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 681   )
 682 {
 683   EFI_STATUS                    Status;
 684
 685   //
 686   // Try to open the DHCP6, HTTP and Device Path protocol.
 687   //
 688   Status = gBS->OpenProtocol (
 689                   ControllerHandle,
 690                   &gEfiDhcp6ServiceBindingProtocolGuid,
 691                   NULL,
 692                   This->DriverBindingHandle,
 693                   ControllerHandle,
 694                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 695                   );
 696   if (EFI_ERROR (Status)) {
 697     return Status;
 698   }
 699
 700   Status = gBS->OpenProtocol (
 701                   ControllerHandle,
 702                   &gEfiHttpServiceBindingProtocolGuid,
 703                   NULL,
 704                   This->DriverBindingHandle,
 705                   ControllerHandle,
 706                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 707                   );
 708   if (EFI_ERROR (Status)) {
 709     return Status;
 710   }
 711
 712   Status = gBS->OpenProtocol (
 713                   ControllerHandle,
 714                   &gEfiDevicePathProtocolGuid,
 715                   NULL,
 716                   This->DriverBindingHandle,
 717                   ControllerHandle,
 718                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 719                   );
 720
 721   return Status;
 722
 723 }
 724
 725 /**
 726   Starts a device controller or a bus controller.
 727
 728   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 729   As a result, much of the error checking on the parameters to Start() has been moved into this
 730   common boot service. It is legal to call Start() from other locations,
 731   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 732   1. ControllerHandle must be a valid EFI_HANDLE.
 733   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 734      EFI_DEVICE_PATH_PROTOCOL.
 735   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 736      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 737
 738   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 739   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 740                                    must support a protocol interface that supplies
 741                                    an I/O abstraction to the driver.
 742   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 743                                    parameter is ignored by device drivers, and is optional for bus
 744                                    drivers. For a bus driver, if this parameter is NULL, then handles
 745                                    for all the children of Controller are created by this driver.
 746                                    If this parameter is not NULL and the first Device Path Node is
 747                                    not the End of Device Path Node, then only the handle for the
 748                                    child device specified by the first Device Path Node of
 749                                    RemainingDevicePath is created by this driver.
 750                                    If the first Device Path Node of RemainingDevicePath is
 751                                    the End of Device Path Node, no child handle is created by this
 752                                    driver.
 753
 754   @retval EFI_SUCCESS              The device was started.
 755   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 756   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 757   @retval Others                   The driver failded to start the device.
 758
 759 **/
 760 EFI_STATUS
 761 EFIAPI
 762 HttpBootIp6DxeDriverBindingStart (
 763   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 764   IN EFI_HANDLE                   ControllerHandle,
 765   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 766   )
 767 {
 768   EFI_STATUS                 Status;
 769   HTTP_BOOT_PRIVATE_DATA     *Private;
 770   EFI_DEV_PATH               *Node;
 771   EFI_DEVICE_PATH_PROTOCOL   *DevicePath;
 772   UINT32                     *Id;
 773
 774   Status = gBS->OpenProtocol (
 775                   ControllerHandle,
 776                   &gEfiCallerIdGuid,
 777                   (VOID **) &Id,
 778                   This->DriverBindingHandle,
 779                   ControllerHandle,
 780                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 781                   );
 782
 783   if (!EFI_ERROR (Status)) {
 784       Private = HTTP_BOOT_PRIVATE_DATA_FROM_ID(Id);
 785   } else {
 786     //
 787     // Initialize the private data structure.
 788     //
 789     Private = AllocateZeroPool (sizeof (HTTP_BOOT_PRIVATE_DATA));
 790     if (Private == NULL) {
 791       return EFI_OUT_OF_RESOURCES;
 792     }
 793     Private->Signature = HTTP_BOOT_PRIVATE_DATA_SIGNATURE;
 794     Private->Controller = ControllerHandle;
 795     Private->Image = This->ImageHandle;
 796     InitializeListHead (&Private->CacheList);
 797     //
 798     // Get the NII interface if it exists, it's not required.
 799     //
 800     Status = gBS->OpenProtocol (
 801                     ControllerHandle,
 802                     &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 803                     (VOID **) &Private->Nii,
 804                     This->DriverBindingHandle,
 805                     ControllerHandle,
 806                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 807                     );
 808     if (EFI_ERROR (Status)) {
 809       Private->Nii = NULL;
 810     }
 811
 812     //
 813     // Open Device Path Protocol to prepare for appending IP and URI node.
 814     //
 815     Status = gBS->OpenProtocol (
 816                     ControllerHandle,
 817                     &gEfiDevicePathProtocolGuid,
 818                     (VOID **) &Private->ParentDevicePath,
 819                     This->DriverBindingHandle,
 820                     ControllerHandle,
 821                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 822                     );
 823     if (EFI_ERROR (Status)) {
 824       goto ON_ERROR;
 825     }
 826
 827     //
 828     // Install a protocol with Caller Id Guid to the NIC, this is just to build the relationship between
 829     // NIC handle and the private data.
 830     //
 831     Status = gBS->InstallProtocolInterface (
 832                     &ControllerHandle,
 833                     &gEfiCallerIdGuid,
 834                     EFI_NATIVE_INTERFACE,
 835                     &Private->Id
 836                     );
 837     if (EFI_ERROR (Status)) {
 838       goto ON_ERROR;
 839     }
 840
 841   }
 842
 843   if (Private->Ip6Nic != NULL) {
 844     //
 845     // Already created before
 846     //
 847     return EFI_SUCCESS;
 848   }
 849
 850   Private->Ip6Nic = AllocateZeroPool (sizeof (HTTP_BOOT_VIRTUAL_NIC));
 851   if (Private->Ip6Nic == NULL) {
 852     return EFI_OUT_OF_RESOURCES;
 853   }
 854   Private->Ip6Nic->Private   = Private;
 855   Private->Ip6Nic->Signature = HTTP_BOOT_VIRTUAL_NIC_SIGNATURE;
 856
 857   //
 858   // Create Dhcp6 child and open Dhcp6 protocol
 859   Status = NetLibCreateServiceChild (
 860              ControllerHandle,
 861              This->DriverBindingHandle,
 862              &gEfiDhcp6ServiceBindingProtocolGuid,
 863              &Private->Dhcp6Child
 864              );
 865   if (EFI_ERROR (Status)) {
 866     goto ON_ERROR;
 867   }
 868
 869   Status = gBS->OpenProtocol (
 870                   Private->Dhcp6Child,
 871                   &gEfiDhcp6ProtocolGuid,
 872                   (VOID **) &Private->Dhcp6,
 873                   This->DriverBindingHandle,
 874                   ControllerHandle,
 875                   EFI_OPEN_PROTOCOL_BY_DRIVER
 876                   );
 877   if (EFI_ERROR (Status)) {
 878     goto ON_ERROR;
 879   }
 880
 881   //
 882   // Create Ip6 child and open Ip6 protocol for background ICMP packets.
 883   //
 884   Status = NetLibCreateServiceChild (
 885               ControllerHandle,
 886               This->DriverBindingHandle,
 887               &gEfiIp6ServiceBindingProtocolGuid,
 888               &Private->Ip6Child
 889               );
 890   if (EFI_ERROR (Status)) {
 891     goto ON_ERROR;
 892   }
 893
 894   Status = gBS->OpenProtocol (
 895                   Private->Ip6Child,
 896                   &gEfiIp6ProtocolGuid,
 897                   (VOID **) &Private->Ip6,
 898                   This->DriverBindingHandle,
 899                   ControllerHandle,
 900                   EFI_OPEN_PROTOCOL_BY_DRIVER
 901                   );
 902   if (EFI_ERROR (Status)) {
 903     goto ON_ERROR;
 904   }
 905
 906   //
 907   // Locate Ip6Config protocol, it's required to configure the default gateway address.
 908   //
 909   Status = gBS->OpenProtocol (
 910                   ControllerHandle,
 911                   &gEfiIp6ConfigProtocolGuid,
 912                   (VOID **) &Private->Ip6Config,
 913                   This->DriverBindingHandle,
 914                   ControllerHandle,
 915                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 916                   );
 917   if (EFI_ERROR (Status)) {
 918     goto ON_ERROR;
 919   }
 920
 921   //
 922   // Append IPv6 device path node.
 923   //
 924   Node = AllocateZeroPool (sizeof (IPv6_DEVICE_PATH));
 925   if (Node == NULL) {
 926     Status = EFI_OUT_OF_RESOURCES;
 927     goto ON_ERROR;
 928   }
 929   Node->Ipv6.Header.Type = MESSAGING_DEVICE_PATH;
 930   Node->Ipv6.Header.SubType = MSG_IPv6_DP;
 931   Node->Ipv6.PrefixLength = IP6_PREFIX_LENGTH;
 932   SetDevicePathNodeLength (Node, sizeof (IPv6_DEVICE_PATH));
 933   DevicePath = AppendDevicePathNode(Private->ParentDevicePath, (EFI_DEVICE_PATH*) Node);
 934   FreePool(Node);
 935   if (DevicePath == NULL) {
 936     Status = EFI_OUT_OF_RESOURCES;
 937     goto ON_ERROR;
 938   }
 939
 940   //
 941   // Append URI device path node.
 942   //
 943   Node = AllocateZeroPool (sizeof (EFI_DEVICE_PATH_PROTOCOL));
 944   if (Node == NULL) {
 945     Status = EFI_OUT_OF_RESOURCES;
 946     goto ON_ERROR;
 947   }
 948   Node->DevPath.Type = MESSAGING_DEVICE_PATH;
 949   Node->DevPath.SubType = MSG_URI_DP;
 950   SetDevicePathNodeLength (Node, sizeof (EFI_DEVICE_PATH_PROTOCOL));
 951   Private->Ip6Nic->DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
 952   FreePool (Node);
 953   FreePool (DevicePath);
 954   if (Private->Ip6Nic->DevicePath == NULL) {
 955     Status = EFI_OUT_OF_RESOURCES;
 956     goto ON_ERROR;
 957   }
 958
 959   //
 960   // Create a child handle for the HTTP boot and install DevPath and Load file protocol on it.
 961   //
 962   CopyMem (&Private->Ip6Nic->LoadFile, &gHttpBootDxeLoadFile, sizeof (Private->LoadFile));
 963   Status = gBS->InstallMultipleProtocolInterfaces (
 964                   &Private->Ip6Nic->Controller,
 965                   &gEfiLoadFileProtocolGuid,
 966                   &Private->Ip6Nic->LoadFile,
 967                   &gEfiDevicePathProtocolGuid,
 968                   Private->Ip6Nic->DevicePath,
 969                   NULL
 970                   );
 971   if (EFI_ERROR (Status)) {
 972     goto ON_ERROR;
 973   }
 974
 975   //
 976   // Open the Caller Id child to setup a parent-child relationship between
 977   // real NIC handle and the HTTP boot child handle.
 978   //
 979   Status = gBS->OpenProtocol (
 980                   ControllerHandle,
 981                   &gEfiCallerIdGuid,
 982                   (VOID **) &Id,
 983                   This->DriverBindingHandle,
 984                   Private->Ip6Nic->Controller,
 985                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 986                   );
 987   if (EFI_ERROR (Status)) {
 988     goto ON_ERROR;
 989   }
 990
 991   return EFI_SUCCESS;
 992
 993 ON_ERROR:
 994
 995  HttpBootDestroyIp6Children(This, Private);
 996  FreePool (Private);
 997
 998  return Status;
 999
1000 }
1001
1002 /**
1003   Stops a device controller or a bus controller.
1004
1005   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
1006   As a result, much of the error checking on the parameters to Stop() has been moved
1007   into this common boot service. It is legal to call Stop() from other locations,
1008   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
1009   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
1010      same driver's Start() function.
1011   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
1012      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
1013      Start() function, and the Start() function must have called OpenProtocol() on
1014      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
1015
1016   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
1017   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
1018                                 support a bus specific I/O protocol for the driver
1019                                 to use to stop the device.
1020   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
1021   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
1022                                 if NumberOfChildren is 0.
1023
1024   @retval EFI_SUCCESS           The device was stopped.
1025   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
1026
1027 **/
1028 EFI_STATUS
1029 EFIAPI
1030 HttpBootIp6DxeDriverBindingStop (
1031   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1032   IN EFI_HANDLE                   ControllerHandle,
1033   IN UINTN                        NumberOfChildren,
1034   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
1035   )
1036 {
1037   EFI_STATUS                      Status;
1038   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1039   HTTP_BOOT_PRIVATE_DATA          *Private;
1040   EFI_HANDLE                      NicHandle;
1041   UINT32                          *Id;
1042
1043   //
1044   // Try to get the Load File Protocol from the controller handle.
1045   //
1046   Status = gBS->OpenProtocol (
1047                   ControllerHandle,
1048                   &gEfiLoadFileProtocolGuid,
1049                   (VOID **) &LoadFile,
1050                   This->DriverBindingHandle,
1051                   ControllerHandle,
1052                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1053                   );
1054   if (EFI_ERROR (Status)) {
1055     //
1056     // If failed, try to find the NIC handle for this controller.
1057     //
1058     NicHandle = HttpBootGetNicByIp6Children (ControllerHandle);
1059     if (NicHandle == NULL) {
1060       return EFI_SUCCESS;
1061     }
1062
1063     //
1064     // Try to retrieve the private data by the Caller Id Guid.
1065     //
1066     Status = gBS->OpenProtocol (
1067                     NicHandle,
1068                     &gEfiCallerIdGuid,
1069                     (VOID **) &Id,
1070                     This->DriverBindingHandle,
1071                     ControllerHandle,
1072                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1073                     );
1074     if (EFI_ERROR (Status)) {
1075       return Status;
1076     }
1077     Private = HTTP_BOOT_PRIVATE_DATA_FROM_ID (Id);
1078   } else {
1079     Private = HTTP_BOOT_PRIVATE_DATA_FROM_LOADFILE (LoadFile);
1080     NicHandle = Private->Controller;
1081   }
1082
1083   //
1084   // Disable the HTTP boot function.
1085   //
1086   Status = HttpBootStop (Private);
1087   if (Status != EFI_SUCCESS && Status != EFI_NOT_STARTED) {
1088     return Status;
1089   }
1090
1091   //
1092   // Destory all child instance and uninstall protocol interface.
1093   //
1094   HttpBootDestroyIp6Children (This, Private);
1095
1096   if (Private->Ip4Nic == NULL && Private->Ip6Nic == NULL) {
1097     //
1098     // Release the cached data.
1099     //
1100     HttpBootFreeCacheList (Private);
1101
1102     gBS->UninstallProtocolInterface (
1103            NicHandle,
1104            &gEfiCallerIdGuid,
1105            &Private->Id
1106            );
1107     FreePool (Private);
1108
1109   }
1110
1111   return EFI_SUCCESS;
1112 }
1113 /**
1114   This is the declaration of an EFI image entry point. This entry point is
1115   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
1116   both device drivers and bus drivers.
1117
1118   @param[in]  ImageHandle       The firmware allocated handle for the UEFI image.
1119   @param[in]  SystemTable       A pointer to the EFI System Table.
1120
1121   @retval EFI_SUCCESS           The operation completed successfully.
1122   @retval Others                An unexpected error occurred.
1123
1124 **/
1125 EFI_STATUS
1126 EFIAPI
1127 HttpBootDxeDriverEntryPoint (
1128   IN EFI_HANDLE        ImageHandle,
1129   IN EFI_SYSTEM_TABLE  *SystemTable
1130   )
1131 {
1132   EFI_STATUS   Status;
1133   //
1134   // Install UEFI Driver Model protocol(s).
1135   //
1136   Status = EfiLibInstallDriverBindingComponentName2 (
1137              ImageHandle,
1138              SystemTable,
1139              &gHttpBootIp4DxeDriverBinding,
1140              ImageHandle,
1141              &gHttpBootDxeComponentName,
1142              &gHttpBootDxeComponentName2
1143              );
1144   if (EFI_ERROR (Status)) {
1145     return Status;
1146   }
1147
1148   Status = EfiLibInstallDriverBindingComponentName2 (
1149              ImageHandle,
1150              SystemTable,
1151              &gHttpBootIp6DxeDriverBinding,
1152              NULL,
1153              &gHttpBootDxeComponentName,
1154              &gHttpBootDxeComponentName2
1155              );
1156   if (EFI_ERROR (Status)) {
1157     gBS->UninstallMultipleProtocolInterfaces(
1158            ImageHandle,
1159            &gEfiDriverBindingProtocolGuid,
1160            &gHttpBootIp4DxeDriverBinding,
1161            &gEfiComponentName2ProtocolGuid,
1162            &gHttpBootDxeComponentName2,
1163            &gEfiComponentNameProtocolGuid,
1164            &gHttpBootDxeComponentName,
1165            NULL
1166            );
1167   }
1168   return Status;
1169 }
1170