Ip6ConfigImpl.c

Go to the documentation of this file.

 
#include "Ip6Impl.h"
 
LIST_ENTRY  mIp6ConfigInstanceList = { &mIp6ConfigInstanceList, &mIp6ConfigInstanceList };
 
VOID
EFIAPI
Ip6ConfigOnDhcp6SbInstalled (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
VOID
Ip6ConfigOnPolicyChanged (
  IN IP6_SERVICE            *IpSb,
  IN EFI_IP6_CONFIG_POLICY  NewPolicy
  )
{
  LIST_ENTRY           *Entry;
  LIST_ENTRY           *Entry2;
  LIST_ENTRY           *Next;
  IP6_INTERFACE        *IpIf;
  IP6_DAD_ENTRY        *DadEntry;
  IP6_DELAY_JOIN_LIST  *DelayNode;
  IP6_ADDRESS_INFO     *AddrInfo;
  IP6_PROTOCOL         *Instance;
  BOOLEAN              Recovery;
 
  Recovery = FALSE;
 
  //
  // Currently there are only two policies: Manual and Automatic. Regardless of
  // what transition is going on, i.e., Manual -> Automatic and Automatic ->
  // Manual, we have to free default router list, on-link prefix list, autonomous
  // prefix list, address list in all the interfaces and destroy any IPv6 child
  // instance whose local IP is neither 0 nor the link-local address.
  //
  Ip6CleanDefaultRouterList (IpSb);
  Ip6CleanPrefixListTable (IpSb, &IpSb->OnlinkPrefix);
  Ip6CleanPrefixListTable (IpSb, &IpSb->AutonomousPrefix);
 
  //
  // It's tricky... If the LinkLocal address is O.K., add back the link-local
  // prefix to the on-link prefix table.
  //
  if (IpSb->LinkLocalOk) {
    Ip6CreatePrefixListEntry (
      IpSb,
      TRUE,
      (UINT32)IP6_INFINIT_LIFETIME,
      (UINT32)IP6_INFINIT_LIFETIME,
      IP6_LINK_LOCAL_PREFIX_LENGTH,
      &IpSb->LinkLocalAddr
      );
  }
 
  if (!IsListEmpty (&IpSb->DefaultInterface->AddressList) && (IpSb->DefaultInterface->AddressCount > 0)) {
    //
    // If any IPv6 children (Instance) in configured state and use global unicast address, it will be
    // destroyed in Ip6RemoveAddr() function later. Then, the upper layer driver's Stop() function will be
    // called, which may break the upper layer network stacks. So, the driver should take the responsibility
    // for the recovery by using ConnectController() after Ip6RemoveAddr().
    // Here, just check whether need to recover the upper layer network stacks later.
    //
    NET_LIST_FOR_EACH (Entry, &IpSb->DefaultInterface->AddressList) {
      AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
      if (!IsListEmpty (&IpSb->Children)) {
        NET_LIST_FOR_EACH (Entry2, &IpSb->Children) {
          Instance = NET_LIST_USER_STRUCT_S (Entry2, IP6_PROTOCOL, Link, IP6_PROTOCOL_SIGNATURE);
          if ((Instance->State == IP6_STATE_CONFIGED) && EFI_IP6_EQUAL (&Instance->ConfigData.StationAddress, &AddrInfo->Address)) {
            Recovery = TRUE;
            break;
          }
        }
      }
    }
 
    //
    // All IPv6 children that use global unicast address as its source address
    // should be destroyed now. The survivers are those use the link-local address
    // or the unspecified address as the source address.
    // TODO: Conduct a check here.
    Ip6RemoveAddr (
      IpSb,
      &IpSb->DefaultInterface->AddressList,
      &IpSb->DefaultInterface->AddressCount,
      NULL,
      0
      );
 
    if ((IpSb->Controller != NULL) && Recovery) {
      //
      // ConnectController() to recover the upper layer network stacks.
      //
      gBS->ConnectController (IpSb->Controller, NULL, NULL, TRUE);
    }
  }
 
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
    //
    // remove all pending delay node and DAD entries for the global addresses.
    //
    IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);
 
    NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DelayJoinList) {
      DelayNode = NET_LIST_USER_STRUCT (Entry2, IP6_DELAY_JOIN_LIST, Link);
      if (!NetIp6IsLinkLocalAddr (&DelayNode->AddressInfo->Address)) {
        RemoveEntryList (&DelayNode->Link);
        FreePool (DelayNode);
      }
    }
 
    NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DupAddrDetectList) {
      DadEntry = NET_LIST_USER_STRUCT_S (Entry2, IP6_DAD_ENTRY, Link, IP6_DAD_ENTRY_SIGNATURE);
 
      if (!NetIp6IsLinkLocalAddr (&DadEntry->AddressInfo->Address)) {
        //
        // Fail this DAD entry if the address is not link-local.
        //
        Ip6OnDADFinished (FALSE, IpIf, DadEntry);
      }
    }
  }
 
  if (NewPolicy == Ip6ConfigPolicyAutomatic) {
    //
    // Set parameters to trigger router solicitation sending in timer handler.
    //
    IpSb->RouterAdvertiseReceived = FALSE;
    IpSb->SolicitTimer            = IP6_MAX_RTR_SOLICITATIONS;
    //
    // delay 1 second
    //
    IpSb->Ticks = (UINT32)IP6_GET_TICKS (IP6_ONE_SECOND_IN_MS);
  }
}
 
