NetworkPkg/Ip6Dxe/Ip6Driver.c

   1 /** @file
   2   The driver binding and service binding protocol for IP6 driver.
   3
   4   Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  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 #include "Ip6Impl.h"
  17
  18 EFI_DRIVER_BINDING_PROTOCOL gIp6DriverBinding = {
  19   Ip6DriverBindingSupported,
  20   Ip6DriverBindingStart,
  21   Ip6DriverBindingStop,
  22   0xa,
  23   NULL,
  24   NULL
  25 };
  26
  27 /**
  28   This is the declaration of an EFI image entry point. This entry point is
  29   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
  30   both device drivers and bus drivers.
  31
  32   The entry point for IP6 driver which installs the driver
  33   binding and component name protocol on its image.
  34
  35   @param[in]  ImageHandle           The firmware allocated handle for the UEFI image.
  36   @param[in]  SystemTable           A pointer to the EFI System Table.
  37
  38   @retval EFI_SUCCESS           The operation completed successfully.
  39   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  40
  41 **/
  42 EFI_STATUS
  43 EFIAPI
  44 Ip6DriverEntryPoint (
  45   IN EFI_HANDLE             ImageHandle,
  46   IN EFI_SYSTEM_TABLE       *SystemTable
  47   )
  48 {
  49   return EfiLibInstallDriverBindingComponentName2 (
  50            ImageHandle,
  51            SystemTable,
  52            &gIp6DriverBinding,
  53            ImageHandle,
  54            &gIp6ComponentName,
  55            &gIp6ComponentName2
  56            );
  57 }
  58
  59 /**
  60   Test to see if this driver supports ControllerHandle.
  61
  62   @param[in]  This                   Protocol instance pointer.
  63   @param[in]  ControllerHandle       Handle of device to test.
  64   @param[in]  RemainingDevicePath    Optional parameter use to pick a specific child
  65                                      device to start.
  66
  67   @retval EFI_SUCCESS                This driver supports this device.
  68   @retval EFI_ALREADY_STARTED        This driver is already running on this device.
  69   @retval other                      This driver does not support this device.
  70
  71 **/
  72 EFI_STATUS
  73 EFIAPI
  74 Ip6DriverBindingSupported (
  75   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  76   IN EFI_HANDLE                   ControllerHandle,
  77   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  78   )
  79 {
  80   //
  81   // Test for the MNP service binding Protocol
  82   //
  83   return gBS->OpenProtocol (
  84                 ControllerHandle,
  85                 &gEfiManagedNetworkServiceBindingProtocolGuid,
  86                 NULL,
  87                 This->DriverBindingHandle,
  88                 ControllerHandle,
  89                 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
  90                 );
  91 }
  92
  93 /**
  94   Clean up an IP6 service binding instance. It releases all
  95   the resource allocated by the instance. The instance may be
  96   partly initialized, or partly destroyed. If a resource is
  97   destroyed, it is marked as that in case the destroy failed and
  98   being called again later.
  99
 100   @param[in]  IpSb               The IP6 service binding instance to clean up.
 101
 102   @retval EFI_SUCCESS            The resource used by the instance are cleaned up.
 103   @retval Others                 Failed to clean up some of the resources.
 104
 105 **/
 106 EFI_STATUS
 107 Ip6CleanService (
 108   IN IP6_SERVICE            *IpSb
 109   )
 110 {
 111   EFI_STATUS                Status;
 112   EFI_IPv6_ADDRESS          AllNodes;
 113   IP6_NEIGHBOR_ENTRY        *NeighborCache;
 114
 115   Ip6ConfigCleanInstance (&IpSb->Ip6ConfigInstance);
 116
 117   if (!IpSb->LinkLocalDadFail) {
 118     //
 119     // Leave link-scope all-nodes multicast address (FF02::1)
 120     //
 121     Ip6SetToAllNodeMulticast (FALSE, IP6_LINK_LOCAL_SCOPE, &AllNodes);
 122
 123     Status = Ip6LeaveGroup (IpSb, &AllNodes);
 124     if (EFI_ERROR (Status)) {
 125       return Status;
 126     }
 127   }
 128
 129   if (IpSb->DefaultInterface != NULL) {
 130     Ip6CleanInterface (IpSb->DefaultInterface, NULL);
 131     IpSb->DefaultInterface = NULL;
 132   }
 133
 134   Ip6CleanDefaultRouterList (IpSb);
 135
 136   Ip6CleanPrefixListTable (IpSb, &IpSb->OnlinkPrefix);
 137   Ip6CleanPrefixListTable (IpSb, &IpSb->AutonomousPrefix);
 138
 139   if (IpSb->RouteTable != NULL) {
 140     Ip6CleanRouteTable (IpSb->RouteTable);
 141     IpSb->RouteTable = NULL;
 142   }
 143
 144   if (IpSb->InterfaceId != NULL) {
 145     FreePool (IpSb->InterfaceId);
 146   }
 147
 148   IpSb->InterfaceId = NULL;
 149
 150   Ip6CleanAssembleTable (&IpSb->Assemble);
 151
 152   if (IpSb->MnpChildHandle != NULL) {
 153     if (IpSb->Mnp != NULL) {
 154       IpSb->Mnp->Cancel (IpSb->Mnp, NULL);
 155       IpSb->Mnp->Configure (IpSb->Mnp, NULL);
 156       gBS->CloseProtocol (
 157             IpSb->MnpChildHandle,
 158             &gEfiManagedNetworkProtocolGuid,
 159             IpSb->Image,
 160             IpSb->Controller
 161             );
 162
 163       IpSb->Mnp = NULL;
 164     }
 165
 166     NetLibDestroyServiceChild (
 167       IpSb->Controller,
 168       IpSb->Image,
 169       &gEfiManagedNetworkServiceBindingProtocolGuid,
 170       IpSb->MnpChildHandle
 171       );
 172
 173     IpSb->MnpChildHandle = NULL;
 174   }
 175
 176   if (IpSb->RecvRequest.MnpToken.Event != NULL) {
 177     gBS->CloseEvent (IpSb->RecvRequest.MnpToken.Event);
 178   }
 179
 180   if (IpSb->Timer != NULL) {
 181     gBS->SetTimer (IpSb->Timer, TimerCancel, 0);
 182     gBS->CloseEvent (IpSb->Timer);
 183
 184     IpSb->Timer = NULL;
 185   }
 186
 187   if (IpSb->FasterTimer != NULL) {
 188     gBS->SetTimer (IpSb->FasterTimer, TimerCancel, 0);
 189     gBS->CloseEvent (IpSb->FasterTimer);
 190
 191     IpSb->FasterTimer = NULL;
 192   }
 193   //
 194   // Free the Neighbor Discovery resources
 195   //
 196   while (!IsListEmpty (&IpSb->NeighborTable)) {
 197     NeighborCache = NET_LIST_HEAD (&IpSb->NeighborTable, IP6_NEIGHBOR_ENTRY, Link);
 198     Ip6FreeNeighborEntry (IpSb, NeighborCache, FALSE, TRUE, EFI_SUCCESS, NULL, NULL);
 199   }
 200
 201   return EFI_SUCCESS;
 202 }
 203
 204 /**
 205   Create a new IP6 driver service binding protocol.
 206
 207   @param[in]  Controller         The controller that has MNP service binding
 208                                  installed.
 209   @param[in]  ImageHandle        The IP6 driver's image handle.
 210   @param[out]  Service           The variable to receive the newly created IP6
 211                                  service.
 212
 213   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resources.
 214   @retval EFI_SUCCESS            A new IP6 service binding private is created.
 215
 216 **/
 217 EFI_STATUS
 218 Ip6CreateService (
 219   IN  EFI_HANDLE            Controller,
 220   IN  EFI_HANDLE            ImageHandle,
 221   OUT IP6_SERVICE           **Service
 222   )
 223 {
 224   IP6_SERVICE                           *IpSb;
 225   EFI_STATUS                            Status;
 226   EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
 227   EFI_MANAGED_NETWORK_CONFIG_DATA       *Config;
 228   IP6_CONFIG_DATA_ITEM                  *DataItem;
 229
 230   ASSERT (Service != NULL);
 231
 232   *Service = NULL;
 233
 234   //
 235   // allocate a service private data then initialize all the filed to
 236   // empty resources, so if any thing goes wrong when allocating
 237   // resources, Ip6CleanService can be called to clean it up.
 238   //
 239   IpSb = AllocateZeroPool (sizeof (IP6_SERVICE));
 240
 241   if (IpSb == NULL) {
 242     return EFI_OUT_OF_RESOURCES;
 243   }
 244
 245   IpSb->Signature                   = IP6_SERVICE_SIGNATURE;
 246   IpSb->ServiceBinding.CreateChild  = Ip6ServiceBindingCreateChild;
 247   IpSb->ServiceBinding.DestroyChild = Ip6ServiceBindingDestroyChild;
 248   IpSb->State                       = IP6_SERVICE_UNSTARTED;
 249
 250   IpSb->NumChildren                 = 0;
 251   InitializeListHead (&IpSb->Children);
 252
 253   InitializeListHead (&IpSb->Interfaces);
 254   IpSb->DefaultInterface            = NULL;
 255   IpSb->RouteTable                  = NULL;
 256
 257   IpSb->RecvRequest.Signature       = IP6_LINK_RX_SIGNATURE;
 258   IpSb->RecvRequest.CallBack        = NULL;
 259   IpSb->RecvRequest.Context         = NULL;
 260   MnpToken                          = &IpSb->RecvRequest.MnpToken;
 261   MnpToken->Event                   = NULL;
 262   MnpToken->Status                  = EFI_NOT_READY;
 263   MnpToken->Packet.RxData           = NULL;
 264
 265   Ip6CreateAssembleTable (&IpSb->Assemble);
 266
 267   IpSb->MldCtrl.Mldv1QuerySeen      = 0;
 268   InitializeListHead (&IpSb->MldCtrl.Groups);
 269
 270   ZeroMem (&IpSb->LinkLocalAddr, sizeof (EFI_IPv6_ADDRESS));
 271   IpSb->LinkLocalOk                 = FALSE;
 272   IpSb->LinkLocalDadFail            = FALSE;
 273   IpSb->Dhcp6NeedStart              = FALSE;
 274   IpSb->Dhcp6NeedInfoRequest        = FALSE;
 275
 276   IpSb->CurHopLimit                 = IP6_HOP_LIMIT;
 277   IpSb->LinkMTU                     = IP6_MIN_LINK_MTU;
 278   IpSb->BaseReachableTime           = IP6_REACHABLE_TIME;
 279   Ip6UpdateReachableTime (IpSb);
 280   //
 281   // RFC4861 RETRANS_TIMER: 1,000 milliseconds
 282   //
 283   IpSb->RetransTimer                = IP6_RETRANS_TIMER;
 284
 285   IpSb->RoundRobin                  = 0;
 286
 287   InitializeListHead (&IpSb->NeighborTable);
 288   InitializeListHead (&IpSb->DefaultRouterList);
 289   InitializeListHead (&IpSb->OnlinkPrefix);
 290   InitializeListHead (&IpSb->AutonomousPrefix);
 291
 292   IpSb->InterfaceIdLen              = IP6_IF_ID_LEN;
 293   IpSb->InterfaceId                 = NULL;
 294
 295   IpSb->RouterAdvertiseReceived     = FALSE;
 296   IpSb->SolicitTimer                = IP6_MAX_RTR_SOLICITATIONS;
 297   IpSb->Ticks                       = 0;
 298
 299   IpSb->Image                       = ImageHandle;
 300   IpSb->Controller                  = Controller;
 301
 302   IpSb->MnpChildHandle              = NULL;
 303   IpSb->Mnp                         = NULL;
 304
 305   Config                            = &IpSb->MnpConfigData;
 306   Config->ReceivedQueueTimeoutValue = 0;
 307   Config->TransmitQueueTimeoutValue = 0;
 308   Config->ProtocolTypeFilter        = IP6_ETHER_PROTO;
 309   Config->EnableUnicastReceive      = TRUE;
 310   Config->EnableMulticastReceive    = TRUE;
 311   Config->EnableBroadcastReceive    = TRUE;
 312   Config->EnablePromiscuousReceive  = FALSE;
 313   Config->FlushQueuesOnReset        = TRUE;
 314   Config->EnableReceiveTimestamps   = FALSE;
 315   Config->DisableBackgroundPolling  = FALSE;
 316
 317   ZeroMem (&IpSb->SnpMode, sizeof (EFI_SIMPLE_NETWORK_MODE));
 318
 319   IpSb->Timer                       = NULL;
 320   IpSb->FasterTimer                 = NULL;
 321
 322   ZeroMem (&IpSb->Ip6ConfigInstance, sizeof (IP6_CONFIG_INSTANCE));
 323
 324   IpSb->MacString                   = NULL;
 325
 326   //
 327   // Create various resources. First create the route table, timer
 328   // event, MNP token event and MNP child.
 329   //
 330
 331   IpSb->RouteTable = Ip6CreateRouteTable ();
 332   if (IpSb->RouteTable == NULL) {
 333     Status = EFI_OUT_OF_RESOURCES;
 334     goto ON_ERROR;
 335   }
 336
 337   Status = gBS->CreateEvent (
 338                   EVT_NOTIFY_SIGNAL | EVT_TIMER,
 339                   TPL_CALLBACK,
 340                   Ip6TimerTicking,
 341                   IpSb,
 342                   &IpSb->Timer
 343                   );
 344   if (EFI_ERROR (Status)) {
 345     goto ON_ERROR;
 346   }
 347
 348   Status = gBS->CreateEvent (
 349                   EVT_NOTIFY_SIGNAL | EVT_TIMER,
 350                   TPL_CALLBACK,
 351                   Ip6NdFasterTimerTicking,
 352                   IpSb,
 353                   &IpSb->FasterTimer
 354                   );
 355   if (EFI_ERROR (Status)) {
 356     goto ON_ERROR;
 357   }
 358
 359   Status = NetLibCreateServiceChild (
 360              Controller,
 361              ImageHandle,
 362              &gEfiManagedNetworkServiceBindingProtocolGuid,
 363              &IpSb->MnpChildHandle
 364              );
 365   if (EFI_ERROR (Status)) {
 366     goto ON_ERROR;
 367   }
 368
 369   Status = gBS->OpenProtocol (
 370                   IpSb->MnpChildHandle,
 371                   &gEfiManagedNetworkProtocolGuid,
 372                   (VOID **) (&IpSb->Mnp),
 373                   ImageHandle,
 374                   Controller,
 375                   EFI_OPEN_PROTOCOL_BY_DRIVER
 376                   );
 377   if (EFI_ERROR (Status)) {
 378     goto ON_ERROR;
 379   }
 380
 381   Status = Ip6ServiceConfigMnp (IpSb, TRUE);
 382   if (EFI_ERROR (Status)) {
 383     goto ON_ERROR;
 384   }
 385
 386   Status = IpSb->Mnp->GetModeData (IpSb->Mnp, NULL, &IpSb->SnpMode);
 387   if (EFI_ERROR (Status)) {
 388     goto ON_ERROR;
 389   }
 390
 391   IpSb->MaxPacketSize = IP6_MIN_LINK_MTU - sizeof (EFI_IP6_HEADER);
 392   if (NetLibGetVlanId (IpSb->Controller) != 0) {
 393     //
 394     // This is a VLAN device, reduce MTU by VLAN tag length
 395     //
 396     IpSb->MaxPacketSize -= NET_VLAN_TAG_LEN;
 397   }
 398   IpSb->OldMaxPacketSize = IpSb->MaxPacketSize;
 399
 400   //
 401   // Currently only ETHERNET is supported in IPv6 stack, since
 402   // link local address requires an IEEE 802 48-bit MACs for
 403   // EUI-64 format interface identifier mapping.
 404   //
 405   if (IpSb->SnpMode.IfType != NET_IFTYPE_ETHERNET) {
 406     Status = EFI_UNSUPPORTED;
 407     goto ON_ERROR;
 408   }
 409
 410   Status = Ip6InitMld (IpSb);
 411   if (EFI_ERROR (Status)) {
 412     goto ON_ERROR;
 413   }
 414
 415   Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &IpSb->MacString);
 416   if (EFI_ERROR (Status)) {
 417     goto ON_ERROR;
 418   }
 419
 420   Status = Ip6ConfigInitInstance (&IpSb->Ip6ConfigInstance);
 421   if (EFI_ERROR (Status)) {
 422     goto ON_ERROR;
 423   }
 424
 425   IpSb->DefaultInterface = Ip6CreateInterface (IpSb, TRUE);
 426   if (IpSb->DefaultInterface == NULL) {
 427     Status = EFI_DEVICE_ERROR;
 428     goto ON_ERROR;
 429   }
 430
 431   Status = gBS->CreateEvent (
 432                   EVT_NOTIFY_SIGNAL,
 433                   TPL_NOTIFY,
 434                   Ip6OnFrameReceived,
 435                   &IpSb->RecvRequest,
 436                   &MnpToken->Event
 437                   );
 438   if (EFI_ERROR (Status)) {
 439     goto ON_ERROR;
 440   }
 441
 442   //
 443   // If there is any manual address, set it.
 444   //
 445   DataItem = &IpSb->Ip6ConfigInstance.DataItem[Ip6ConfigDataTypeManualAddress];
 446   if (DataItem->Data.Ptr != NULL) {
 447     DataItem->SetData (
 448                 &IpSb->Ip6ConfigInstance,
 449                 DataItem->DataSize,
 450                 DataItem->Data.Ptr
 451                 );
 452   }
 453
 454   //
 455   // If there is any gateway address, set it.
 456   //
 457   DataItem = &IpSb->Ip6ConfigInstance.DataItem[Ip6ConfigDataTypeGateway];
 458   if (DataItem->Data.Ptr != NULL) {
 459     DataItem->SetData (
 460                 &IpSb->Ip6ConfigInstance,
 461                 DataItem->DataSize,
 462                 DataItem->Data.Ptr
 463                 );
 464   }
 465
 466   InsertHeadList (&IpSb->Interfaces, &IpSb->DefaultInterface->Link);
 467
 468   *Service = IpSb;
 469   return EFI_SUCCESS;
 470
 471 ON_ERROR:
 472   Ip6CleanService (IpSb);
 473   FreePool (IpSb);
 474   return Status;
 475 }
 476
 477
 478 /**
 479   Start this driver on ControllerHandle.
 480
 481   @param[in]  This                Protocol instance pointer.
 482   @param[in]  ControllerHandle    Handle of device to bind driver to.
 483   @param[in]  RemainingDevicePath Optional parameter used to pick a specific child
 484                                   device to start.
 485
 486   @retval EFI_SUCCES              This driver is added to ControllerHandle.
 487   @retval EFI_ALREADY_STARTED     This driver is already running on ControllerHandle.
 488   @retval other                   This driver does not support this device.
 489
 490 **/
 491 EFI_STATUS
 492 EFIAPI
 493 Ip6DriverBindingStart (
 494   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 495   IN EFI_HANDLE                   ControllerHandle,
 496   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 497   )
 498 {
 499   IP6_SERVICE               *IpSb;
 500   EFI_STATUS                Status;
 501
 502   //
 503   // Test for the Ip6 service binding protocol
 504   //
 505   Status = gBS->OpenProtocol (
 506                   ControllerHandle,
 507                   &gEfiIp6ServiceBindingProtocolGuid,
 508                   NULL,
 509                   This->DriverBindingHandle,
 510                   ControllerHandle,
 511                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 512                   );
 513
 514   if (Status == EFI_SUCCESS) {
 515     return EFI_ALREADY_STARTED;
 516   }
 517
 518   Status = Ip6CreateService (ControllerHandle, This->DriverBindingHandle, &IpSb);
 519
 520   if (EFI_ERROR (Status)) {
 521     return Status;
 522   }
 523
 524   ASSERT (IpSb != NULL);
 525
 526   //
 527   // Install the Ip6ServiceBinding Protocol onto ControlerHandle
 528   //
 529   Status = gBS->InstallMultipleProtocolInterfaces (
 530                   &ControllerHandle,
 531                   &gEfiIp6ServiceBindingProtocolGuid,
 532                   &IpSb->ServiceBinding,
 533                   &gEfiIp6ConfigProtocolGuid,
 534                   &IpSb->Ip6ConfigInstance.Ip6Config,
 535                   NULL
 536                   );
 537
 538   if (!EFI_ERROR (Status)) {
 539     //
 540     // ready to go: start the receiving and timer
 541     //
 542     Status = Ip6ReceiveFrame (Ip6AcceptFrame, IpSb);
 543     if (EFI_ERROR (Status)) {
 544       goto ON_ERROR;
 545     }
 546
 547     //
 548     // The timer expires every 100 (IP6_TIMER_INTERVAL_IN_MS) milliseconds.
 549     //
 550     Status = gBS->SetTimer (
 551                     IpSb->FasterTimer,
 552                     TimerPeriodic,
 553                     TICKS_PER_MS * IP6_TIMER_INTERVAL_IN_MS
 554                     );
 555     if (EFI_ERROR (Status)) {
 556       goto ON_ERROR;
 557     }
 558
 559     //
 560     // The timer expires every 1000 (IP6_ONE_SECOND_IN_MS) milliseconds.
 561     //
 562     Status = gBS->SetTimer (
 563                     IpSb->Timer,
 564                     TimerPeriodic,
 565                     TICKS_PER_MS * IP6_ONE_SECOND_IN_MS
 566                     );
 567     if (EFI_ERROR (Status)) {
 568       goto ON_ERROR;
 569     }
 570
 571     //
 572     // Initialize the IP6 ID
 573     //
 574     mIp6Id = NET_RANDOM (NetRandomInitSeed ());
 575
 576     return EFI_SUCCESS;
 577   }
 578
 579 ON_ERROR:
 580   Ip6CleanService (IpSb);
 581   FreePool (IpSb);
 582   return Status;
 583 }
 584
 585 /**
 586   Callback function which provided by user to remove one node in NetDestroyLinkList process.
 587
 588   @param[in]    Entry           The entry to be removed.
 589   @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
 590
 591   @retval EFI_SUCCESS           The entry has been removed successfully.
 592   @retval Others                Fail to remove the entry.
 593
 594 **/
 595 EFI_STATUS
 596 EFIAPI
 597 Ip6DestroyChildEntryInHandleBuffer (
 598   IN LIST_ENTRY         *Entry,
 599   IN VOID               *Context
 600   )
 601 {
 602   IP6_PROTOCOL                  *IpInstance;
 603   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
 604   UINTN                         NumberOfChildren;
 605   EFI_HANDLE                    *ChildHandleBuffer;
 606
 607   if (Entry == NULL || Context == NULL) {
 608     return EFI_INVALID_PARAMETER;
 609   }
 610
 611   IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP6_PROTOCOL, Link, IP6_PROTOCOL_SIGNATURE);
 612   ServiceBinding    = ((IP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
 613   NumberOfChildren  = ((IP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
 614   ChildHandleBuffer = ((IP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
 615
 616   if (!NetIsInHandleBuffer (IpInstance->Handle, NumberOfChildren, ChildHandleBuffer)) {
 617     return EFI_SUCCESS;
 618   }
 619
 620   return ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
 621 }
 622
 623 /**
 624   Stop this driver on ControllerHandle.
 625
 626   @param[in]  This               Protocol instance pointer.
 627   @param[in]  ControllerHandle   Handle of device to stop driver on.
 628   @param[in]  NumberOfChildren   Number of Handles in ChildHandleBuffer. If number
 629                                  of children is zero, stop the entire  bus driver.
 630   @param[in]  ChildHandleBuffer  An array of child handles to be freed. May be NULL
 631                                  if NumberOfChildren is 0.
 632
 633   @retval EFI_SUCCESS           The device was stopped.
 634   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 635
 636 **/
 637 EFI_STATUS
 638 EFIAPI
 639 Ip6DriverBindingStop (
 640   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 641   IN  EFI_HANDLE                   ControllerHandle,
 642   IN  UINTN                        NumberOfChildren,
 643   IN  EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 644   )
 645 {
 646   EFI_SERVICE_BINDING_PROTOCOL            *ServiceBinding;
 647   IP6_SERVICE                             *IpSb;
 648   EFI_HANDLE                              NicHandle;
 649   EFI_STATUS                              Status;
 650   LIST_ENTRY                              *List;
 651   INTN                                    State;
 652   BOOLEAN                                 IsDhcp6;
 653   IP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
 654
 655   IsDhcp6   = FALSE;
 656   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiManagedNetworkProtocolGuid);
 657   if (NicHandle == NULL) {
 658     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp6ProtocolGuid);
 659     if (NicHandle != NULL) {
 660       IsDhcp6 = TRUE;
 661     } else {
 662       return EFI_SUCCESS;
 663     }
 664   }
 665
 666   Status = gBS->OpenProtocol (
 667                   NicHandle,
 668                   &gEfiIp6ServiceBindingProtocolGuid,
 669                   (VOID **) &ServiceBinding,
 670                   This->DriverBindingHandle,
 671                   NicHandle,
 672                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 673                   );
 674   if (EFI_ERROR (Status)) {
 675     return EFI_DEVICE_ERROR;
 676   }
 677
 678   IpSb = IP6_SERVICE_FROM_PROTOCOL (ServiceBinding);
 679
 680   if (IsDhcp6) {
 681     Status = Ip6ConfigDestroyDhcp6 (&IpSb->Ip6ConfigInstance);
 682     gBS->CloseEvent (IpSb->Ip6ConfigInstance.Dhcp6Event);
 683     IpSb->Ip6ConfigInstance.Dhcp6Event = NULL;
 684   } else if (NumberOfChildren != 0) {
 685     //
 686     // NumberOfChildren is not zero, destroy the IP6 children instances in ChildHandleBuffer.
 687     //
 688     List = &IpSb->Children;
 689     Context.ServiceBinding    = ServiceBinding;
 690     Context.NumberOfChildren  = NumberOfChildren;
 691     Context.ChildHandleBuffer = ChildHandleBuffer;
 692     Status = NetDestroyLinkList (
 693                List,
 694                Ip6DestroyChildEntryInHandleBuffer,
 695                &Context,
 696                NULL
 697                );
 698   } else if (IsListEmpty (&IpSb->Children)) {
 699     State           = IpSb->State;
 700     IpSb->State     = IP6_SERVICE_DESTROY;
 701
 702     Status = Ip6CleanService (IpSb);
 703     if (EFI_ERROR (Status)) {
 704       IpSb->State = State;
 705       goto Exit;
 706     }
 707
 708     Status = gBS->UninstallMultipleProtocolInterfaces (
 709                     NicHandle,
 710                     &gEfiIp6ServiceBindingProtocolGuid,
 711                     ServiceBinding,
 712                     &gEfiIp6ConfigProtocolGuid,
 713                     &IpSb->Ip6ConfigInstance.Ip6Config,
 714                     NULL
 715                     );
 716     ASSERT_EFI_ERROR (Status);
 717     FreePool (IpSb);
 718     Status = EFI_SUCCESS;
 719   }
 720
 721 Exit:
 722   return Status;
 723 }
 724
 725
 726 /**
 727   Creates a child handle with a set of I/O services.
 728
 729   @param[in]  This               Protocol instance pointer.
 730   @param[in]  ChildHandle        Pointer to the handle of the child to create.   If
 731                                  it is NULL, then a new handle is created.   If it
 732                                  is not NULL, then the I/O services are added to
 733                                  the existing child handle.
 734
 735   @retval EFI_SUCCES             The child handle was created with the I/O services.
 736   @retval EFI_OUT_OF_RESOURCES   There are not enough resources availabe to create
 737                                  the child.
 738   @retval other                  The child handle was not created.
 739
 740 **/
 741 EFI_STATUS
 742 EFIAPI
 743 Ip6ServiceBindingCreateChild (
 744   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 745   IN EFI_HANDLE                    *ChildHandle
 746   )
 747 {
 748   IP6_SERVICE               *IpSb;
 749   IP6_PROTOCOL              *IpInstance;
 750   EFI_TPL                   OldTpl;
 751   EFI_STATUS                Status;
 752   VOID                      *Mnp;
 753
 754   if ((This == NULL) || (ChildHandle == NULL)) {
 755     return EFI_INVALID_PARAMETER;
 756   }
 757
 758   IpSb       = IP6_SERVICE_FROM_PROTOCOL (This);
 759
 760   if (IpSb->LinkLocalDadFail) {
 761     return EFI_DEVICE_ERROR;
 762   }
 763
 764   IpInstance = AllocatePool (sizeof (IP6_PROTOCOL));
 765
 766   if (IpInstance == NULL) {
 767     return EFI_OUT_OF_RESOURCES;
 768   }
 769
 770   Ip6InitProtocol (IpSb, IpInstance);
 771
 772   //
 773   // Install Ip6 onto ChildHandle
 774   //
 775   Status = gBS->InstallMultipleProtocolInterfaces (
 776                   ChildHandle,
 777                   &gEfiIp6ProtocolGuid,
 778                   &IpInstance->Ip6Proto,
 779                   NULL
 780                   );
 781   if (EFI_ERROR (Status)) {
 782     goto ON_ERROR;
 783   }
 784
 785   IpInstance->Handle = *ChildHandle;
 786
 787   //
 788   // Open the Managed Network protocol BY_CHILD.
 789   //
 790   Status = gBS->OpenProtocol (
 791                   IpSb->MnpChildHandle,
 792                   &gEfiManagedNetworkProtocolGuid,
 793                   (VOID **) &Mnp,
 794                   gIp6DriverBinding.DriverBindingHandle,
 795                   IpInstance->Handle,
 796                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 797                   );
 798   if (EFI_ERROR (Status)) {
 799     gBS->UninstallMultipleProtocolInterfaces (
 800            ChildHandle,
 801            &gEfiIp6ProtocolGuid,
 802            &IpInstance->Ip6Proto,
 803            NULL
 804            );
 805
 806     goto ON_ERROR;
 807   }
 808
 809   //
 810   // Insert it into the service binding instance.
 811   //
 812   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 813
 814   InsertTailList (&IpSb->Children, &IpInstance->Link);
 815   IpSb->NumChildren++;
 816
 817   gBS->RestoreTPL (OldTpl);
 818
 819 ON_ERROR:
 820
 821   if (EFI_ERROR (Status)) {
 822
 823     Ip6CleanProtocol (IpInstance);
 824
 825     FreePool (IpInstance);
 826   }
 827
 828   return Status;
 829 }
 830
 831 /**
 832   Destroys a child handle with a set of I/O services.
 833
 834   @param[in]  This               Protocol instance pointer.
 835   @param[in]  ChildHandle        Handle of the child to destroy.
 836
 837   @retval EFI_SUCCES             The I/O services were removed from the child
 838                                  handle.
 839   @retval EFI_UNSUPPORTED        The child handle does not support the I/O services
 840                                   that are being removed.
 841   @retval EFI_INVALID_PARAMETER  Child handle is NULL.
 842   @retval EFI_ACCESS_DENIED      The child handle could not be destroyed because
 843                                  its I/O services are being used.
 844   @retval other                  The child handle was not destroyed.
 845
 846 **/
 847 EFI_STATUS
 848 EFIAPI
 849 Ip6ServiceBindingDestroyChild (
 850   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 851   IN EFI_HANDLE                    ChildHandle
 852   )
 853 {
 854   EFI_STATUS                Status;
 855   IP6_SERVICE               *IpSb;
 856   IP6_PROTOCOL              *IpInstance;
 857   EFI_IP6_PROTOCOL          *Ip6;
 858   EFI_TPL                   OldTpl;
 859
 860   if ((This == NULL) || (ChildHandle == NULL)) {
 861     return EFI_INVALID_PARAMETER;
 862   }
 863
 864   //
 865   // Retrieve the private context data structures
 866   //
 867   IpSb   = IP6_SERVICE_FROM_PROTOCOL (This);
 868
 869   Status = gBS->OpenProtocol (
 870                   ChildHandle,
 871                   &gEfiIp6ProtocolGuid,
 872                   (VOID **) &Ip6,
 873                   gIp6DriverBinding.DriverBindingHandle,
 874                   ChildHandle,
 875                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 876                   );
 877
 878   if (EFI_ERROR (Status)) {
 879     return EFI_UNSUPPORTED;
 880   }
 881
 882   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (Ip6);
 883
 884   if (IpInstance->Service != IpSb) {
 885     return EFI_INVALID_PARAMETER;
 886   }
 887
 888   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 889
 890   //
 891   // A child can be destroyed more than once. For example,
 892   // Ip6DriverBindingStop will destroy all of its children.
 893   // when UDP driver is being stopped, it will destroy all
 894   // the IP child it opens.
 895   //
 896   if (IpInstance->InDestroy) {
 897     gBS->RestoreTPL (OldTpl);
 898     return EFI_SUCCESS;
 899   }
 900
 901   IpInstance->InDestroy = TRUE;
 902
 903   //
 904   // Close the Managed Network protocol.
 905   //
 906   gBS->CloseProtocol (
 907          IpSb->MnpChildHandle,
 908          &gEfiManagedNetworkProtocolGuid,
 909          gIp6DriverBinding.DriverBindingHandle,
 910          ChildHandle
 911          );
 912
 913   //
 914   // Uninstall the IP6 protocol first. Many thing happens during
 915   // this:
 916   // 1. The consumer of the IP6 protocol will be stopped if it
 917   // opens the protocol BY_DRIVER. For eaxmple, if MNP driver is
 918   // stopped, IP driver's stop function will be called, and uninstall
 919   // EFI_IP6_PROTOCOL will trigger the UDP's stop function. This
 920   // makes it possible to create the network stack bottom up, and
 921   // stop it top down.
 922   // 2. the upper layer will recycle the received packet. The recycle
 923   // event's TPL is higher than this function. The recycle events
 924   // will be called back before preceeding. If any packets not recycled,
 925   // that means there is a resource leak.
 926   //
 927   gBS->RestoreTPL (OldTpl);
 928   Status = gBS->UninstallProtocolInterface (
 929                   ChildHandle,
 930                   &gEfiIp6ProtocolGuid,
 931                   &IpInstance->Ip6Proto
 932                   );
 933   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 934   if (EFI_ERROR (Status)) {
 935     goto ON_ERROR;
 936   }
 937
 938   Status = Ip6CleanProtocol (IpInstance);
 939   if (EFI_ERROR (Status)) {
 940     gBS->InstallMultipleProtocolInterfaces (
 941            &ChildHandle,
 942            &gEfiIp6ProtocolGuid,
 943            Ip6,
 944            NULL
 945            );
 946
 947     goto ON_ERROR;
 948   }
 949
 950   RemoveEntryList (&IpInstance->Link);
 951   ASSERT (IpSb->NumChildren > 0);
 952   IpSb->NumChildren--;
 953
 954   gBS->RestoreTPL (OldTpl);
 955
 956   FreePool (IpInstance);
 957   return EFI_SUCCESS;
 958
 959 ON_ERROR:
 960   gBS->RestoreTPL (OldTpl);
 961
 962   return Status;
 963 }