NetworkPkg/DnsDxe/DnsDriver.h

   1 /** @file
   2 The header files of the driver binding and service binding protocol for DnsDxe driver.
   3
   4 Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
   5 SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #ifndef _DNS_DRIVER_H_
  10 #define _DNS_DRIVER_H_
  11
  12 #include <Protocol/DriverBinding.h>
  13 #include <Protocol/ServiceBinding.h>
  14
  15 ///
  16 /// Dns service block
  17 ///
  18 typedef struct _DNS_DRIVER_DATA  DNS_DRIVER_DATA;
  19
  20 ///
  21 /// Dns service block
  22 ///
  23 typedef struct _DNS_SERVICE  DNS_SERVICE;
  24
  25 ///
  26 /// Dns instance block
  27 ///
  28 typedef struct _DNS_INSTANCE DNS_INSTANCE;
  29
  30 #define DNS_SERVICE_SIGNATURE    SIGNATURE_32 ('D', 'N', 'S', 'S')
  31
  32 #define DNS_INSTANCE_SIGNATURE   SIGNATURE_32 ('D', 'N', 'S', 'I')
  33
  34 struct _DNS_DRIVER_DATA {
  35   EFI_EVENT                     Timer; /// Ticking timer for DNS cache update.
  36
  37   LIST_ENTRY                    Dns4CacheList;
  38   LIST_ENTRY                    Dns4ServerList;
  39
  40   LIST_ENTRY                    Dns6CacheList;
  41   LIST_ENTRY                    Dns6ServerList;
  42 };
  43
  44 struct _DNS_SERVICE {
  45   UINT32                        Signature;
  46   EFI_SERVICE_BINDING_PROTOCOL  ServiceBinding;
  47
  48   UINT16                        Dns4ChildrenNum;
  49   LIST_ENTRY                    Dns4ChildrenList;
  50
  51   UINT16                        Dns6ChildrenNum;
  52   LIST_ENTRY                    Dns6ChildrenList;
  53
  54   EFI_HANDLE                    ControllerHandle;
  55   EFI_HANDLE                    ImageHandle;
  56
  57   EFI_EVENT                     TimerToGetMap;
  58
  59   EFI_EVENT                     Timer; /// Ticking timer for packet retransmission.
  60
  61   UINT8                         IpVersion;
  62   UDP_IO                        *ConnectUdp;
  63 };
  64
  65 struct _DNS_INSTANCE {
  66   UINT32                        Signature;
  67   LIST_ENTRY                    Link;
  68
  69   EFI_DNS4_PROTOCOL             Dns4;
  70   EFI_DNS6_PROTOCOL             Dns6;
  71
  72   INTN                          State;
  73   BOOLEAN                       InDestroy;
  74
  75   DNS_SERVICE                   *Service;
  76   EFI_HANDLE                    ChildHandle;
  77
  78   EFI_DNS4_CONFIG_DATA          Dns4CfgData;
  79   EFI_DNS6_CONFIG_DATA          Dns6CfgData;
  80
  81   EFI_IP_ADDRESS                SessionDnsServer;
  82
  83   NET_MAP                       Dns4TxTokens;
  84   NET_MAP                       Dns6TxTokens;
  85
  86   UDP_IO                        *UdpIo;
  87 };
  88
  89 typedef struct {
  90   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  91   UINTN                         NumberOfChildren;
  92   EFI_HANDLE                    *ChildHandleBuffer;
  93 } DNS_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT;
  94
  95 extern DNS_DRIVER_DATA          *mDriverData;
  96
  97 #define DNS_SERVICE_FROM_THIS(a)   \
  98   CR (a, DNS_SERVICE, ServiceBinding, DNS_SERVICE_SIGNATURE)
  99
 100 #define DNS_INSTANCE_FROM_THIS_PROTOCOL4(a)  \
 101   CR (a, DNS_INSTANCE, Dns4, DNS_INSTANCE_SIGNATURE)
 102
 103 #define DNS_INSTANCE_FROM_THIS_PROTOCOL6(a)  \
 104   CR (a, DNS_INSTANCE, Dns6, DNS_INSTANCE_SIGNATURE)
 105
 106
 107 /**
 108   Destroy the DNS instance and recycle the resources.
 109
 110   @param[in]  Instance        The pointer to the DNS instance.
 111
 112 **/
 113 VOID
 114 DnsDestroyInstance (
 115   IN DNS_INSTANCE         *Instance
 116   );
 117
 118 /**
 119   Create the DNS instance and initialize it.
 120
 121   @param[in]  Service              The pointer to the DNS service.
 122   @param[out] Instance             The pointer to the DNS instance.
 123
 124   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resources.
 125   @retval EFI_SUCCESS            The DNS instance is created.
 126
 127 **/
 128 EFI_STATUS
 129 DnsCreateInstance (
 130   IN  DNS_SERVICE         *Service,
 131   OUT DNS_INSTANCE        **Instance
 132   );
 133
 134 /**
 135   Callback function which provided by user to remove one node in NetDestroyLinkList process.
 136
 137   @param[in]    Entry           The entry to be removed.
 138   @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
 139
 140   @retval EFI_SUCCESS           The entry has been removed successfully.
 141   @retval Others                Fail to remove the entry.
 142
 143 **/
 144 EFI_STATUS
 145 EFIAPI
 146 DnsDestroyChildEntryInHandleBuffer (
 147   IN LIST_ENTRY         *Entry,
 148   IN VOID               *Context
 149   );
 150
 151 /**
 152   Config a NULL UDP that is used to keep the connection between UDP and DNS.
 153
 154   Just leave the Udp child unconfigured. When UDP is unloaded,
 155     DNS will be informed with DriverBinding Stop.
 156
 157   @param  UdpIo                  The UDP_IO to configure
 158   @param  Context                The opaque parameter to the callback
 159
 160   @retval EFI_SUCCESS            It always return EFI_SUCCESS directly.
 161
 162 **/
 163 EFI_STATUS
 164 EFIAPI
 165 DnsConfigNullUdp (
 166   IN UDP_IO                 *UdpIo,
 167   IN VOID                   *Context
 168   );
 169
 170 /**
 171   Release all the resource used the DNS service binding instance.
 172
 173   @param  DnsSb                The Dns service binding instance.
 174
 175 **/
 176 VOID
 177 DnsDestroyService (
 178   IN DNS_SERVICE     *DnsSb
 179   );
 180
 181 /**
 182   Create then initialize a Dns service binding instance.
 183
 184   @param  Controller             The controller to install the DNS service
 185                                  binding on
 186   @param  Image                  The driver binding image of the DNS driver
 187   @param  IpVersion              IpVersion for this service
 188   @param  Service                The variable to receive the created service
 189                                  binding instance.
 190
 191   @retval EFI_OUT_OF_RESOURCES   Failed to allocate resource to create the instance.
 192   @retval EFI_DEVICE_ERROR       Failed to create a NULL UDP port to keep
 193                                  connection  with UDP.
 194   @retval EFI_SUCCESS            The service instance is created for the
 195                                  controller.
 196
 197 **/
 198 EFI_STATUS
 199 DnsCreateService (
 200   IN     EFI_HANDLE            Controller,
 201   IN     EFI_HANDLE            Image,
 202   IN     UINT8                 IpVersion,
 203      OUT DNS_SERVICE           **Service
 204   );
 205
 206 /**
 207   Unloads an image.
 208
 209   @param  ImageHandle           Handle that identifies the image to be unloaded.
 210
 211   @retval EFI_SUCCESS           The image has been unloaded.
 212   @retval EFI_INVALID_PARAMETER ImageHandle is not a valid image handle.
 213
 214 **/
 215 EFI_STATUS
 216 EFIAPI
 217 DnsUnload (
 218   IN EFI_HANDLE  ImageHandle
 219   );
 220
 221 /**
 222   This is the declaration of an EFI image entry point. This entry point is
 223   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
 224   both device drivers and bus drivers.
 225
 226   @param  ImageHandle           The firmware allocated handle for the UEFI image.
 227   @param  SystemTable           A pointer to the EFI System Table.
 228
 229   @retval EFI_SUCCESS           The operation completed successfully.
 230   @retval Others                An unexpected error occurred.
 231 **/
 232 EFI_STATUS
 233 EFIAPI
 234 DnsDriverEntryPoint (
 235   IN EFI_HANDLE        ImageHandle,
 236   IN EFI_SYSTEM_TABLE  *SystemTable
 237   );
 238
 239 /**
 240   Tests to see if this driver supports a given controller. If a child device is provided,
 241   it further tests to see if this driver supports creating a handle for the specified child device.
 242
 243   This function checks to see if the driver specified by This supports the device specified by
 244   ControllerHandle. Drivers will typically use the device path attached to
 245   ControllerHandle and/or the services from the bus I/O abstraction attached to
 246   ControllerHandle to determine if the driver supports ControllerHandle. This function
 247   may be called many times during platform initialization. In order to reduce boot times, the tests
 248   performed by this function must be very small, and take as little time as possible to execute. This
 249   function must not change the state of any hardware devices, and this function must be aware that the
 250   device specified by ControllerHandle may already be managed by the same driver or a
 251   different driver. This function must match its calls to AllocatePages() with FreePages(),
 252   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
 253   Because ControllerHandle may have been previously started by the same driver, if a protocol is
 254   already in the opened state, then it must not be closed with CloseProtocol(). This is required
 255   to guarantee the state of ControllerHandle is not modified by this function.
 256
 257   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 258   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 259                                    must support a protocol interface that supplies
 260                                    an I/O abstraction to the driver.
 261   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 262                                    parameter is ignored by device drivers, and is optional for bus
 263                                    drivers. For bus drivers, if this parameter is not NULL, then
 264                                    the bus driver must determine if the bus controller specified
 265                                    by ControllerHandle and the child controller specified
 266                                    by RemainingDevicePath are both supported by this
 267                                    bus driver.
 268
 269   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 270                                    RemainingDevicePath is supported by the driver specified by This.
 271   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 272                                    RemainingDevicePath is already being managed by the driver
 273                                    specified by This.
 274   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 275                                    RemainingDevicePath is already being managed by a different
 276                                    driver or an application that requires exclusive access.
 277                                    Currently not implemented.
 278   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 279                                    RemainingDevicePath is not supported by the driver specified by This.
 280 **/
 281 EFI_STATUS
 282 EFIAPI
 283 Dns4DriverBindingSupported (
 284   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 285   IN EFI_HANDLE                   ControllerHandle,
 286   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 287   );
 288
 289 /**
 290   Starts a device controller or a bus controller.
 291
 292   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 293   As a result, much of the error checking on the parameters to Start() has been moved into this
 294   common boot service. It is legal to call Start() from other locations,
 295   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 296   1. ControllerHandle must be a valid EFI_HANDLE.
 297   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 298      EFI_DEVICE_PATH_PROTOCOL.
 299   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 300      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 301
 302   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 303   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 304                                    must support a protocol interface that supplies
 305                                    an I/O abstraction to the driver.
 306   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 307                                    parameter is ignored by device drivers, and is optional for bus
 308                                    drivers. For a bus driver, if this parameter is NULL, then handles
 309                                    for all the children of Controller are created by this driver.
 310                                    If this parameter is not NULL and the first Device Path Node is
 311                                    not the End of Device Path Node, then only the handle for the
 312                                    child device specified by the first Device Path Node of
 313                                    RemainingDevicePath is created by this driver.
 314                                    If the first Device Path Node of RemainingDevicePath is
 315                                    the End of Device Path Node, no child handle is created by this
 316                                    driver.
 317
 318   @retval EFI_SUCCESS              The device was started.
 319   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 320   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 321   @retval Others                   The driver failded to start the device.
 322
 323 **/
 324 EFI_STATUS
 325 EFIAPI
 326 Dns4DriverBindingStart (
 327   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 328   IN EFI_HANDLE                   ControllerHandle,
 329   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 330   );
 331
 332 /**
 333   Stops a device controller or a bus controller.
 334
 335   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
 336   As a result, much of the error checking on the parameters to Stop() has been moved
 337   into this common boot service. It is legal to call Stop() from other locations,
 338   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 339   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
 340      same driver's Start() function.
 341   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
 342      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
 343      Start() function, and the Start() function must have called OpenProtocol() on
 344      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 345
 346   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 347   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
 348                                 support a bus specific I/O protocol for the driver
 349                                 to use to stop the device.
 350   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
 351   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
 352                                 if NumberOfChildren is 0.
 353
 354   @retval EFI_SUCCESS           The device was stopped.
 355   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 356
 357 **/
 358 EFI_STATUS
 359 EFIAPI
 360 Dns4DriverBindingStop (
 361   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 362   IN EFI_HANDLE                   ControllerHandle,
 363   IN UINTN                        NumberOfChildren,
 364   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 365   );
 366
 367 /**
 368   Tests to see if this driver supports a given controller. If a child device is provided,
 369   it further tests to see if this driver supports creating a handle for the specified child device.
 370
 371   This function checks to see if the driver specified by This supports the device specified by
 372   ControllerHandle. Drivers will typically use the device path attached to
 373   ControllerHandle and/or the services from the bus I/O abstraction attached to
 374   ControllerHandle to determine if the driver supports ControllerHandle. This function
 375   may be called many times during platform initialization. In order to reduce boot times, the tests
 376   performed by this function must be very small, and take as little time as possible to execute. This
 377   function must not change the state of any hardware devices, and this function must be aware that the
 378   device specified by ControllerHandle may already be managed by the same driver or a
 379   different driver. This function must match its calls to AllocatePages() with FreePages(),
 380   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
 381   Because ControllerHandle may have been previously started by the same driver, if a protocol is
 382   already in the opened state, then it must not be closed with CloseProtocol(). This is required
 383   to guarantee the state of ControllerHandle is not modified by this function.
 384
 385   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 386   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 387                                    must support a protocol interface that supplies
 388                                    an I/O abstraction to the driver.
 389   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 390                                    parameter is ignored by device drivers, and is optional for bus
 391                                    drivers. For bus drivers, if this parameter is not NULL, then
 392                                    the bus driver must determine if the bus controller specified
 393                                    by ControllerHandle and the child controller specified
 394                                    by RemainingDevicePath are both supported by this
 395                                    bus driver.
 396
 397   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 398                                    RemainingDevicePath is supported by the driver specified by This.
 399   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 400                                    RemainingDevicePath is already being managed by the driver
 401                                    specified by This.
 402   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 403                                    RemainingDevicePath is already being managed by a different
 404                                    driver or an application that requires exclusive access.
 405                                    Currently not implemented.
 406   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 407                                    RemainingDevicePath is not supported by the driver specified by This.
 408 **/
 409 EFI_STATUS
 410 EFIAPI
 411 Dns6DriverBindingSupported (
 412   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 413   IN EFI_HANDLE                   ControllerHandle,
 414   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 415   );
 416
 417 /**
 418   Starts a device controller or a bus controller.
 419
 420   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 421   As a result, much of the error checking on the parameters to Start() has been moved into this
 422   common boot service. It is legal to call Start() from other locations,
 423   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 424   1. ControllerHandle must be a valid EFI_HANDLE.
 425   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 426      EFI_DEVICE_PATH_PROTOCOL.
 427   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 428      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 429
 430   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 431   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 432                                    must support a protocol interface that supplies
 433                                    an I/O abstraction to the driver.
 434   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 435                                    parameter is ignored by device drivers, and is optional for bus
 436                                    drivers. For a bus driver, if this parameter is NULL, then handles
 437                                    for all the children of Controller are created by this driver.
 438                                    If this parameter is not NULL and the first Device Path Node is
 439                                    not the End of Device Path Node, then only the handle for the
 440                                    child device specified by the first Device Path Node of
 441                                    RemainingDevicePath is created by this driver.
 442                                    If the first Device Path Node of RemainingDevicePath is
 443                                    the End of Device Path Node, no child handle is created by this
 444                                    driver.
 445
 446   @retval EFI_SUCCESS              The device was started.
 447   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 448   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 449   @retval Others                   The driver failded to start the device.
 450
 451 **/
 452 EFI_STATUS
 453 EFIAPI
 454 Dns6DriverBindingStart (
 455   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 456   IN EFI_HANDLE                   ControllerHandle,
 457   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 458   );
 459
 460 /**
 461   Stops a device controller or a bus controller.
 462
 463   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
 464   As a result, much of the error checking on the parameters to Stop() has been moved
 465   into this common boot service. It is legal to call Stop() from other locations,
 466   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 467   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
 468      same driver's Start() function.
 469   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
 470      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
 471      Start() function, and the Start() function must have called OpenProtocol() on
 472      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 473
 474   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 475   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
 476                                 support a bus specific I/O protocol for the driver
 477                                 to use to stop the device.
 478   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
 479   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
 480                                 if NumberOfChildren is 0.
 481
 482   @retval EFI_SUCCESS           The device was stopped.
 483   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 484
 485 **/
 486 EFI_STATUS
 487 EFIAPI
 488 Dns6DriverBindingStop (
 489   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 490   IN EFI_HANDLE                   ControllerHandle,
 491   IN UINTN                        NumberOfChildren,
 492   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 493   );
 494
 495 /**
 496   Creates a child handle and installs a protocol.
 497
 498   The CreateChild() function installs a protocol on ChildHandle.
 499   If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
 500   If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
 501
 502   @param[in] This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 503   @param[in] ChildHandle Pointer to the handle of the child to create. If it is NULL,
 504                          then a new handle is created. If it is a pointer to an existing UEFI handle,
 505                          then the protocol is added to the existing UEFI handle.
 506
 507   @retval EFI_SUCCES            The protocol was added to ChildHandle.
 508   @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
 509   @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to create
 510                                 the child
 511   @retval other                 The child handle was not created
 512
 513 **/
 514 EFI_STATUS
 515 EFIAPI
 516 Dns4ServiceBindingCreateChild (
 517   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 518   IN EFI_HANDLE                    *ChildHandle
 519   );
 520
 521 /**
 522   Destroys a child handle with a protocol installed on it.
 523
 524   The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
 525   that was installed by CreateChild() from ChildHandle. If the removed protocol is the
 526   last protocol on ChildHandle, then ChildHandle is destroyed.
 527
 528   @param[in] This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 529   @param[in] ChildHandle Handle of the child to destroy
 530
 531   @retval EFI_SUCCES            The protocol was removed from ChildHandle.
 532   @retval EFI_UNSUPPORTED       ChildHandle does not support the protocol that is being removed.
 533   @retval EFI_INVALID_PARAMETER Child handle is NULL.
 534   @retval EFI_ACCESS_DENIED     The protocol could not be removed from the ChildHandle
 535                                 because its services are being used.
 536   @retval other                 The child handle was not destroyed
 537
 538 **/
 539 EFI_STATUS
 540 EFIAPI
 541 Dns4ServiceBindingDestroyChild (
 542   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 543   IN EFI_HANDLE                    ChildHandle
 544   );
 545
 546 /**
 547   Creates a child handle and installs a protocol.
 548
 549   The CreateChild() function installs a protocol on ChildHandle.
 550   If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
 551   If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
 552
 553   @param[in] This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 554   @param[in] ChildHandle Pointer to the handle of the child to create. If it is NULL,
 555                          then a new handle is created. If it is a pointer to an existing UEFI handle,
 556                          then the protocol is added to the existing UEFI handle.
 557
 558   @retval EFI_SUCCES            The protocol was added to ChildHandle.
 559   @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
 560   @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to create
 561                                 the child
 562   @retval other                 The child handle was not created
 563
 564 **/
 565 EFI_STATUS
 566 EFIAPI
 567 Dns6ServiceBindingCreateChild (
 568   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 569   IN EFI_HANDLE                    *ChildHandle
 570   );
 571
 572 /**
 573   Destroys a child handle with a protocol installed on it.
 574
 575   The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
 576   that was installed by CreateChild() from ChildHandle. If the removed protocol is the
 577   last protocol on ChildHandle, then ChildHandle is destroyed.
 578
 579   @param[in] This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 580   @param[in] ChildHandle Handle of the child to destroy
 581
 582   @retval EFI_SUCCES            The protocol was removed from ChildHandle.
 583   @retval EFI_UNSUPPORTED       ChildHandle does not support the protocol that is being removed.
 584   @retval EFI_INVALID_PARAMETER Child handle is NULL.
 585   @retval EFI_ACCESS_DENIED     The protocol could not be removed from the ChildHandle
 586                                 because its services are being used.
 587   @retval other                 The child handle was not destroyed
 588
 589 **/
 590 EFI_STATUS
 591 EFIAPI
 592 Dns6ServiceBindingDestroyChild (
 593   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 594   IN EFI_HANDLE                    ChildHandle
 595   );
 596
 597
 598 #endif