EFI_STATUS
Ip6ConfigStartStatefulAutoConfig (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN BOOLEAN              OtherInfoOnly
  )
{
  EFI_STATUS                Status;
  IP6_SERVICE               *IpSb;
  EFI_DHCP6_CONFIG_DATA     Dhcp6CfgData;
  EFI_DHCP6_PROTOCOL        *Dhcp6;
  EFI_DHCP6_PACKET_OPTION   *OptList[1];
  UINT16                    OptBuf[4];
  EFI_DHCP6_PACKET_OPTION   *Oro;
  EFI_DHCP6_RETRANSMISSION  InfoReqReXmit;
 
  //
  // A host must not invoke stateful address configuration if it is already
  // participating in the statuful protocol as a result of an earlier advertisement.
  //
  if (Instance->Dhcp6Handle != NULL) {
    return EFI_SUCCESS;
  }
 
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
 
  Instance->OtherInfoOnly = OtherInfoOnly;
 
  Status = NetLibCreateServiceChild (
             IpSb->Controller,
             IpSb->Image,
             &gEfiDhcp6ServiceBindingProtocolGuid,
             &Instance->Dhcp6Handle
             );
 
  if (Status == EFI_UNSUPPORTED) {
    //
    // No DHCPv6 Service Binding protocol, register a notify.
    //
    if (Instance->Dhcp6SbNotifyEvent == NULL) {
      Instance->Dhcp6SbNotifyEvent = EfiCreateProtocolNotifyEvent (
                                       &gEfiDhcp6ServiceBindingProtocolGuid,
                                       TPL_CALLBACK,
                                       Ip6ConfigOnDhcp6SbInstalled,
                                       (VOID *)Instance,
                                       &Instance->Registration
                                       );
    }
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Instance->Dhcp6SbNotifyEvent != NULL) {
    gBS->CloseEvent (Instance->Dhcp6SbNotifyEvent);
  }
 
  Status = gBS->OpenProtocol (
                  Instance->Dhcp6Handle,
                  &gEfiDhcp6ProtocolGuid,
                  (VOID **)&Instance->Dhcp6,
                  IpSb->Image,
                  IpSb->Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  ASSERT_EFI_ERROR (Status);
 
  Dhcp6 = Instance->Dhcp6;
  Dhcp6->Configure (Dhcp6, NULL);
 
  //
  // Set the exta options to send. Here we only want the option request option
  // with DNS SERVERS.
  //
  Oro                        = (EFI_DHCP6_PACKET_OPTION *)OptBuf;
  Oro->OpCode                = HTONS (DHCP6_OPT_ORO);
  Oro->OpLen                 = HTONS (2);
  *((UINT16 *)&Oro->Data[0]) = HTONS (DHCP6_OPT_DNS_SERVERS);
  OptList[0]                 = Oro;
 
  Status = EFI_SUCCESS;
 
  if (!OtherInfoOnly) {
    //
    // Get stateful address and other information via DHCPv6.
    //
    Dhcp6CfgData.Dhcp6Callback         = NULL;
    Dhcp6CfgData.CallbackContext       = NULL;
    Dhcp6CfgData.OptionCount           = 1;
    Dhcp6CfgData.OptionList            = &OptList[0];
    Dhcp6CfgData.IaDescriptor.Type     = EFI_DHCP6_IA_TYPE_NA;
    Dhcp6CfgData.IaDescriptor.IaId     = Instance->IaId;
    Dhcp6CfgData.IaInfoEvent           = Instance->Dhcp6Event;
    Dhcp6CfgData.ReconfigureAccept     = FALSE;
    Dhcp6CfgData.RapidCommit           = FALSE;
    Dhcp6CfgData.SolicitRetransmission = NULL;
 
    Status = Dhcp6->Configure (Dhcp6, &Dhcp6CfgData);
 
    if (!EFI_ERROR (Status)) {
      if (IpSb->LinkLocalOk) {
        Status = Dhcp6->Start (Dhcp6);
      } else {
        IpSb->Dhcp6NeedStart = TRUE;
      }
    }
  } else {
    //
    // Only get other information via DHCPv6, this doesn't require a config
    // action.
    //
    InfoReqReXmit.Irt = 4;
    InfoReqReXmit.Mrc = 64;
    InfoReqReXmit.Mrt = 60;
    InfoReqReXmit.Mrd = 0;
 
    if (IpSb->LinkLocalOk) {
      Status = Dhcp6->InfoRequest (
                        Dhcp6,
                        TRUE,
                        Oro,
                        0,
                        NULL,
                        &InfoReqReXmit,
                        Instance->Dhcp6Event,
                        Ip6ConfigOnDhcp6Reply,
                        Instance
                        );
    } else {
      IpSb->Dhcp6NeedInfoRequest = TRUE;
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
Ip6ConfigSignalEvent (
  IN NET_MAP       *Map,
  IN NET_MAP_ITEM  *Item,
  IN VOID          *Arg
  )
{
  gBS->SignalEvent ((EFI_EVENT)Item->Key);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6ConfigReadConfigData (
  IN     CHAR16               *VarName,
  IN OUT IP6_CONFIG_INSTANCE  *Instance
  )
{
  EFI_STATUS              Status;
  UINTN                   VarSize;
  IP6_CONFIG_VARIABLE     *Variable;
  IP6_CONFIG_DATA_ITEM    *DataItem;
  UINTN                   Index;
  IP6_CONFIG_DATA_RECORD  DataRecord;
  CHAR8                   *Data;
 
  //
  // Try to read the configuration variable.
  //
  VarSize = 0;
  Status  = gRT->GetVariable (
                   VarName,
                   &gEfiIp6ConfigProtocolGuid,
                   NULL,
                   &VarSize,
                   NULL
                   );
 
  if (Status == EFI_BUFFER_TOO_SMALL) {
    //
    // Allocate buffer and read the config variable.
    //
    Variable = AllocatePool (VarSize);
    if (Variable == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    Status = gRT->GetVariable (
                    VarName,
                    &gEfiIp6ConfigProtocolGuid,
                    NULL,
                    &VarSize,
                    Variable
                    );
    if (EFI_ERROR (Status) || ((UINT16)(~NetblockChecksum ((UINT8 *)Variable, (UINT32)VarSize)) != 0)) {
      //
      // GetVariable error or the variable is corrupted.
      //
      goto Error;
    }
 
    //
    // Get the IAID we use.
    //
    Instance->IaId = Variable->IaId;
 
    for (Index = 0; Index < Variable->DataRecordCount; Index++) {
      CopyMem (&DataRecord, &Variable->DataRecord[Index], sizeof (DataRecord));
 
      DataItem = &Instance->DataItem[DataRecord.DataType];
      if (DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED) &&
          (DataItem->DataSize != DataRecord.DataSize)
          )
      {
        //
        // Perhaps a corrupted data record...
        //
        continue;
      }
 
      if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
        //
        // This data item has variable length data.
        // Check that the length is contained within the variable before allocating.
        //
        if (DataRecord.DataSize > VarSize - DataRecord.Offset) {
          goto Error;
        }
 
        DataItem->Data.Ptr = AllocatePool (DataRecord.DataSize);
        if (DataItem->Data.Ptr == NULL) {
          //
          // no memory resource
          //
          continue;
        }
      }
 
      Data = (CHAR8 *)Variable + DataRecord.Offset;
      CopyMem (DataItem->Data.Ptr, Data, DataRecord.DataSize);
 
      DataItem->DataSize = DataRecord.DataSize;
      DataItem->Status   = EFI_SUCCESS;
    }
 
    FreePool (Variable);
    return EFI_SUCCESS;
  }
 
  return Status;
 
Error:
  //
  // Fall back to the default value.
  //
  if (Variable != NULL) {
    FreePool (Variable);
  }
 
  //
  // Remove the problematic variable and return EFI_NOT_FOUND, a new
  // variable will be set again.
  //
  gRT->SetVariable (
         VarName,
         &gEfiIp6ConfigProtocolGuid,
         IP6_CONFIG_VARIABLE_ATTRIBUTE,
         0,
         NULL
         );
 
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
Ip6ConfigWriteConfigData (
  IN CHAR16               *VarName,
  IN IP6_CONFIG_INSTANCE  *Instance
  )
{
  UINTN                   Index;
  UINTN                   VarSize;
  IP6_CONFIG_DATA_ITEM    *DataItem;
  IP6_CONFIG_VARIABLE     *Variable;
  IP6_CONFIG_DATA_RECORD  *DataRecord;
  CHAR8                   *Heap;
  EFI_STATUS              Status;
 
  VarSize = sizeof (IP6_CONFIG_VARIABLE) - sizeof (IP6_CONFIG_DATA_RECORD);
 
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {
    DataItem = &Instance->DataItem[Index];
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
      VarSize += sizeof (IP6_CONFIG_DATA_RECORD) + DataItem->DataSize;
    }
  }
 
  Variable = AllocatePool (VarSize);
  if (Variable == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Variable->IaId            = Instance->IaId;
  Heap                      = (CHAR8 *)Variable + VarSize;
  Variable->DataRecordCount = 0;
 
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {
    DataItem = &Instance->DataItem[Index];
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
      Heap -= DataItem->DataSize;
      CopyMem (Heap, DataItem->Data.Ptr, DataItem->DataSize);
 
      DataRecord           = &Variable->DataRecord[Variable->DataRecordCount];
      DataRecord->DataType = (EFI_IP6_CONFIG_DATA_TYPE)Index;
      DataRecord->DataSize = (UINT32)DataItem->DataSize;
      DataRecord->Offset   = (UINT16)(Heap - (CHAR8 *)Variable);
 
      Variable->DataRecordCount++;
    }
  }
 
  Variable->Checksum = 0;
  Variable->Checksum = (UINT16) ~NetblockChecksum ((UINT8 *)Variable, (UINT32)VarSize);
 
  Status = gRT->SetVariable (
                  VarName,
                  &gEfiIp6ConfigProtocolGuid,
                  IP6_CONFIG_VARIABLE_ATTRIBUTE,
                  VarSize,
                  Variable
                  );
 
  FreePool (Variable);
 
  return Status;
}
 
EFI_STATUS
Ip6ConfigGetIfInfo (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN OUT UINTN            *DataSize,
  IN VOID                 *Data      OPTIONAL
  )
{
  IP6_SERVICE                    *IpSb;
  UINTN                          Length;
  IP6_CONFIG_DATA_ITEM           *Item;
  EFI_IP6_CONFIG_INTERFACE_INFO  *IfInfo;
  UINT32                         AddressCount;
  UINT32                         RouteCount;
 
  IpSb   = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
  Length = sizeof (EFI_IP6_CONFIG_INTERFACE_INFO);
 
  //
  // Calculate the required length, add the buffer size for AddressInfo and
  // RouteTable
  //
  Ip6BuildEfiAddressList (IpSb, &AddressCount, NULL);
  Ip6BuildEfiRouteTable (IpSb->RouteTable, &RouteCount, NULL);
 
  Length += AddressCount * sizeof (EFI_IP6_ADDRESS_INFO) + RouteCount * sizeof (EFI_IP6_ROUTE_TABLE);
 
  if (*DataSize < Length) {
    *DataSize = Length;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  //
  // Copy the fixed size part of the interface info.
  //
  Item   = &Instance->DataItem[Ip6ConfigDataTypeInterfaceInfo];
  IfInfo = (EFI_IP6_CONFIG_INTERFACE_INFO *)Data;
  CopyMem (IfInfo, Item->Data.Ptr, sizeof (EFI_IP6_CONFIG_INTERFACE_INFO));
 
  //
  // AddressInfo
  //
  IfInfo->AddressInfo = (EFI_IP6_ADDRESS_INFO *)(IfInfo + 1);
  Ip6BuildEfiAddressList (IpSb, &IfInfo->AddressInfoCount, &IfInfo->AddressInfo);
 
  //
  // RouteTable
  //
  IfInfo->RouteTable = (EFI_IP6_ROUTE_TABLE *)(IfInfo->AddressInfo + IfInfo->AddressInfoCount);
  Ip6BuildEfiRouteTable (IpSb->RouteTable, &IfInfo->RouteCount, &IfInfo->RouteTable);
 
  if (IfInfo->AddressInfoCount == 0) {
    IfInfo->AddressInfo = NULL;
  }
 
  if (IfInfo->RouteCount == 0) {
    IfInfo->RouteTable = NULL;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6ConfigSetAltIfId (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN UINTN                DataSize,
  IN VOID                 *Data
  )
{
  EFI_IP6_CONFIG_INTERFACE_ID  *OldIfId;
  EFI_IP6_CONFIG_INTERFACE_ID  *NewIfId;
  IP6_CONFIG_DATA_ITEM         *DataItem;
 
  if (DataSize != sizeof (EFI_IP6_CONFIG_INTERFACE_ID)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  DataItem = &Instance->DataItem[Ip6ConfigDataTypeAltInterfaceId];
  OldIfId  = DataItem->Data.AltIfId;
  NewIfId  = (EFI_IP6_CONFIG_INTERFACE_ID *)Data;
 
  CopyMem (OldIfId, NewIfId, DataSize);
  DataItem->Status = EFI_SUCCESS;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6ConfigSetPolicy (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN UINTN                DataSize,
  IN VOID                 *Data
  )
{
  EFI_IP6_CONFIG_POLICY  NewPolicy;
  IP6_CONFIG_DATA_ITEM   *DataItem;
  IP6_SERVICE            *IpSb;
 
  if (DataSize != sizeof (EFI_IP6_CONFIG_POLICY)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  NewPolicy = *((EFI_IP6_CONFIG_POLICY *)Data);
 
  if (NewPolicy > Ip6ConfigPolicyAutomatic) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (NewPolicy == Instance->Policy) {
    return EFI_ABORTED;
  } else {
    //
    // Clean the ManualAddress, Gateway and DnsServers, shrink the variable
    // data size, and fire up all the related events.
    //
    DataItem = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
    NetMapIterate (&DataItem->EventMap, Ip6ConfigSignalEvent, NULL);
 
    DataItem = &Instance->DataItem[Ip6ConfigDataTypeGateway];
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
    NetMapIterate (&DataItem->EventMap, Ip6ConfigSignalEvent, NULL);
 
    DataItem           = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
    NetMapIterate (&DataItem->EventMap, Ip6ConfigSignalEvent, NULL);
 
    if (NewPolicy == Ip6ConfigPolicyManual) {
      //
      // The policy is changed from automatic to manual. Stop the DHCPv6 process
      // and destroy the DHCPv6 child.
      //
      if (Instance->Dhcp6Handle != NULL) {
        Ip6ConfigDestroyDhcp6 (Instance);
      }
    }
 
    IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
    Ip6ConfigOnPolicyChanged (IpSb, NewPolicy);
 
    Instance->Policy = NewPolicy;
 
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
Ip6ConfigSetDadXmits (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN UINTN                DataSize,
  IN VOID                 *Data
  )
{
  EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS  *OldDadXmits;
 
  if (DataSize != sizeof (EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  OldDadXmits = Instance->DataItem[Ip6ConfigDataTypeDupAddrDetectTransmits].Data.DadXmits;
 
  if ((*(UINT32 *)Data) == OldDadXmits->DupAddrDetectTransmits) {
    return EFI_ABORTED;
  } else {
    OldDadXmits->DupAddrDetectTransmits = *((UINT32 *)Data);
    return EFI_SUCCESS;
  }
}
 
VOID
Ip6ManualAddrDadCallback (
  IN BOOLEAN           IsDadPassed,
  IN EFI_IPv6_ADDRESS  *TargetAddress,
  IN VOID              *Context
  )
{
  IP6_CONFIG_INSTANCE            *Instance;
  UINTN                          Index;
  IP6_CONFIG_DATA_ITEM           *Item;
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *ManualAddr;
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *PassedAddr;
  UINTN                          DadPassCount;
  UINTN                          DadFailCount;
  IP6_SERVICE                    *IpSb;
 
  Instance = (IP6_CONFIG_INSTANCE *)Context;
  NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);
  Item       = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];
  ManualAddr = NULL;
 
  if (Item->DataSize == 0) {
    return;
  }
 
  for (Index = 0; Index < Item->DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS); Index++) {
    //
    // Find the original tag used to place into the NET_MAP.
    //
    ManualAddr = Item->Data.ManualAddress + Index;
    if (EFI_IP6_EQUAL (TargetAddress, &ManualAddr->Address)) {
      break;
    }
  }
 
  ASSERT (Index != Item->DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS));
 
  if (IsDadPassed) {
    NetMapInsertTail (&Instance->DadPassedMap, ManualAddr, NULL);
  } else {
    NetMapInsertTail (&Instance->DadFailedMap, ManualAddr, NULL);
  }
 
  DadPassCount = NetMapGetCount (&Instance->DadPassedMap);
  DadFailCount = NetMapGetCount (&Instance->DadFailedMap);
 
  if ((DadPassCount + DadFailCount) == (Item->DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS))) {
    //
    // All addresses have finished the configuration process.
    //
    if (DadFailCount != 0) {
      //
      // There is at least one duplicate address.
      //
      FreePool (Item->Data.Ptr);
 
      Item->DataSize = DadPassCount * sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS);
      if (Item->DataSize == 0) {
        //
        // All failed, bad luck.
        //
        Item->Data.Ptr = NULL;
        Item->Status   = EFI_NOT_FOUND;
      } else {
        //
        // Part of addresses are detected to be duplicates, so update the
        // data with those passed.
        //
        PassedAddr = (EFI_IP6_CONFIG_MANUAL_ADDRESS *)AllocatePool (Item->DataSize);
        ASSERT (PassedAddr != NULL);
 
        Item->Data.Ptr = PassedAddr;
        Item->Status   = EFI_SUCCESS;
 
        while (!NetMapIsEmpty (&Instance->DadPassedMap)) {
          ManualAddr = (EFI_IP6_CONFIG_MANUAL_ADDRESS *)NetMapRemoveHead (&Instance->DadPassedMap, NULL);
          CopyMem (PassedAddr, ManualAddr, sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS));
 
          PassedAddr++;
        }
 
        ASSERT ((UINTN)PassedAddr - (UINTN)Item->Data.Ptr == Item->DataSize);
      }
    } else {
      //
      // All addresses are valid.
      //
      Item->Status = EFI_SUCCESS;
    }
 
    //
    // Remove the tags we put in the NET_MAPs.
    //
    while (!NetMapIsEmpty (&Instance->DadFailedMap)) {
      NetMapRemoveHead (&Instance->DadFailedMap, NULL);
    }
 
    while (!NetMapIsEmpty (&Instance->DadPassedMap)) {
      NetMapRemoveHead (&Instance->DadPassedMap, NULL);
    }
 
    //
    // Signal the waiting events.
    //
    NetMapIterate (&Item->EventMap, Ip6ConfigSignalEvent, NULL);
    IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
    Ip6ConfigWriteConfigData (IpSb->MacString, Instance);
  }
}
 
EFI_STATUS
Ip6ConfigSetManualAddress (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN UINTN                DataSize,
  IN VOID                 *Data
  )
{
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *NewAddress;
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *TmpAddress;
  IP6_CONFIG_DATA_ITEM           *DataItem;
  UINTN                          NewAddressCount;
  UINTN                          Index1;
  UINTN                          Index2;
  IP6_SERVICE                    *IpSb;
  IP6_ADDRESS_INFO               *CurrentAddrInfo;
  IP6_ADDRESS_INFO               *Copy;
  LIST_ENTRY                     CurrentSourceList;
  UINT32                         CurrentSourceCount;
  LIST_ENTRY                     *Entry;
  LIST_ENTRY                     *Entry2;
  IP6_INTERFACE                  *IpIf;
  IP6_PREFIX_LIST_ENTRY          *PrefixEntry;
  EFI_STATUS                     Status;
  BOOLEAN                        IsUpdated;
  LIST_ENTRY                     *Next;
  IP6_DAD_ENTRY                  *DadEntry;
  IP6_DELAY_JOIN_LIST            *DelayNode;
 
  NewAddress      = NULL;
  TmpAddress      = NULL;
  CurrentAddrInfo = NULL;
  Copy            = NULL;
  Entry           = NULL;
  Entry2          = NULL;
  IpIf            = NULL;
  PrefixEntry     = NULL;
  Next            = NULL;
  DadEntry        = NULL;
  DelayNode       = NULL;
  Status          = EFI_SUCCESS;
 
  ASSERT (Instance->DataItem[Ip6ConfigDataTypeManualAddress].Status != EFI_NOT_READY);
 
  if ((DataSize != 0) && ((DataSize % sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS)) != 0)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Instance->Policy != Ip6ConfigPolicyManual) {
    return EFI_WRITE_PROTECTED;
  }
 
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
 
  DataItem = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];
 
  if ((Data != NULL) && (DataSize != 0)) {
    NewAddressCount = DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS);
    NewAddress      = (EFI_IP6_CONFIG_MANUAL_ADDRESS *)Data;
 
    for (Index1 = 0; Index1 < NewAddressCount; Index1++, NewAddress++) {
      if (NetIp6IsLinkLocalAddr (&NewAddress->Address)    ||
          !NetIp6IsValidUnicast (&NewAddress->Address)    ||
          (NewAddress->PrefixLength > 128)
          )
      {
        //
        // make sure the IPv6 address is unicast and not link-local address &&
        // the prefix length is valid.
        //
        return EFI_INVALID_PARAMETER;
      }
 
      TmpAddress = NewAddress + 1;
      for (Index2 = Index1 + 1; Index2 < NewAddressCount; Index2++, TmpAddress++) {
        //
        // Any two addresses in the array can't be equal.
        //
        if (EFI_IP6_EQUAL (&TmpAddress->Address, &NewAddress->Address)) {
          return EFI_INVALID_PARAMETER;
        }
      }
    }
 
    //
    // Build the current source address list.
    //
    InitializeListHead (&CurrentSourceList);
    CurrentSourceCount = 0;
 
    NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
      IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);
 
      NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) {
        CurrentAddrInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);
 
        Copy = AllocateCopyPool (sizeof (IP6_ADDRESS_INFO), CurrentAddrInfo);
        if (Copy == NULL) {
          break;
        }
 
        InsertTailList (&CurrentSourceList, &Copy->Link);
        CurrentSourceCount++;
      }
    }
 
    //
    // Update the value... a long journey starts
    //
    NewAddress = AllocateCopyPool (DataSize, Data);
    if (NewAddress == NULL) {
      Ip6RemoveAddr (NULL, &CurrentSourceList, &CurrentSourceCount, NULL, 0);
 
      return EFI_OUT_OF_RESOURCES;
    }
 
    //
    // Store the new data, and init the DataItem status to EFI_NOT_READY because
    // we may have an asynchronous configuration process.
    //
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NewAddress;
    DataItem->DataSize = DataSize;
    DataItem->Status   = EFI_NOT_READY;
 
    //
    // Trigger DAD, it's an asynchronous process.
    //
    IsUpdated = FALSE;
 
    for (Index1 = 0; Index1 < NewAddressCount; Index1++, NewAddress++) {
      if (Ip6IsOneOfSetAddress (IpSb, &NewAddress->Address, NULL, &CurrentAddrInfo)) {
        ASSERT (CurrentAddrInfo != NULL);
        //
        // Remove this already existing source address from the CurrentSourceList
        // built before.
        //
        Ip6RemoveAddr (
          NULL,
          &CurrentSourceList,
          &CurrentSourceCount,
          &CurrentAddrInfo->Address,
          128
          );
 
        //
        // If the new address's prefix length is not specified, just use the previous configured
        // prefix length for this address.
        //
        if (NewAddress->PrefixLength == 0) {
          NewAddress->PrefixLength = CurrentAddrInfo->PrefixLength;
        }
 
        //
        // This manual address is already in use, see whether prefix length is changed.
        //
        if (NewAddress->PrefixLength != CurrentAddrInfo->PrefixLength) {
          //
          // Remove the on-link prefix table, the route entry will be removed
          // implicitly.
          //
          PrefixEntry = Ip6FindPrefixListEntry (
                          IpSb,
                          TRUE,
                          CurrentAddrInfo->PrefixLength,
                          &CurrentAddrInfo->Address
                          );
          if (PrefixEntry != NULL) {
            Ip6DestroyPrefixListEntry (IpSb, PrefixEntry, TRUE, FALSE);
          }
 
          //
          // Save the prefix length.
          //
          CurrentAddrInfo->PrefixLength = NewAddress->PrefixLength;
          IsUpdated                     = TRUE;
        }
 
        //
        // create a new on-link prefix entry.
        //
        PrefixEntry = Ip6FindPrefixListEntry (
                        IpSb,
                        TRUE,
                        NewAddress->PrefixLength,
                        &NewAddress->Address
                        );
        if (PrefixEntry == NULL) {
          Ip6CreatePrefixListEntry (
            IpSb,
            TRUE,
            (UINT32)IP6_INFINIT_LIFETIME,
            (UINT32)IP6_INFINIT_LIFETIME,
            NewAddress->PrefixLength,
            &NewAddress->Address
            );
        }
 
        CurrentAddrInfo->IsAnycast = NewAddress->IsAnycast;
        //
        // Artificially mark this address passed DAD be'coz it is already in use.
        //
        Ip6ManualAddrDadCallback (TRUE, &NewAddress->Address, Instance);
      } else {
        //
        // A new address.
        //
        IsUpdated = TRUE;
 
        //
        // Set the new address, this will trigger DAD and activate the address if
        // DAD succeeds.
        //
        Ip6SetAddress (
          IpSb->DefaultInterface,
          &NewAddress->Address,
          NewAddress->IsAnycast,
          NewAddress->PrefixLength,
          (UINT32)IP6_INFINIT_LIFETIME,
          (UINT32)IP6_INFINIT_LIFETIME,
          Ip6ManualAddrDadCallback,
          Instance
          );
      }
    }
 
    //
    // Check the CurrentSourceList, it now contains those addresses currently in
    // use and will be removed.
    //
    IpIf = IpSb->DefaultInterface;
 
    while (!IsListEmpty (&CurrentSourceList)) {
      IsUpdated = TRUE;
 
      CurrentAddrInfo = NET_LIST_HEAD (&CurrentSourceList, IP6_ADDRESS_INFO, Link);
 
      //
      // This local address is going to be removed, the IP instances that are
      // currently using it will be destroyed.
      //
      Ip6RemoveAddr (
        IpSb,
        &IpIf->AddressList,
        &IpIf->AddressCount,
        &CurrentAddrInfo->Address,
        128
        );
 
      //
      // Remove the on-link prefix table, the route entry will be removed
      // implicitly.
      //
      PrefixEntry = Ip6FindPrefixListEntry (
                      IpSb,
                      TRUE,
                      CurrentAddrInfo->PrefixLength,
                      &CurrentAddrInfo->Address
                      );
      if (PrefixEntry != NULL) {
        Ip6DestroyPrefixListEntry (IpSb, PrefixEntry, TRUE, FALSE);
      }
 
      RemoveEntryList (&CurrentAddrInfo->Link);
      FreePool (CurrentAddrInfo);
    }
 
    if (IsUpdated) {
      if (DataItem->Status == EFI_NOT_READY) {
        //
        // If DAD is disabled on this interface, the configuration process is
        // actually synchronous, and the data item's status will be changed to
        // the final status before we reach here, just check it.
        //
        Status = EFI_NOT_READY;
      } else {
        Status = EFI_SUCCESS;
      }
    } else {
      //
      // No update is taken, reset the status to success and return EFI_ABORTED.
      //
      DataItem->Status = EFI_SUCCESS;
      Status           = EFI_ABORTED;
    }
  } else {
    //
    // DataSize is 0 and Data is NULL, clean up the manual address.
    //
    if (DataItem->Data.Ptr != NULL) {
      FreePool (DataItem->Data.Ptr);
    }
 
    DataItem->Data.Ptr = NULL;
    DataItem->DataSize = 0;
    DataItem->Status   = EFI_NOT_FOUND;
 
    Ip6CleanDefaultRouterList (IpSb);
    Ip6CleanPrefixListTable (IpSb, &IpSb->OnlinkPrefix);
    Ip6CleanPrefixListTable (IpSb, &IpSb->AutonomousPrefix);
    Ip6CleanAssembleTable (&IpSb->Assemble);
 
    if (IpSb->LinkLocalOk) {
      Ip6CreatePrefixListEntry (
        IpSb,
        TRUE,
        (UINT32)IP6_INFINIT_LIFETIME,
        (UINT32)IP6_INFINIT_LIFETIME,
        IP6_LINK_LOCAL_PREFIX_LENGTH,
        &IpSb->LinkLocalAddr
        );
    }
 
    Ip6RemoveAddr (
      IpSb,
      &IpSb->DefaultInterface->AddressList,
      &IpSb->DefaultInterface->AddressCount,
      NULL,
      0
      );
 
    NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
      //
      // Remove all pending delay node and DAD entries for the global addresses.
      //
      IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);
 
      NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DelayJoinList) {
        DelayNode = NET_LIST_USER_STRUCT (Entry2, IP6_DELAY_JOIN_LIST, Link);
        if (!NetIp6IsLinkLocalAddr (&DelayNode->AddressInfo->Address)) {
          RemoveEntryList (&DelayNode->Link);
          FreePool (DelayNode);
        }
      }
 
      NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DupAddrDetectList) {
        DadEntry = NET_LIST_USER_STRUCT_S (Entry2, IP6_DAD_ENTRY, Link, IP6_DAD_ENTRY_SIGNATURE);
 
        if (!NetIp6IsLinkLocalAddr (&DadEntry->AddressInfo->Address)) {
          //
          // Fail this DAD entry if the address is not link-local.
          //
          Ip6OnDADFinished (FALSE, IpIf, DadEntry);
        }
      }
    }
  }
 
  return Status;
}
 
