NetworkPkg/HttpBootDxe/HttpBootDxe.h

   1 /** @file
   2   UEFI HTTP boot driver's private data structure and interfaces declaration.
   3
   4 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
   5 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   6 This program and the accompanying materials are licensed and made available under
   7 the terms and conditions of the BSD License that accompanies this distribution.
   8 The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php.
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #ifndef __EFI_HTTP_BOOT_DXE_H__
  17 #define __EFI_HTTP_BOOT_DXE_H__
  18
  19 #include <Uefi.h>
  20
  21 #include <IndustryStandard/Http11.h>
  22 #include <IndustryStandard/Dhcp.h>
  23
  24 //
  25 // Libraries
  26 //
  27 #include <Library/UefiBootServicesTableLib.h>
  28 #include <Library/UefiHiiServicesLib.h>
  29 #include <Library/UefiRuntimeServicesTableLib.h>
  30 #include <Library/MemoryAllocationLib.h>
  31 #include <Library/BaseLib.h>
  32 #include <Library/UefiLib.h>
  33 #include <Library/DevicePathLib.h>
  34 #include <Library/DebugLib.h>
  35 #include <Library/NetLib.h>
  36 #include <Library/HttpLib.h>
  37 #include <Library/HiiLib.h>
  38 #include <Library/PrintLib.h>
  39 #include <Library/DpcLib.h>
  40
  41 //
  42 // UEFI Driver Model Protocols
  43 //
  44 #include <Protocol/DriverBinding.h>
  45 #include <Protocol/ComponentName2.h>
  46 #include <Protocol/ComponentName.h>
  47
  48 //
  49 // Consumed Protocols
  50 //
  51 #include <Protocol/ServiceBinding.h>
  52 #include <Protocol/HiiConfigAccess.h>
  53 #include <Protocol/NetworkInterfaceIdentifier.h>
  54 #include <Protocol/Dhcp4.h>
  55 #include <Protocol/Dhcp6.h>
  56 #include <Protocol/Dns6.h>
  57 #include <Protocol/Http.h>
  58 #include <Protocol/Ip4Config2.h>
  59 #include <Protocol/Ip6Config.h>
  60 #include <Protocol/RamDisk.h>
  61 //
  62 // Produced Protocols
  63 //
  64 #include <Protocol/LoadFile.h>
  65 #include <Protocol/HttpBootCallback.h>
  66
  67 //
  68 // Consumed Guids
  69 //
  70 #include <Guid/HttpBootConfigHii.h>
  71
  72 //
  73 // Driver Version
  74 //
  75 #define HTTP_BOOT_DXE_VERSION  0xa
  76
  77 //
  78 // Standard Media Types defined in
  79 // http://www.iana.org/assignments/media-types
  80 //
  81 #define HTTP_CONTENT_TYPE_APP_EFI           "application/efi"
  82 #define HTTP_CONTENT_TYPE_APP_IMG           "application/vnd.efi-img"
  83 #define HTTP_CONTENT_TYPE_APP_ISO           "application/vnd.efi-iso"
  84
  85 //
  86 // Protocol instances
  87 //
  88 extern EFI_DRIVER_BINDING_PROTOCOL  gHttpBootDxeDriverBinding;
  89 extern EFI_COMPONENT_NAME2_PROTOCOL gHttpBootDxeComponentName2;
  90 extern EFI_COMPONENT_NAME_PROTOCOL  gHttpBootDxeComponentName;
  91
  92 //
  93 // Private data structure
  94 //
  95 typedef struct _HTTP_BOOT_PRIVATE_DATA      HTTP_BOOT_PRIVATE_DATA;
  96 typedef struct _HTTP_BOOT_VIRTUAL_NIC       HTTP_BOOT_VIRTUAL_NIC;
  97
  98 typedef enum  {
  99   ImageTypeEfi,
 100   ImageTypeVirtualCd,
 101   ImageTypeVirtualDisk,
 102   ImageTypeMax
 103 } HTTP_BOOT_IMAGE_TYPE;
 104
 105 //
 106 // Include files with internal function prototypes
 107 //
 108 #include "HttpBootComponentName.h"
 109 #include "HttpBootDhcp4.h"
 110 #include "HttpBootDhcp6.h"
 111 #include "HttpBootImpl.h"
 112 #include "HttpBootSupport.h"
 113 #include "HttpBootClient.h"
 114 #include "HttpBootConfig.h"
 115
 116 typedef union {
 117   HTTP_BOOT_DHCP4_PACKET_CACHE              Dhcp4;
 118   HTTP_BOOT_DHCP6_PACKET_CACHE              Dhcp6;
 119 } HTTP_BOOT_DHCP_PACKET_CACHE;
 120
 121 struct _HTTP_BOOT_VIRTUAL_NIC {
 122   UINT32                                    Signature;
 123   EFI_HANDLE                                Controller;
 124   EFI_HANDLE                                ImageHandle;
 125   EFI_LOAD_FILE_PROTOCOL                    LoadFile;
 126   EFI_DEVICE_PATH_PROTOCOL                  *DevicePath;
 127   HTTP_BOOT_PRIVATE_DATA                    *Private;
 128 };
 129
 130 #define HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_INFO(Callback) \
 131   CR ( \
 132   Callback, \
 133   HTTP_BOOT_PRIVATE_DATA, \
 134   CallbackInfo, \
 135   HTTP_BOOT_PRIVATE_DATA_SIGNATURE \
 136   )
 137
 138 #define HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_PROTOCOL(CallbackProtocol) \
 139     CR ( \
 140     CallbackProtocol, \
 141     HTTP_BOOT_PRIVATE_DATA, \
 142     LoadFileCallback, \
 143     HTTP_BOOT_PRIVATE_DATA_SIGNATURE \
 144     )
 145
 146 struct _HTTP_BOOT_PRIVATE_DATA {
 147   UINT32                                    Signature;
 148   EFI_HANDLE                                Controller;
 149
 150   HTTP_BOOT_VIRTUAL_NIC                     *Ip4Nic;
 151   HTTP_BOOT_VIRTUAL_NIC                     *Ip6Nic;
 152
 153   //
 154   // Cousumed children
 155   //
 156   EFI_HANDLE                                Ip6Child;
 157   EFI_HANDLE                                Dhcp4Child;
 158   EFI_HANDLE                                Dhcp6Child;
 159   HTTP_IO                                   HttpIo;
 160   BOOLEAN                                   HttpCreated;
 161
 162   //
 163   // Consumed protocol
 164   //
 165   EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *Nii;
 166   EFI_IP6_PROTOCOL                          *Ip6;
 167   EFI_IP4_CONFIG2_PROTOCOL                  *Ip4Config2;
 168   EFI_IP6_CONFIG_PROTOCOL                   *Ip6Config;
 169   EFI_DHCP4_PROTOCOL                        *Dhcp4;
 170   EFI_DHCP6_PROTOCOL                        *Dhcp6;
 171   EFI_DEVICE_PATH_PROTOCOL                  *ParentDevicePath;
 172
 173
 174   //
 175   // Produced protocol
 176   //
 177   EFI_LOAD_FILE_PROTOCOL                    LoadFile;
 178   EFI_DEVICE_PATH_PROTOCOL                  *DevicePath;
 179   UINT32                                    Id;
 180   EFI_HTTP_BOOT_CALLBACK_PROTOCOL           *HttpBootCallback;
 181   EFI_HTTP_BOOT_CALLBACK_PROTOCOL           LoadFileCallback;
 182
 183   //
 184   // Data for the default HTTP Boot callback protocol
 185   //
 186   UINT64                                    FileSize;
 187   UINT64                                    ReceivedSize;
 188   UINT32                                    Percentage;
 189
 190   //
 191   // HII callback info block
 192   //
 193   HTTP_BOOT_FORM_CALLBACK_INFO              CallbackInfo;
 194
 195   //
 196   // Mode data
 197   //
 198   BOOLEAN                                   UsingIpv6;
 199   BOOLEAN                                   Started;
 200   EFI_IP_ADDRESS                            StationIp;
 201   EFI_IP_ADDRESS                            SubnetMask;
 202   EFI_IP_ADDRESS                            GatewayIp;
 203   EFI_IP_ADDRESS                            ServerIp;
 204   UINT16                                    Port;
 205   UINT32                                    DnsServerCount;
 206   EFI_IP_ADDRESS                            *DnsServerIp;
 207
 208   //
 209   // The URI string attempt to download through HTTP, may point to
 210   // the memory in cached DHCP offer, or to the memory in FilePathUri.
 211   //
 212   CHAR8                                     *BootFileUri;
 213   VOID                                      *BootFileUriParser;
 214   UINTN                                     BootFileSize;
 215   BOOLEAN                                   NoGateway;
 216   HTTP_BOOT_IMAGE_TYPE                      ImageType;
 217
 218   //
 219   // URI string extracted from the input FilePath parameter.
 220   //
 221   CHAR8                                     *FilePathUri;
 222   VOID                                      *FilePathUriParser;
 223
 224   //
 225   // Cached HTTP data
 226   //
 227   LIST_ENTRY                                CacheList;
 228
 229   //
 230   // Cached DHCP offer
 231   //
 232   // OfferIndex records the index of DhcpOffer[] buffer, and OfferCount records the num of each type of offer.
 233   //
 234   // It supposed that
 235   //
 236   //   OfferNum:    8
 237   //   OfferBuffer: [ProxyNameUri, DhcpNameUri, DhcpIpUri, ProxyNameUri, ProxyIpUri, DhcpOnly, DhcpIpUri, DhcpNameUriDns]
 238   //   (OfferBuffer is 0-based.)
 239   //
 240   // And assume that (DhcpIpUri is the first priority actually.)
 241   //
 242   //   SelectIndex:     5
 243   //   SelectProxyType: HttpOfferTypeProxyIpUri
 244   //   (SelectIndex is 1-based, and 0 means no one is selected.)
 245   //
 246   // So it should be
 247   //
 248   //                 DhcpIpUri  DhcpNameUriDns  DhcpDns  DhcpOnly  ProxyNameUri  ProxyIpUri  DhcpNameUri
 249   //   OfferCount:  [       2,              1,       0,        1,            2,          1,            1]
 250   //
 251   //   OfferIndex: {[       2,              7,       0,        5,            0,         *4,            1]
 252   //                [       6,              0,       0,        0,            3,          0,            0]
 253   //                [       0,              0,       0,        0,            0,          0,            0]
 254   //                ...                                                                                 ]}
 255   //   (OfferIndex is 0-based.)
 256   //
 257   //
 258   UINT32                                    SelectIndex;
 259   UINT32                                    SelectProxyType;
 260   HTTP_BOOT_DHCP_PACKET_CACHE               OfferBuffer[HTTP_BOOT_OFFER_MAX_NUM];
 261   UINT32                                    OfferNum;
 262   UINT32                                    OfferCount[HttpOfferTypeMax];
 263   UINT32                                    OfferIndex[HttpOfferTypeMax][HTTP_BOOT_OFFER_MAX_NUM];
 264 };
 265
 266 #define HTTP_BOOT_PRIVATE_DATA_SIGNATURE          SIGNATURE_32 ('H', 'B', 'P', 'D')
 267 #define HTTP_BOOT_VIRTUAL_NIC_SIGNATURE           SIGNATURE_32 ('H', 'B', 'V', 'N')
 268 #define HTTP_BOOT_PRIVATE_DATA_FROM_LOADFILE(a)   CR (a, HTTP_BOOT_PRIVATE_DATA, LoadFile, HTTP_BOOT_PRIVATE_DATA_SIGNATURE)
 269 #define HTTP_BOOT_PRIVATE_DATA_FROM_ID(a)         CR (a, HTTP_BOOT_PRIVATE_DATA, Id, HTTP_BOOT_PRIVATE_DATA_SIGNATURE)
 270 #define HTTP_BOOT_VIRTUAL_NIC_FROM_LOADFILE(a)    CR (a, HTTP_BOOT_VIRTUAL_NIC, LoadFile, HTTP_BOOT_VIRTUAL_NIC_SIGNATURE)
 271 extern EFI_LOAD_FILE_PROTOCOL               gHttpBootDxeLoadFile;
 272
 273 /**
 274   Tests to see if this driver supports a given controller. If a child device is provided,
 275   it further tests to see if this driver supports creating a handle for the specified child device.
 276
 277   This function checks to see if the driver specified by This supports the device specified by
 278   ControllerHandle. Drivers will typically use the device path attached to
 279   ControllerHandle and/or the services from the bus I/O abstraction attached to
 280   ControllerHandle to determine if the driver supports ControllerHandle. This function
 281   may be called many times during platform initialization. In order to reduce boot times, the tests
 282   performed by this function must be very small, and take as little time as possible to execute. This
 283   function must not change the state of any hardware devices, and this function must be aware that the
 284   device specified by ControllerHandle may already be managed by the same driver or a
 285   different driver. This function must match its calls to AllocatePages() with FreePages(),
 286   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
 287   Because ControllerHandle may have been previously started by the same driver, if a protocol is
 288   already in the opened state, then it must not be closed with CloseProtocol(). This is required
 289   to guarantee the state of ControllerHandle is not modified by this function.
 290
 291   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 292   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 293                                    must support a protocol interface that supplies
 294                                    an I/O abstraction to the driver.
 295   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 296                                    parameter is ignored by device drivers, and is optional for bus
 297                                    drivers. For bus drivers, if this parameter is not NULL, then
 298                                    the bus driver must determine if the bus controller specified
 299                                    by ControllerHandle and the child controller specified
 300                                    by RemainingDevicePath are both supported by this
 301                                    bus driver.
 302
 303   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 304                                    RemainingDevicePath is supported by the driver specified by This.
 305   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 306                                    RemainingDevicePath is already being managed by the driver
 307                                    specified by This.
 308   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 309                                    RemainingDevicePath is already being managed by a different
 310                                    driver or an application that requires exclusive access.
 311                                    Currently not implemented.
 312   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 313                                    RemainingDevicePath is not supported by the driver specified by This.
 314 **/
 315 EFI_STATUS
 316 EFIAPI
 317 HttpBootIp4DxeDriverBindingSupported (
 318   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 319   IN EFI_HANDLE                   ControllerHandle,
 320   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 321   );
 322
 323 /**
 324   Starts a device controller or a bus controller.
 325
 326   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 327   As a result, much of the error checking on the parameters to Start() has been moved into this
 328   common boot service. It is legal to call Start() from other locations,
 329   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 330   1. ControllerHandle must be a valid EFI_HANDLE.
 331   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 332      EFI_DEVICE_PATH_PROTOCOL.
 333   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 334      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 335
 336   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 337   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 338                                    must support a protocol interface that supplies
 339                                    an I/O abstraction to the driver.
 340   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 341                                    parameter is ignored by device drivers, and is optional for bus
 342                                    drivers. For a bus driver, if this parameter is NULL, then handles
 343                                    for all the children of Controller are created by this driver.
 344                                    If this parameter is not NULL and the first Device Path Node is
 345                                    not the End of Device Path Node, then only the handle for the
 346                                    child device specified by the first Device Path Node of
 347                                    RemainingDevicePath is created by this driver.
 348                                    If the first Device Path Node of RemainingDevicePath is
 349                                    the End of Device Path Node, no child handle is created by this
 350                                    driver.
 351
 352   @retval EFI_SUCCESS              The device was started.
 353   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 354   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 355   @retval Others                   The driver failded to start the device.
 356
 357 **/
 358 EFI_STATUS
 359 EFIAPI
 360 HttpBootIp4DxeDriverBindingStart (
 361   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 362   IN EFI_HANDLE                   ControllerHandle,
 363   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 364   );
 365
 366 /**
 367   Stops a device controller or a bus controller.
 368
 369   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
 370   As a result, much of the error checking on the parameters to Stop() has been moved
 371   into this common boot service. It is legal to call Stop() from other locations,
 372   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 373   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
 374      same driver's Start() function.
 375   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
 376      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
 377      Start() function, and the Start() function must have called OpenProtocol() on
 378      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 379
 380   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 381   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
 382                                 support a bus specific I/O protocol for the driver
 383                                 to use to stop the device.
 384   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
 385   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
 386                                 if NumberOfChildren is 0.
 387
 388   @retval EFI_SUCCESS           The device was stopped.
 389   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 390
 391 **/
 392 EFI_STATUS
 393 EFIAPI
 394 HttpBootIp4DxeDriverBindingStop (
 395   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 396   IN EFI_HANDLE                   ControllerHandle,
 397   IN UINTN                        NumberOfChildren,
 398   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 399   );
 400
 401 /**
 402   Tests to see if this driver supports a given controller. If a child device is provided,
 403   it further tests to see if this driver supports creating a handle for the specified child device.
 404
 405   This function checks to see if the driver specified by This supports the device specified by
 406   ControllerHandle. Drivers will typically use the device path attached to
 407   ControllerHandle and/or the services from the bus I/O abstraction attached to
 408   ControllerHandle to determine if the driver supports ControllerHandle. This function
 409   may be called many times during platform initialization. In order to reduce boot times, the tests
 410   performed by this function must be very small, and take as little time as possible to execute. This
 411   function must not change the state of any hardware devices, and this function must be aware that the
 412   device specified by ControllerHandle may already be managed by the same driver or a
 413   different driver. This function must match its calls to AllocatePages() with FreePages(),
 414   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
 415   Because ControllerHandle may have been previously started by the same driver, if a protocol is
 416   already in the opened state, then it must not be closed with CloseProtocol(). This is required
 417   to guarantee the state of ControllerHandle is not modified by this function.
 418
 419   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 420   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 421                                    must support a protocol interface that supplies
 422                                    an I/O abstraction to the driver.
 423   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 424                                    parameter is ignored by device drivers, and is optional for bus
 425                                    drivers. For bus drivers, if this parameter is not NULL, then
 426                                    the bus driver must determine if the bus controller specified
 427                                    by ControllerHandle and the child controller specified
 428                                    by RemainingDevicePath are both supported by this
 429                                    bus driver.
 430
 431   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 432                                    RemainingDevicePath is supported by the driver specified by This.
 433   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 434                                    RemainingDevicePath is already being managed by the driver
 435                                    specified by This.
 436   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 437                                    RemainingDevicePath is already being managed by a different
 438                                    driver or an application that requires exclusive access.
 439                                    Currently not implemented.
 440   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 441                                    RemainingDevicePath is not supported by the driver specified by This.
 442 **/
 443 EFI_STATUS
 444 EFIAPI
 445 HttpBootIp6DxeDriverBindingSupported (
 446   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 447   IN EFI_HANDLE                   ControllerHandle,
 448   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 449   );
 450
 451 /**
 452   Starts a device controller or a bus controller.
 453
 454   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 455   As a result, much of the error checking on the parameters to Start() has been moved into this
 456   common boot service. It is legal to call Start() from other locations,
 457   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 458   1. ControllerHandle must be a valid EFI_HANDLE.
 459   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 460      EFI_DEVICE_PATH_PROTOCOL.
 461   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 462      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 463
 464   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 465   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 466                                    must support a protocol interface that supplies
 467                                    an I/O abstraction to the driver.
 468   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 469                                    parameter is ignored by device drivers, and is optional for bus
 470                                    drivers. For a bus driver, if this parameter is NULL, then handles
 471                                    for all the children of Controller are created by this driver.
 472                                    If this parameter is not NULL and the first Device Path Node is
 473                                    not the End of Device Path Node, then only the handle for the
 474                                    child device specified by the first Device Path Node of
 475                                    RemainingDevicePath is created by this driver.
 476                                    If the first Device Path Node of RemainingDevicePath is
 477                                    the End of Device Path Node, no child handle is created by this
 478                                    driver.
 479
 480   @retval EFI_SUCCESS              The device was started.
 481   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 482   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 483   @retval Others                   The driver failded to start the device.
 484
 485 **/
 486 EFI_STATUS
 487 EFIAPI
 488 HttpBootIp6DxeDriverBindingStart (
 489   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 490   IN EFI_HANDLE                   ControllerHandle,
 491   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 492   );
 493
 494 /**
 495   Stops a device controller or a bus controller.
 496
 497   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
 498   As a result, much of the error checking on the parameters to Stop() has been moved
 499   into this common boot service. It is legal to call Stop() from other locations,
 500   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 501   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
 502      same driver's Start() function.
 503   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
 504      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
 505      Start() function, and the Start() function must have called OpenProtocol() on
 506      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 507
 508   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 509   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
 510                                 support a bus specific I/O protocol for the driver
 511                                 to use to stop the device.
 512   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
 513   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
 514                                 if NumberOfChildren is 0.
 515
 516   @retval EFI_SUCCESS           The device was stopped.
 517   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 518
 519 **/
 520 EFI_STATUS
 521 EFIAPI
 522 HttpBootIp6DxeDriverBindingStop (
 523   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 524   IN EFI_HANDLE                   ControllerHandle,
 525   IN UINTN                        NumberOfChildren,
 526   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 527   );
 528 #endif