EFI_STATUS
Ip6ConfigSetGateway (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN UINTN                DataSize,
  IN VOID                 *Data
  )
{
  UINTN                 Index1;
  UINTN                 Index2;
  EFI_IPv6_ADDRESS      *OldGateway;
  EFI_IPv6_ADDRESS      *NewGateway;
  UINTN                 OldGatewayCount;
  UINTN                 NewGatewayCount;
  IP6_CONFIG_DATA_ITEM  *Item;
  BOOLEAN               OneRemoved;
  BOOLEAN               OneAdded;
  IP6_SERVICE           *IpSb;
  IP6_DEFAULT_ROUTER    *DefaultRouter;
  VOID                  *Tmp;
 
  OldGateway    = NULL;
  NewGateway    = NULL;
  Item          = NULL;
  DefaultRouter = NULL;
  Tmp           = NULL;
  OneRemoved    = FALSE;
  OneAdded      = FALSE;
 
  if ((DataSize != 0) && (DataSize % sizeof (EFI_IPv6_ADDRESS) != 0)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Instance->Policy != Ip6ConfigPolicyManual) {
    return EFI_WRITE_PROTECTED;
  }
 
  IpSb            = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
  Item            = &Instance->DataItem[Ip6ConfigDataTypeGateway];
  OldGateway      = Item->Data.Gateway;
  OldGatewayCount = Item->DataSize / sizeof (EFI_IPv6_ADDRESS);
 
  for (Index1 = 0; Index1 < OldGatewayCount; Index1++) {
    //
    // Remove this default router.
    //
    DefaultRouter = Ip6FindDefaultRouter (IpSb, OldGateway + Index1);
    if (DefaultRouter != NULL) {
      Ip6DestroyDefaultRouter (IpSb, DefaultRouter);
      OneRemoved = TRUE;
    }
  }
 
  if ((Data != NULL) && (DataSize != 0)) {
    NewGateway      = (EFI_IPv6_ADDRESS *)Data;
    NewGatewayCount = DataSize / sizeof (EFI_IPv6_ADDRESS);
    for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
      if (!NetIp6IsValidUnicast (NewGateway + Index1)) {
        return EFI_INVALID_PARAMETER;
      }
 
      for (Index2 = Index1 + 1; Index2 < NewGatewayCount; Index2++) {
        if (EFI_IP6_EQUAL (NewGateway + Index1, NewGateway + Index2)) {
          return EFI_INVALID_PARAMETER;
        }
      }
    }
 
    if (NewGatewayCount != OldGatewayCount) {
      Tmp = AllocatePool (DataSize);
      if (Tmp == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }
    } else {
      Tmp = NULL;
    }
 
    for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
      DefaultRouter = Ip6FindDefaultRouter (IpSb, NewGateway + Index1);
      if (DefaultRouter == NULL) {
        Ip6CreateDefaultRouter (IpSb, NewGateway + Index1, IP6_INF_ROUTER_LIFETIME);
        OneAdded = TRUE;
      }
    }
 
    if (!OneRemoved && !OneAdded) {
      Item->Status = EFI_SUCCESS;
      return EFI_ABORTED;
    } else {
      if (Tmp != NULL) {
        if (Item->Data.Ptr != NULL) {
          FreePool (Item->Data.Ptr);
        }
 
        Item->Data.Ptr = Tmp;
      }
 
      CopyMem (Item->Data.Ptr, Data, DataSize);
      Item->DataSize = DataSize;
      Item->Status   = EFI_SUCCESS;
      return EFI_SUCCESS;
    }
  } else {
    //
    // DataSize is 0 and Data is NULL, clean up the Gateway address.
    //
    if (Item->Data.Ptr != NULL) {
      FreePool (Item->Data.Ptr);
    }
 
    Item->Data.Ptr = NULL;
    Item->DataSize = 0;
    Item->Status   = EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6ConfigSetDnsServer (
  IN IP6_CONFIG_INSTANCE  *Instance,
  IN UINTN                DataSize,
  IN VOID                 *Data
  )
{
  UINTN                 OldIndex;
  UINTN                 NewIndex;
  EFI_IPv6_ADDRESS      *OldDns;
  EFI_IPv6_ADDRESS      *NewDns;
  UINTN                 OldDnsCount;
  UINTN                 NewDnsCount;
  IP6_CONFIG_DATA_ITEM  *Item;
  BOOLEAN               OneAdded;
  VOID                  *Tmp;
 
  OldDns = NULL;
  NewDns = NULL;
  Item   = NULL;
  Tmp    = NULL;
 
  if ((DataSize != 0) && (DataSize % sizeof (EFI_IPv6_ADDRESS) != 0)) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  if (Instance->Policy != Ip6ConfigPolicyManual) {
    return EFI_WRITE_PROTECTED;
  }
 
  Item = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];
 
  if ((Data != NULL) && (DataSize != 0)) {
    NewDns      = (EFI_IPv6_ADDRESS *)Data;
    OldDns      = Item->Data.DnsServers;
    NewDnsCount = DataSize / sizeof (EFI_IPv6_ADDRESS);
    OldDnsCount = Item->DataSize / sizeof (EFI_IPv6_ADDRESS);
    OneAdded    = FALSE;
 
    if (NewDnsCount != OldDnsCount) {
      Tmp = AllocatePool (DataSize);
      if (Tmp == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }
    } else {
      Tmp = NULL;
    }
 
    for (NewIndex = 0; NewIndex < NewDnsCount; NewIndex++) {
      if (!NetIp6IsValidUnicast (NewDns + NewIndex)) {
        //
        // The dns server address must be unicast.
        //
        if (Tmp != NULL) {
          FreePool (Tmp);
        }
 
        return EFI_INVALID_PARAMETER;
      }
 
      if (OneAdded) {
        //
        // If any address in the new setting is not in the old settings, skip the
        // comparision below.
        //
        continue;
      }
 
      for (OldIndex = 0; OldIndex < OldDnsCount; OldIndex++) {
        if (EFI_IP6_EQUAL (NewDns + NewIndex, OldDns + OldIndex)) {
          //
          // If found break out.
          //
          break;
        }
      }
 
      if (OldIndex == OldDnsCount) {
        OneAdded = TRUE;
      }
    }
 
    if (!OneAdded && (DataSize == Item->DataSize)) {
      //
      // No new item is added and the size is the same.
      //
      Item->Status = EFI_SUCCESS;
      return EFI_ABORTED;
    } else {
      if (Tmp != NULL) {
        if (Item->Data.Ptr != NULL) {
          FreePool (Item->Data.Ptr);
        }
 
        Item->Data.Ptr = Tmp;
      }
 
      CopyMem (Item->Data.Ptr, Data, DataSize);
      Item->DataSize = DataSize;
      Item->Status   = EFI_SUCCESS;
    }
  } else {
    //
    // DataSize is 0 and Data is NULL, clean up the DnsServer address.
    //
    if (Item->Data.Ptr != NULL) {
      FreePool (Item->Data.Ptr);
    }
 
    Item->Data.Ptr = NULL;
    Item->DataSize = 0;
    Item->Status   = EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
VOID
Ip6ConfigInitIfInfo (
  IN  IP6_SERVICE                    *IpSb,
  OUT EFI_IP6_CONFIG_INTERFACE_INFO  *IfInfo
  )
{
  UnicodeSPrint (
    IfInfo->Name,
    sizeof (IfInfo->Name),
    L"eth%d",
    IpSb->Ip6ConfigInstance.IfIndex
    );
 
  IfInfo->IfType        = IpSb->SnpMode.IfType;
  IfInfo->HwAddressSize = IpSb->SnpMode.HwAddressSize;
  CopyMem (&IfInfo->HwAddress, &IpSb->SnpMode.CurrentAddress, IfInfo->HwAddressSize);
}
 
EFI_STATUS
Ip6ConfigParseDhcpReply (
  IN     EFI_DHCP6_PROTOCOL   *Dhcp6,
  IN OUT IP6_CONFIG_INSTANCE  *Instance,
  IN     EFI_DHCP6_PACKET     *Reply
  )
{
  EFI_STATUS               Status;
  UINT32                   OptCount;
  EFI_DHCP6_PACKET_OPTION  **OptList;
  UINT16                   OpCode;
  UINT16                   Length;
  UINTN                    Index;
  UINTN                    Index2;
  EFI_IPv6_ADDRESS         *DnsServer;
  IP6_CONFIG_DATA_ITEM     *Item;
 
  //
  // A DHCPv6 reply packet is received as the response to our InfoRequest
  // packet.
  //
  OptCount = 0;
  Status   = Dhcp6->Parse (Dhcp6, Reply, &OptCount, NULL);
  if (Status != EFI_BUFFER_TOO_SMALL) {
    return EFI_NOT_READY;
  }
 
  OptList = AllocatePool (OptCount * sizeof (EFI_DHCP6_PACKET_OPTION *));
  if (OptList == NULL) {
    return EFI_NOT_READY;
  }
 
  Status = Dhcp6->Parse (Dhcp6, Reply, &OptCount, OptList);
  if (EFI_ERROR (Status)) {
    Status = EFI_NOT_READY;
    goto ON_EXIT;
  }
 
  Status = EFI_SUCCESS;
 
  for (Index = 0; Index < OptCount; Index++) {
    //
    // Go through all the options to check the ones we are interested in.
    // The OpCode and Length are in network byte-order and may not be naturally
    // aligned.
    //
    CopyMem (&OpCode, &OptList[Index]->OpCode, sizeof (OpCode));
    OpCode = NTOHS (OpCode);
 
    if (OpCode == DHCP6_OPT_DNS_SERVERS) {
      CopyMem (&Length, &OptList[Index]->OpLen, sizeof (Length));
      Length = NTOHS (Length);
 
      if ((Length == 0) || ((Length % sizeof (EFI_IPv6_ADDRESS)) != 0)) {
        //
        // The length should be a multiple of 16 bytes.
        //
        Status = EFI_NOT_READY;
        break;
      }
 
      //
      // Validate the DnsServers: whether they are unicast addresses.
      //
      DnsServer = (EFI_IPv6_ADDRESS *)OptList[Index]->Data;
      for (Index2 = 0; Index2 < Length / sizeof (EFI_IPv6_ADDRESS); Index2++) {
        if (!NetIp6IsValidUnicast (DnsServer)) {
          Status = EFI_NOT_READY;
          goto ON_EXIT;
        }
 
        DnsServer++;
      }
 
      Item = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];
 
      if (Item->DataSize != Length) {
        if (Item->Data.Ptr != NULL) {
          FreePool (Item->Data.Ptr);
        }
 
        Item->Data.Ptr = AllocatePool (Length);
        ASSERT (Item->Data.Ptr != NULL);
      }
 
      CopyMem (Item->Data.Ptr, OptList[Index]->Data, Length);
      Item->DataSize = Length;
      Item->Status   = EFI_SUCCESS;
 
      //
      // Signal the waiting events.
      //
      NetMapIterate (&Item->EventMap, Ip6ConfigSignalEvent, NULL);
 
      break;
    }
  }
 
ON_EXIT:
 
  FreePool (OptList);
  return Status;
}
 
VOID
Ip6ConfigSetStatefulAddrCallback (
  IN BOOLEAN           IsDadPassed,
  IN EFI_IPv6_ADDRESS  *TargetAddress,
  IN VOID              *Context
  )
{
  IP6_CONFIG_INSTANCE  *Instance;
 
  Instance = (IP6_CONFIG_INSTANCE *)Context;
  NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);
 
  //
  // We should record the addresses that fail the DAD, and DECLINE them.
  //
  if (IsDadPassed) {
    //
    // Decrease the count, no interests in those passed DAD.
    //
    if (Instance->FailedIaAddressCount > 0 ) {
      Instance->FailedIaAddressCount--;
    }
  } else {
    //
    // Record it.
    //
    IP6_COPY_ADDRESS (Instance->DeclineAddress + Instance->DeclineAddressCount, TargetAddress);
    Instance->DeclineAddressCount++;
  }
 
  if (Instance->FailedIaAddressCount == Instance->DeclineAddressCount) {
    //
    // The checking on all addresses are finished.
    //
    if (Instance->DeclineAddressCount != 0) {
      //
      // Decline those duplicates.
      //
      if (Instance->Dhcp6 != NULL) {
        Instance->Dhcp6->Decline (
                           Instance->Dhcp6,
                           Instance->DeclineAddressCount,
                           Instance->DeclineAddress
                           );
      }
    }
 
    if (Instance->DeclineAddress != NULL) {
      FreePool (Instance->DeclineAddress);
    }
 
    Instance->DeclineAddress      = NULL;
    Instance->DeclineAddressCount = 0;
  }
}
 
VOID
EFIAPI
Ip6ConfigOnDhcp6Event (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  IP6_CONFIG_INSTANCE   *Instance;
  EFI_DHCP6_PROTOCOL    *Dhcp6;
  EFI_STATUS            Status;
  EFI_DHCP6_MODE_DATA   Dhcp6ModeData;
  EFI_DHCP6_IA          *Ia;
  EFI_DHCP6_IA_ADDRESS  *IaAddr;
  UINT32                Index;
  IP6_SERVICE           *IpSb;
  IP6_ADDRESS_INFO      *AddrInfo;
  IP6_INTERFACE         *IpIf;
 
  Instance = (IP6_CONFIG_INSTANCE *)Context;
 
  if ((Instance->Policy != Ip6ConfigPolicyAutomatic) || Instance->OtherInfoOnly) {
    //
    // IPv6 is not operating in the automatic policy now or
    // the DHCPv6 information request message exchange is aborted.
    //
    return;
  }
 
  //
  // The stateful address autoconfiguration is done or updated.
  //
  Dhcp6 = Instance->Dhcp6;
 
  Status = Dhcp6->GetModeData (Dhcp6, &Dhcp6ModeData, NULL);
  if (EFI_ERROR (Status)) {
    return;
  }
 
  IpSb   = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
  IpIf   = IpSb->DefaultInterface;
  Ia     = Dhcp6ModeData.Ia;
  IaAddr = Ia->IaAddress;
 
  if (Instance->DeclineAddress != NULL) {
    FreePool (Instance->DeclineAddress);
  }
 
  Instance->DeclineAddress = (EFI_IPv6_ADDRESS *)AllocatePool (Ia->IaAddressCount * sizeof (EFI_IPv6_ADDRESS));
  if (Instance->DeclineAddress == NULL) {
    goto ON_EXIT;
  }
 
  Instance->FailedIaAddressCount = Ia->IaAddressCount;
  Instance->DeclineAddressCount  = 0;
 
  for (Index = 0; Index < Ia->IaAddressCount; Index++, IaAddr++) {
    if ((Ia->IaAddress[Index].ValidLifetime != 0) && (Ia->State == Dhcp6Bound)) {
      //
      // Set this address, either it's a new address or with updated lifetimes.
      // An appropriate prefix length will be set.
      //
      Ip6SetAddress (
        IpIf,
        &IaAddr->IpAddress,
        FALSE,
        0,
        IaAddr->ValidLifetime,
        IaAddr->PreferredLifetime,
        Ip6ConfigSetStatefulAddrCallback,
        Instance
        );
    } else {
      //
      // discard this address, artificially decrease the count as if this address
      // passed DAD.
      //
      if (Ip6IsOneOfSetAddress (IpSb, &IaAddr->IpAddress, NULL, &AddrInfo)) {
        ASSERT (AddrInfo != NULL);
        Ip6RemoveAddr (
          IpSb,
          &IpIf->AddressList,
          &IpIf->AddressCount,
          &AddrInfo->Address,
          AddrInfo->PrefixLength
          );
      }
 
      if (Instance->FailedIaAddressCount > 0) {
        Instance->FailedIaAddressCount--;
      }
    }
  }
 
  //
  // Parse the Reply packet to get the options we need.
  //
  if (Dhcp6ModeData.Ia->ReplyPacket != NULL) {
    Ip6ConfigParseDhcpReply (Dhcp6, Instance, Dhcp6ModeData.Ia->ReplyPacket);
  }
 
ON_EXIT:
 
  FreePool (Dhcp6ModeData.ClientId);
  FreePool (Dhcp6ModeData.Ia);
}
 
EFI_STATUS
EFIAPI
Ip6ConfigOnDhcp6Reply (
  IN EFI_DHCP6_PROTOCOL  *This,
  IN VOID                *Context,
  IN EFI_DHCP6_PACKET    *Packet
  )
{
  return Ip6ConfigParseDhcpReply (This, (IP6_CONFIG_INSTANCE *)Context, Packet);
}
 
VOID
EFIAPI
Ip6ConfigOnDhcp6SbInstalled (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  IP6_CONFIG_INSTANCE  *Instance;
 
  Instance = (IP6_CONFIG_INSTANCE *)Context;
 
  if ((Instance->Dhcp6Handle != NULL) || (Instance->Policy != Ip6ConfigPolicyAutomatic)) {
    //
    // The DHCP6 child is already created or the policy is no longer AUTOMATIC.
    //
    return;
  }
 
  Ip6ConfigStartStatefulAutoConfig (Instance, Instance->OtherInfoOnly);
}
 
EFI_STATUS
EFIAPI
EfiIp6ConfigSetData (
  IN EFI_IP6_CONFIG_PROTOCOL   *This,
  IN EFI_IP6_CONFIG_DATA_TYPE  DataType,
  IN UINTN                     DataSize,
  IN VOID                      *Data
  )
{
  EFI_TPL              OldTpl;
  EFI_STATUS           Status;
  IP6_CONFIG_INSTANCE  *Instance;
  IP6_SERVICE          *IpSb;
 
  if ((This == NULL) || ((Data == NULL) && (DataSize != 0)) || ((Data != NULL) && (DataSize == 0))) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip6ConfigDataTypeMaximum) {
    return EFI_UNSUPPORTED;
  }
 
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);
  IpSb     = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  if (IpSb->LinkLocalDadFail) {
    return EFI_DEVICE_ERROR;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Status = Instance->DataItem[DataType].Status;
  if (Status != EFI_NOT_READY) {
    if (Instance->DataItem[DataType].SetData == NULL) {
      //
      // This type of data is readonly.
      //
      Status = EFI_WRITE_PROTECTED;
    } else {
      Status = Instance->DataItem[DataType].SetData (Instance, DataSize, Data);
      if (!EFI_ERROR (Status)) {
        //
        // Fire up the events registered with this type of data.
        //
        NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip6ConfigSignalEvent, NULL);
        Ip6ConfigWriteConfigData (IpSb->MacString, Instance);
      } else if (Status == EFI_ABORTED) {
        //
        // The SetData is aborted because the data to set is the same with
        // the one maintained.
        //
        Status = EFI_SUCCESS;
        NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip6ConfigSignalEvent, NULL);
      }
    }
  } else {
    //
    // Another asynchronous process is on the way.
    //
    Status = EFI_ACCESS_DENIED;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiIp6ConfigGetData (
  IN EFI_IP6_CONFIG_PROTOCOL   *This,
  IN EFI_IP6_CONFIG_DATA_TYPE  DataType,
  IN OUT UINTN                 *DataSize,
  IN VOID                      *Data   OPTIONAL
  )
{
  EFI_TPL               OldTpl;
  EFI_STATUS            Status;
  IP6_CONFIG_INSTANCE   *Instance;
  IP6_CONFIG_DATA_ITEM  *DataItem;
 
  if ((This == NULL) || (DataSize == NULL) || ((*DataSize != 0) && (Data == NULL))) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip6ConfigDataTypeMaximum) {
    return EFI_NOT_FOUND;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);
  DataItem = &Instance->DataItem[DataType];
 
  Status = Instance->DataItem[DataType].Status;
  if (!EFI_ERROR (Status)) {
    if (DataItem->GetData != NULL) {
      Status = DataItem->GetData (Instance, DataSize, Data);
    } else if (*DataSize < Instance->DataItem[DataType].DataSize) {
      //
      // Update the buffer length.
      //
      *DataSize = Instance->DataItem[DataType].DataSize;
      Status    = EFI_BUFFER_TOO_SMALL;
    } else {
      *DataSize = Instance->DataItem[DataType].DataSize;
      CopyMem (Data, Instance->DataItem[DataType].Data.Ptr, *DataSize);
    }
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiIp6ConfigRegisterDataNotify (
  IN EFI_IP6_CONFIG_PROTOCOL   *This,
  IN EFI_IP6_CONFIG_DATA_TYPE  DataType,
  IN EFI_EVENT                 Event
  )
{
  EFI_TPL              OldTpl;
  EFI_STATUS           Status;
  IP6_CONFIG_INSTANCE  *Instance;
  NET_MAP              *EventMap;
  NET_MAP_ITEM         *Item;
 
  if ((This == NULL) || (Event == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip6ConfigDataTypeMaximum) {
    return EFI_UNSUPPORTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);
  EventMap = &Instance->DataItem[DataType].EventMap;
 
  //
  // Check whether this event is already registered for this DataType.
  //
  Item = NetMapFindKey (EventMap, Event);
  if (Item == NULL) {
    Status = NetMapInsertTail (EventMap, Event, NULL);
 
    if (EFI_ERROR (Status)) {
      Status = EFI_OUT_OF_RESOURCES;
    }
  } else {
    Status = EFI_ACCESS_DENIED;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiIp6ConfigUnregisterDataNotify (
  IN EFI_IP6_CONFIG_PROTOCOL   *This,
  IN EFI_IP6_CONFIG_DATA_TYPE  DataType,
  IN EFI_EVENT                 Event
  )
{
  EFI_TPL              OldTpl;
  EFI_STATUS           Status;
  IP6_CONFIG_INSTANCE  *Instance;
  NET_MAP_ITEM         *Item;
 
  if ((This == NULL) || (Event == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (DataType >= Ip6ConfigDataTypeMaximum) {
    return EFI_NOT_FOUND;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);
 
  Item = NetMapFindKey (&Instance->DataItem[DataType].EventMap, Event);
  if (Item != NULL) {
    NetMapRemoveItem (&Instance->DataItem[DataType].EventMap, Item, NULL);
    Status = EFI_SUCCESS;
  } else {
    Status = EFI_NOT_FOUND;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
Ip6ConfigInitInstance (
  OUT IP6_CONFIG_INSTANCE  *Instance
  )
{
  IP6_SERVICE           *IpSb;
  IP6_CONFIG_INSTANCE   *TmpInstance;
  LIST_ENTRY            *Entry;
  EFI_STATUS            Status;
  UINTN                 Index;
  UINT16                IfIndex;
  IP6_CONFIG_DATA_ITEM  *DataItem;
  UINT32                Random;
 
  Status = PseudoRandomU32 (&Random);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a failed to generate random number: %r\n", __func__, Status));
    return Status;
  }
 
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
 
  Instance->Signature = IP6_CONFIG_INSTANCE_SIGNATURE;
 
  //
  // Determine the index of this interface.
  //
  IfIndex = 0;
  NET_LIST_FOR_EACH (Entry, &mIp6ConfigInstanceList) {
    TmpInstance = NET_LIST_USER_STRUCT_S (Entry, IP6_CONFIG_INSTANCE, Link, IP6_CONFIG_INSTANCE_SIGNATURE);
 
    if (TmpInstance->IfIndex > IfIndex) {
      //
      // There is a sequence hole because some interface is down.
      //
      break;
    }
 
    IfIndex++;
  }
 
  Instance->IfIndex = IfIndex;
  NetListInsertBefore (Entry, &Instance->Link);
 
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {
    //
    // Initialize the event map for each data item.
    //
    NetMapInit (&Instance->DataItem[Index].EventMap);
  }
 
  //
  // Initialize the NET_MAPs used for DAD on manually configured source addresses.
  //
  NetMapInit (&Instance->DadFailedMap);
  NetMapInit (&Instance->DadPassedMap);
 
  //
  // Initialize each data type: associate storage and set data size for the
  // fixed size data types, hook the SetData function, set the data attribute.
  //
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeInterfaceInfo];
  DataItem->GetData  = Ip6ConfigGetIfInfo;
  DataItem->Data.Ptr = &Instance->InterfaceInfo;
  DataItem->DataSize = sizeof (Instance->InterfaceInfo);
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED | DATA_ATTRIB_VOLATILE);
  Ip6ConfigInitIfInfo (IpSb, &Instance->InterfaceInfo);
 
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeAltInterfaceId];
  DataItem->SetData  = Ip6ConfigSetAltIfId;
  DataItem->Data.Ptr = &Instance->AltIfId;
  DataItem->DataSize = sizeof (Instance->AltIfId);
  DataItem->Status   = EFI_NOT_FOUND;
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);
 
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypePolicy];
  DataItem->SetData  = Ip6ConfigSetPolicy;
  DataItem->Data.Ptr = &Instance->Policy;
  DataItem->DataSize = sizeof (Instance->Policy);
  Instance->Policy   = Ip6ConfigPolicyManual;
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);
 
  DataItem                                  = &Instance->DataItem[Ip6ConfigDataTypeDupAddrDetectTransmits];
  DataItem->SetData                         = Ip6ConfigSetDadXmits;
  DataItem->Data.Ptr                        = &Instance->DadXmits;
  DataItem->DataSize                        = sizeof (Instance->DadXmits);
  Instance->DadXmits.DupAddrDetectTransmits = IP6_CONFIG_DEFAULT_DAD_XMITS;
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);
 
  DataItem          = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];
  DataItem->SetData = Ip6ConfigSetManualAddress;
  DataItem->Status  = EFI_NOT_FOUND;
 
  DataItem          = &Instance->DataItem[Ip6ConfigDataTypeGateway];
  DataItem->SetData = Ip6ConfigSetGateway;
  DataItem->Status  = EFI_NOT_FOUND;
 
  DataItem          = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];
  DataItem->SetData = Ip6ConfigSetDnsServer;
  DataItem->Status  = EFI_NOT_FOUND;
 
  //
  // Create the event used for DHCP.
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  Ip6ConfigOnDhcp6Event,
                  Instance,
                  &Instance->Dhcp6Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  Instance->Configured = TRUE;
 
  //
  // Try to read the config data from NV variable.
  //
  Status = Ip6ConfigReadConfigData (IpSb->MacString, Instance);
  if (Status == EFI_NOT_FOUND) {
    //
    // The NV variable is not set, so generate a random IAID, and write down the
    // fresh new configuration as the NV variable now.
    //
    Instance->IaId = Random;
 
    for (Index = 0; Index < IpSb->SnpMode.HwAddressSize; Index++) {
      Instance->IaId |= (IpSb->SnpMode.CurrentAddress.Addr[Index] << ((Index << 3) & 31));
    }
 
    Ip6ConfigWriteConfigData (IpSb->MacString, Instance);
  } else if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Instance->Ip6Config.SetData              = EfiIp6ConfigSetData;
  Instance->Ip6Config.GetData              = EfiIp6ConfigGetData;
  Instance->Ip6Config.RegisterDataNotify   = EfiIp6ConfigRegisterDataNotify;
  Instance->Ip6Config.UnregisterDataNotify = EfiIp6ConfigUnregisterDataNotify;
 
  //
  // Publish the IP6 configuration form
  //
  return Ip6ConfigFormInit (Instance);
}
 
VOID
Ip6ConfigCleanInstance (
  IN OUT IP6_CONFIG_INSTANCE  *Instance
  )
{
  UINTN                 Index;
  IP6_CONFIG_DATA_ITEM  *DataItem;
 
  if (Instance->DeclineAddress != NULL) {
    FreePool (Instance->DeclineAddress);
  }
 
  if (!Instance->Configured) {
    return;
  }
 
  if (Instance->Dhcp6Handle != NULL) {
    Ip6ConfigDestroyDhcp6 (Instance);
  }
 
  //
  // Close the event.
  //
  if (Instance->Dhcp6Event != NULL) {
    gBS->CloseEvent (Instance->Dhcp6Event);
  }
 
  NetMapClean (&Instance->DadPassedMap);
  NetMapClean (&Instance->DadFailedMap);
 
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {
    DataItem = &Instance->DataItem[Index];
 
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
      if (DataItem->Data.Ptr != NULL) {
        FreePool (DataItem->Data.Ptr);
      }
 
      DataItem->Data.Ptr = NULL;
      DataItem->DataSize = 0;
    }
 
    NetMapClean (&Instance->DataItem[Index].EventMap);
  }
 
  Ip6ConfigFormUnload (Instance);
 
  RemoveEntryList (&Instance->Link);
}
 
EFI_STATUS
Ip6ConfigDestroyDhcp6 (
  IN OUT IP6_CONFIG_INSTANCE  *Instance
  )
{
  IP6_SERVICE         *IpSb;
  EFI_STATUS          Status;
  EFI_DHCP6_PROTOCOL  *Dhcp6;
 
  Dhcp6 = Instance->Dhcp6;
  ASSERT (Dhcp6 != NULL);
 
  Dhcp6->Stop (Dhcp6);
  Dhcp6->Configure (Dhcp6, NULL);
  Instance->Dhcp6 = NULL;
 
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);
 
  //
  // Close DHCPv6 protocol and destroy the child.
  //
  Status = gBS->CloseProtocol (
                  Instance->Dhcp6Handle,
                  &gEfiDhcp6ProtocolGuid,
                  IpSb->Image,
                  IpSb->Controller
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = NetLibDestroyServiceChild (
             IpSb->Controller,
             IpSb->Image,
             &gEfiDhcp6ServiceBindingProtocolGuid,
             Instance->Dhcp6Handle
             );
 
  Instance->Dhcp6Handle = NULL;
 
  return Status;
}