[mirror_edk2.git] / NetworkPkg / Ip6Dxe / Ip6ConfigImpl.c

/** @file\r
  The implementation of EFI IPv6 Configuration Protocol.\r
\r
  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>\r
\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php.\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "Ip6Impl.h"\r
\r
LIST_ENTRY  mIp6ConfigInstanceList = {&mIp6ConfigInstanceList, &mIp6ConfigInstanceList};\r
\r
/**\r
  The event process routine when the DHCPv6 service binding protocol is installed\r
  in the system.\r
\r
  @param[in]     Event         Not used.\r
  @param[in]     Context       Pointer to the IP6 config instance data.\r
\r
**/\r
VOID\r
EFIAPI\r
Ip6ConfigOnDhcp6SbInstalled (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  );\r
\r
/**\r
  Update the current policy to NewPolicy. During the transition\r
  period, the default router list, on-link prefix list, autonomous prefix list\r
  and address list in all interfaces will be released.\r
\r
  @param[in]  IpSb               The IP6 service binding instance.\r
  @param[in]  NewPolicy          The new policy to be updated to.\r
\r
**/\r
VOID\r
Ip6ConfigOnPolicyChanged (\r
  IN IP6_SERVICE            *IpSb,\r
  IN EFI_IP6_CONFIG_POLICY  NewPolicy\r
  )\r
{\r
  LIST_ENTRY      *Entry;\r
  LIST_ENTRY      *Entry2;\r
  LIST_ENTRY      *Next;\r
  IP6_INTERFACE   *IpIf;\r
  IP6_DAD_ENTRY   *DadEntry;\r
  IP6_DELAY_JOIN_LIST       *DelayNode;\r
  \r
  //\r
  // Currently there are only two policies: Manual and Automatic. Regardless of\r
  // what transition is going on, i.e., Manual -> Automatic and Automatic ->\r
  // Manual, we have to free default router list, on-link prefix list, autonomous\r
  // prefix list, address list in all the interfaces and destroy any IPv6 child\r
  // instance whose local IP is neither 0 nor the link-local address.\r
  //\r
  Ip6CleanDefaultRouterList (IpSb);\r
  Ip6CleanPrefixListTable (IpSb, &IpSb->OnlinkPrefix);\r
  Ip6CleanPrefixListTable (IpSb, &IpSb->AutonomousPrefix);\r
\r
  //\r
  // It's tricky... If the LinkLocal address is O.K., add back the link-local\r
  // prefix to the on-link prefix table.\r
  //\r
  if (IpSb->LinkLocalOk) {\r
    Ip6CreatePrefixListEntry (\r
      IpSb,\r
      TRUE,\r
      (UINT32) IP6_INFINIT_LIFETIME,\r
      (UINT32) IP6_INFINIT_LIFETIME,\r
      IP6_LINK_LOCAL_PREFIX_LENGTH,\r
      &IpSb->LinkLocalAddr\r
      );\r
  }\r
\r
  //\r
  // All IPv6 children that use global unicast address as it's source address\r
  // should be destryoed now. The survivers are those use the link-local address\r
  // or the unspecified address as the source address.\r
  // TODO: Conduct a check here.\r
  Ip6RemoveAddr (\r
    IpSb,\r
    &IpSb->DefaultInterface->AddressList,\r
    &IpSb->DefaultInterface->AddressCount,\r
    NULL,\r
    0\r
    );\r
\r
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {\r
    //\r
    // remove all pending delay node and DAD entries for the global addresses.\r
    //\r
    IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);\r
\r
    NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DelayJoinList) {\r
      DelayNode = NET_LIST_USER_STRUCT (Entry2, IP6_DELAY_JOIN_LIST, Link);\r
      if (!NetIp6IsLinkLocalAddr (&DelayNode->AddressInfo->Address)) {\r
        RemoveEntryList (&DelayNode->Link);\r
        FreePool (DelayNode);\r
      }\r
    }\r
\r
    NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DupAddrDetectList) {\r
      DadEntry = NET_LIST_USER_STRUCT_S (Entry2, IP6_DAD_ENTRY, Link, IP6_DAD_ENTRY_SIGNATURE);\r
\r
      if (!NetIp6IsLinkLocalAddr (&DadEntry->AddressInfo->Address)) {\r
        //\r
        // Fail this DAD entry if the address is not link-local.\r
        //\r
        Ip6OnDADFinished (FALSE, IpIf, DadEntry);\r
      }\r
    }\r
  }\r
\r
  if (NewPolicy == Ip6ConfigPolicyAutomatic) {\r
    //\r
    // Set paramters to trigger router solicitation sending in timer handler.\r
    //\r
    IpSb->RouterAdvertiseReceived = FALSE;\r
    IpSb->SolicitTimer            = IP6_MAX_RTR_SOLICITATIONS;\r
    //\r
    // delay 1 second\r
    //\r
    IpSb->Ticks                   = (UINT32) IP6_GET_TICKS (IP6_ONE_SECOND_IN_MS);\r
  }\r
\r
}\r
\r
/**\r
  The work function to trigger the DHCPv6 process to perform a stateful autoconfiguration.\r
\r
  @param[in]     Instance      Pointer to the IP6 config instance data.\r
  @param[in]     OtherInfoOnly If FALSE, get stateful address and other information\r
                               via DHCPv6. Otherwise, only get the other information.\r
\r
  @retval    EFI_SUCCESS       The operation finished successfully.\r
  @retval    EFI_UNSUPPORTED   The DHCP6 driver is not available.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigStartStatefulAutoConfig (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN BOOLEAN              OtherInfoOnly\r
  )\r
{\r
  EFI_STATUS                Status;\r
  IP6_SERVICE               *IpSb;\r
  EFI_DHCP6_CONFIG_DATA     Dhcp6CfgData;\r
  EFI_DHCP6_PROTOCOL        *Dhcp6;\r
  EFI_DHCP6_PACKET_OPTION   *OptList[1];\r
  UINT16                    OptBuf[4];\r
  EFI_DHCP6_PACKET_OPTION   *Oro;\r
  EFI_DHCP6_RETRANSMISSION  InfoReqReXmit;\r
\r
  //\r
  // A host must not invoke stateful address configuration if it is already\r
  // participating in the statuful protocol as a result of an earlier advertisement.\r
  //\r
  if (Instance->Dhcp6Handle != NULL) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
\r
  Instance->OtherInfoOnly = OtherInfoOnly;\r
\r
  Status = NetLibCreateServiceChild (\r
             IpSb->Controller,\r
             IpSb->Image,\r
             &gEfiDhcp6ServiceBindingProtocolGuid,\r
             &Instance->Dhcp6Handle\r
             );\r
\r
  if (Status == EFI_UNSUPPORTED) {\r
    //\r
    // No DHCPv6 Service Binding protocol, register a notify.\r
    //\r
    if (Instance->Dhcp6SbNotifyEvent == NULL) {\r
      Instance->Dhcp6SbNotifyEvent = EfiCreateProtocolNotifyEvent (\r
                                       &gEfiDhcp6ServiceBindingProtocolGuid,\r
                                       TPL_CALLBACK,\r
                                       Ip6ConfigOnDhcp6SbInstalled,\r
                                       (VOID *) Instance,\r
                                       &Instance->Registration\r
                                       );\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (Instance->Dhcp6SbNotifyEvent != NULL) {\r
    gBS->CloseEvent (Instance->Dhcp6SbNotifyEvent);\r
  }\r
\r
  Status = gBS->OpenProtocol (\r
                  Instance->Dhcp6Handle,\r
                  &gEfiDhcp6ProtocolGuid,\r
                  (VOID **) &Instance->Dhcp6,\r
                  IpSb->Image,\r
                  IpSb->Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Dhcp6 = Instance->Dhcp6;\r
  Dhcp6->Configure (Dhcp6, NULL);\r
\r
  //\r
  // Set the exta options to send. Here we only want the option request option\r
  // with DNS SERVERS.\r
  //\r
  Oro                         = (EFI_DHCP6_PACKET_OPTION *) OptBuf;\r
  Oro->OpCode                 = HTONS (IP6_CONFIG_DHCP6_OPTION_ORO);\r
  Oro->OpLen                  = HTONS (2);\r
  *((UINT16 *) &Oro->Data[0]) = HTONS (IP6_CONFIG_DHCP6_OPTION_DNS_SERVERS);\r
  OptList[0]                  = Oro;\r
\r
  Status                      = EFI_SUCCESS;\r
\r
  if (!OtherInfoOnly) {\r
    //\r
    // Get stateful address and other information via DHCPv6.\r
    //\r
    Dhcp6CfgData.Dhcp6Callback         = NULL;\r
    Dhcp6CfgData.CallbackContext       = NULL;\r
    Dhcp6CfgData.OptionCount           = 1;\r
    Dhcp6CfgData.OptionList            = &OptList[0];\r
    Dhcp6CfgData.IaDescriptor.Type     = EFI_DHCP6_IA_TYPE_NA;\r
    Dhcp6CfgData.IaDescriptor.IaId     = Instance->IaId;\r
    Dhcp6CfgData.IaInfoEvent           = Instance->Dhcp6Event;\r
    Dhcp6CfgData.ReconfigureAccept     = FALSE;\r
    Dhcp6CfgData.RapidCommit           = FALSE;\r
    Dhcp6CfgData.SolicitRetransmission = NULL;\r
\r
    Status = Dhcp6->Configure (Dhcp6, &Dhcp6CfgData);\r
\r
    if (!EFI_ERROR (Status)) {\r
\r
      if (IpSb->LinkLocalOk) {\r
        Status = Dhcp6->Start (Dhcp6);\r
      } else {\r
        IpSb->Dhcp6NeedStart = TRUE;\r
      }\r
\r
    }\r
  } else {\r
    //\r
    // Only get other information via DHCPv6, this doesn't require a config\r
    // action.\r
    //\r
    InfoReqReXmit.Irt = 4;\r
    InfoReqReXmit.Mrc = 64;\r
    InfoReqReXmit.Mrt = 60;\r
    InfoReqReXmit.Mrd = 0;\r
\r
    if (IpSb->LinkLocalOk) {\r
      Status = Dhcp6->InfoRequest (\r
                        Dhcp6,\r
                        TRUE,\r
                        Oro,\r
                        0,\r
                        NULL,\r
                        &InfoReqReXmit,\r
                        Instance->Dhcp6Event,\r
                        Ip6ConfigOnDhcp6Reply,\r
                        Instance\r
                        );\r
    } else {\r
      IpSb->Dhcp6NeedInfoRequest = TRUE;\r
    }\r
\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Signal the registered event. It is the callback routine for NetMapIterate.\r
\r
  @param[in]  Map    Points to the list of registered event.\r
  @param[in]  Item   The registered event.\r
  @param[in]  Arg    Not used.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
Ip6ConfigSignalEvent (\r
  IN NET_MAP                *Map,\r
  IN NET_MAP_ITEM           *Item,\r
  IN VOID                   *Arg\r
  )\r
{\r
  gBS->SignalEvent ((EFI_EVENT) Item->Key);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Read the configuration data from variable storage according to the VarName and\r
  gEfiIp6ConfigProtocolGuid. It checks the integrity of variable data. If the\r
  data is corrupted, it clears the variable data to ZERO. Othewise, it outputs the\r
  configuration data to IP6_CONFIG_INSTANCE.\r
\r
  @param[in]      VarName  The pointer to the variable name\r
  @param[in, out] Instance The pointer to the IP6 config instance data.\r
\r
  @retval EFI_NOT_FOUND         The variable can not be found or already corrupted.\r
  @retval EFI_OUT_OF_RESOURCES  Fail to allocate resource to complete the operation.\r
  @retval EFI_SUCCESS           The configuration data was retrieved successfully.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigReadConfigData (\r
  IN     CHAR16               *VarName,\r
  IN OUT IP6_CONFIG_INSTANCE  *Instance\r
  )\r
{\r
  EFI_STATUS              Status;\r
  UINTN                   VarSize;\r
  IP6_CONFIG_VARIABLE     *Variable;\r
  IP6_CONFIG_DATA_ITEM    *DataItem;\r
  UINTN                   Index;\r
  IP6_CONFIG_DATA_RECORD  DataRecord;\r
  CHAR8                   *Data;\r
\r
  //\r
  // Try to read the configuration variable.\r
  //\r
  VarSize = 0;\r
  Status  = gRT->GetVariable (\r
                   VarName,\r
                   &gEfiIp6ConfigProtocolGuid,\r
                   NULL,\r
                   &VarSize,\r
                   NULL\r
                   );\r
\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    //\r
    // Allocate buffer and read the config variable.\r
    //\r
    Variable = AllocatePool (VarSize);\r
    if (Variable == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Status = gRT->GetVariable (\r
                    VarName,\r
                    &gEfiIp6ConfigProtocolGuid,\r
                    NULL,\r
                    &VarSize,\r
                    Variable\r
                    );\r
    if (EFI_ERROR (Status) || (UINT16) (~NetblockChecksum ((UINT8 *) Variable, (UINT32) VarSize)) != 0) {\r
      //\r
      // GetVariable still error or the variable is corrupted.\r
      // Fall back to the default value.\r
      //\r
      FreePool (Variable);\r
\r
      //\r
      // Remove the problematic variable and return EFI_NOT_FOUND, a new\r
      // variable will be set again.\r
      //\r
      gRT->SetVariable (\r
             VarName,\r
             &gEfiIp6ConfigProtocolGuid,\r
             IP6_CONFIG_VARIABLE_ATTRIBUTE,\r
             0,\r
             NULL\r
             );\r
\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    //\r
    // Get the IAID we use.\r
    //\r
    Instance->IaId = Variable->IaId;\r
\r
    for (Index = 0; Index < Variable->DataRecordCount; Index++) {\r
\r
      CopyMem (&DataRecord, &Variable->DataRecord[Index], sizeof (DataRecord));\r
\r
      DataItem = &Instance->DataItem[DataRecord.DataType];\r
      if (DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED) &&\r
          (DataItem->DataSize != DataRecord.DataSize)\r
          ) {\r
        //\r
        // Perhaps a corrupted data record...\r
        //\r
        continue;\r
      }\r
\r
      if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {\r
        //\r
        // This data item has variable length data.\r
        //\r
        DataItem->Data.Ptr = AllocatePool (DataRecord.DataSize);\r
        if (DataItem->Data.Ptr == NULL) {\r
          //\r
          // no memory resource\r
          //\r
          continue;\r
        }\r
      }\r
\r
      Data = (CHAR8 *) Variable + DataRecord.Offset;\r
      CopyMem (DataItem->Data.Ptr, Data, DataRecord.DataSize);\r
\r
      DataItem->DataSize = DataRecord.DataSize;\r
      DataItem->Status   = EFI_SUCCESS;\r
    }\r
\r
    FreePool (Variable);\r
    return EFI_SUCCESS;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Write the configuration data from IP6_CONFIG_INSTANCE to variable storage.\r
\r
  @param[in]      VarName  The pointer to the variable name.\r
  @param[in]      Instance The pointer to the IP6 configuration instance data.\r
\r
  @retval EFI_OUT_OF_RESOURCES  Fail to allocate resource to complete the operation.\r
  @retval EFI_SUCCESS           The configuration data is written successfully.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigWriteConfigData (\r
  IN CHAR16               *VarName,\r
  IN IP6_CONFIG_INSTANCE  *Instance\r
  )\r
{\r
  UINTN                   Index;\r
  UINTN                   VarSize;\r
  IP6_CONFIG_DATA_ITEM    *DataItem;\r
  IP6_CONFIG_VARIABLE     *Variable;\r
  IP6_CONFIG_DATA_RECORD  *DataRecord;\r
  CHAR8                   *Heap;\r
  EFI_STATUS              Status;\r
\r
  VarSize = sizeof (IP6_CONFIG_VARIABLE) - sizeof (IP6_CONFIG_DATA_RECORD);\r
\r
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {\r
\r
    DataItem = &Instance->DataItem[Index];\r
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {\r
\r
      VarSize += sizeof (IP6_CONFIG_DATA_RECORD) + DataItem->DataSize;\r
    }\r
  }\r
\r
  Variable = AllocatePool (VarSize);\r
  if (Variable == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Variable->IaId            = Instance->IaId;\r
  Heap                      = (CHAR8 *) Variable + VarSize;\r
  Variable->DataRecordCount = 0;\r
\r
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {\r
\r
    DataItem = &Instance->DataItem[Index];\r
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {\r
\r
      Heap -= DataItem->DataSize;\r
      CopyMem (Heap, DataItem->Data.Ptr, DataItem->DataSize);\r
\r
      DataRecord           = &Variable->DataRecord[Variable->DataRecordCount];\r
      DataRecord->DataType = (EFI_IP6_CONFIG_DATA_TYPE) Index;\r
      DataRecord->DataSize = (UINT32) DataItem->DataSize;\r
      DataRecord->Offset   = (UINT16) (Heap - (CHAR8 *) Variable);\r
\r
      Variable->DataRecordCount++;\r
    }\r
  }\r
\r
  Variable->Checksum = 0;\r
  Variable->Checksum = (UINT16) ~NetblockChecksum ((UINT8 *) Variable, (UINT32) VarSize);\r
\r
  Status = gRT->SetVariable (\r
                  VarName,\r
                  &gEfiIp6ConfigProtocolGuid,\r
                  IP6_CONFIG_VARIABLE_ATTRIBUTE,\r
                  VarSize,\r
                  Variable\r
                  );\r
\r
  FreePool (Variable);\r
\r
  return Status;\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigGetData() to get the interface information\r
  of the communication device this IP6Config instance manages.\r
\r
  @param[in]      Instance Pointer to the IP6 config instance data.\r
  @param[in, out] DataSize On input, in bytes, the size of Data. On output, in\r
                           bytes, the size of buffer required to store the specified\r
                           configuration data.\r
  @param[in]      Data     The data buffer in which the configuration data is returned.\r
                           Ignored if DataSize is ZERO.\r
\r
  @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified\r
                               configuration data, and the required size is\r
                               returned in DataSize.\r
  @retval EFI_SUCCESS          The specified configuration data was obtained.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigGetIfInfo (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN OUT UINTN            *DataSize,\r
  IN VOID                 *Data      OPTIONAL\r
  )\r
{\r
  IP6_SERVICE                    *IpSb;\r
  UINTN                          Length;\r
  IP6_CONFIG_DATA_ITEM           *Item;\r
  EFI_IP6_CONFIG_INTERFACE_INFO  *IfInfo;\r
  UINT32                         AddressCount;\r
  UINT32                         RouteCount;\r
\r
  IpSb   = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
  Length = sizeof (EFI_IP6_CONFIG_INTERFACE_INFO);\r
\r
  //\r
  // Calculate the required length, add the buffer size for AddressInfo and\r
  // RouteTable\r
  //\r
  Ip6BuildEfiAddressList (IpSb, &AddressCount, NULL);\r
  Ip6BuildEfiRouteTable (IpSb->RouteTable, &RouteCount, NULL);\r
\r
  Length += AddressCount * sizeof (EFI_IP6_ADDRESS_INFO) + RouteCount * sizeof (EFI_IP6_ROUTE_TABLE);\r
\r
  if (*DataSize < Length) {\r
    *DataSize = Length;\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Copy the fixed size part of the interface info.\r
  //\r
  Item = &Instance->DataItem[Ip6ConfigDataTypeInterfaceInfo];\r
  IfInfo = (EFI_IP6_CONFIG_INTERFACE_INFO *) Data;\r
  CopyMem (IfInfo, Item->Data.Ptr, sizeof (EFI_IP6_CONFIG_INTERFACE_INFO));\r
\r
  //\r
  // AddressInfo\r
  //\r
  IfInfo->AddressInfo = (EFI_IP6_ADDRESS_INFO *) (IfInfo + 1);\r
  Ip6BuildEfiAddressList (IpSb, &IfInfo->AddressInfoCount, &IfInfo->AddressInfo);\r
\r
  //\r
  // RouteTable\r
  //\r
  IfInfo->RouteTable = (EFI_IP6_ROUTE_TABLE *) (IfInfo->AddressInfo + IfInfo->AddressInfoCount);\r
  Ip6BuildEfiRouteTable (IpSb->RouteTable, &IfInfo->RouteCount, &IfInfo->RouteTable);\r
\r
  if (IfInfo->AddressInfoCount == 0) {\r
    IfInfo->AddressInfo = NULL;\r
  }\r
\r
  if (IfInfo->RouteCount == 0) {\r
    IfInfo->RouteTable = NULL;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigSetData() to set the alternative inteface ID\r
  for the communication device managed by this IP6Config instance, if the link local\r
  IPv6 addresses generated from the interface ID based on the default source the\r
  EFI IPv6 Protocol uses is a duplicate address.\r
\r
  @param[in]     Instance Pointer to the IP6 configuration instance data.\r
  @param[in]     DataSize Size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data     The data buffer to set.\r
\r
  @retval EFI_BAD_BUFFER_SIZE  The DataSize does not match the size of the type,\r
                               8 bytes.\r
  @retval EFI_SUCCESS          The specified configuration data for the EFI IPv6\r
                               network stack was set.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigSetAltIfId (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN UINTN                DataSize,\r
  IN VOID                 *Data\r
  )\r
{\r
  EFI_IP6_CONFIG_INTERFACE_ID  *OldIfId;\r
  EFI_IP6_CONFIG_INTERFACE_ID  *NewIfId;\r
  IP6_CONFIG_DATA_ITEM         *DataItem;\r
\r
  if (DataSize != sizeof (EFI_IP6_CONFIG_INTERFACE_ID)) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  DataItem = &Instance->DataItem[Ip6ConfigDataTypeAltInterfaceId];\r
  OldIfId  = DataItem->Data.AltIfId;\r
  NewIfId  = (EFI_IP6_CONFIG_INTERFACE_ID *) Data;\r
\r
  CopyMem (OldIfId, NewIfId, DataSize);\r
  DataItem->Status = EFI_SUCCESS;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigSetData() to set the general configuration\r
  policy for the EFI IPv6 network stack that is running on the communication device\r
  managed by this IP6Config instance. The policy will affect other configuration settings.\r
\r
  @param[in]     Instance Pointer to the IP6 config instance data.\r
  @param[in]     DataSize Size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data     The data buffer to set.\r
\r
  @retval EFI_INVALID_PARAMETER The to be set policy is invalid.\r
  @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.\r
  @retval EFI_ABORTED           The new policy equals the current policy.\r
  @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6\r
                                network stack was set.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigSetPolicy (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN UINTN                DataSize,\r
  IN VOID                 *Data\r
  )\r
{\r
  EFI_IP6_CONFIG_POLICY  NewPolicy;\r
  IP6_CONFIG_DATA_ITEM   *DataItem;\r
  IP6_SERVICE            *IpSb;\r
\r
  if (DataSize != sizeof (EFI_IP6_CONFIG_POLICY)) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  NewPolicy = *((EFI_IP6_CONFIG_POLICY *) Data);\r
\r
  if (NewPolicy > Ip6ConfigPolicyAutomatic) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (NewPolicy == Instance->Policy) {\r
\r
    return EFI_ABORTED;\r
  } else {\r
\r
    if (NewPolicy == Ip6ConfigPolicyAutomatic) {\r
      //\r
      // Clean the ManualAddress, Gateway and DnsServers, shrink the variable\r
      // data size, and fire up all the related events.\r
      //\r
      DataItem           = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];\r
      if (DataItem->Data.Ptr != NULL) {\r
        FreePool (DataItem->Data.Ptr);\r
      }\r
      DataItem->Data.Ptr = NULL;\r
      DataItem->DataSize = 0;\r
      DataItem->Status   = EFI_NOT_FOUND;\r
      NetMapIterate (&DataItem->EventMap, Ip6ConfigSignalEvent, NULL);\r
\r
      DataItem           = &Instance->DataItem[Ip6ConfigDataTypeGateway];\r
      if (DataItem->Data.Ptr != NULL) {\r
        FreePool (DataItem->Data.Ptr);\r
      }\r
      DataItem->Data.Ptr = NULL;\r
      DataItem->DataSize = 0;\r
      DataItem->Status   = EFI_NOT_FOUND;\r
      NetMapIterate (&DataItem->EventMap, Ip6ConfigSignalEvent, NULL);\r
\r
      DataItem           = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];\r
      DataItem->Data.Ptr = NULL;\r
      DataItem->DataSize = 0;\r
      DataItem->Status   = EFI_NOT_FOUND;\r
      NetMapIterate (&DataItem->EventMap, Ip6ConfigSignalEvent, NULL);\r
    } else {\r
      //\r
      // The policy is changed from automatic to manual. Stop the DHCPv6 process\r
      // and destroy the DHCPv6 child.\r
      //\r
      if (Instance->Dhcp6Handle != NULL) {\r
        Ip6ConfigDestroyDhcp6 (Instance);\r
      }\r
    }\r
\r
    IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
    Ip6ConfigOnPolicyChanged (IpSb, NewPolicy);\r
\r
    Instance->Policy = NewPolicy;\r
\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigSetData() to set the number of consecutive\r
  Neighbor Solicitation messages sent while performing Duplicate Address Detection\r
  on a tentative address. A value of ZERO indicates that Duplicate Address Detection\r
  will not be performed on a tentative address.\r
\r
  @param[in]     Instance The Instance Pointer to the IP6 config instance data.\r
  @param[in]     DataSize Size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data     The data buffer to set.\r
\r
  @retval EFI_BAD_BUFFER_SIZE  The DataSize does not match the size of the type.\r
  @retval EFI_ABORTED          The new transmit count equals the current configuration.\r
  @retval EFI_SUCCESS          The specified configuration data for the EFI IPv6\r
                               network stack was set.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigSetDadXmits (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN UINTN                DataSize,\r
  IN VOID                 *Data\r
  )\r
{\r
  EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS  *OldDadXmits;\r
\r
  if (DataSize != sizeof (EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS)) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  OldDadXmits = Instance->DataItem[Ip6ConfigDataTypeDupAddrDetectTransmits].Data.DadXmits;\r
\r
  if ((*(UINT32 *) Data) == OldDadXmits->DupAddrDetectTransmits) {\r
\r
    return EFI_ABORTED;\r
  } else {\r
\r
    OldDadXmits->DupAddrDetectTransmits = *((UINT32 *) Data);\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
/**\r
  The callback function for Ip6SetAddr. The prototype is defined\r
  as IP6_DAD_CALLBACK. It is called after Duplicate Address Detection is performed\r
  for the manual address set by Ip6ConfigSetMaunualAddress.\r
\r
  @param[in]     IsDadPassed   If TRUE, Duplicate Address Detection passed.\r
  @param[in]     TargetAddress The tentative IPv6 address to be checked.\r
  @param[in]     Context       Pointer to the IP6 configuration instance data.\r
\r
**/\r
VOID\r
Ip6ManualAddrDadCallback (\r
  IN BOOLEAN           IsDadPassed,\r
  IN EFI_IPv6_ADDRESS  *TargetAddress,\r
  IN VOID              *Context\r
  )\r
{\r
  IP6_CONFIG_INSTANCE            *Instance;\r
  UINTN                          Index;\r
  IP6_CONFIG_DATA_ITEM           *Item;\r
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *ManualAddr;\r
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *PassedAddr;\r
  UINTN                          DadPassCount;\r
  UINTN                          DadFailCount;\r
  IP6_SERVICE                    *IpSb;\r
\r
  Instance   = (IP6_CONFIG_INSTANCE *) Context;\r
  NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);\r
  Item       = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];\r
  ManualAddr = NULL;\r
\r
  for (Index = 0; Index < Item->DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS); Index++) {\r
    //\r
    // Find the original tag used to place into the NET_MAP.\r
    //\r
    ManualAddr = Item->Data.ManualAddress + Index;\r
    if (EFI_IP6_EQUAL (TargetAddress, &ManualAddr->Address)) {\r
      break;\r
    }\r
  }\r
\r
  ASSERT (Index != Item->DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS));\r
\r
  if (IsDadPassed) {\r
    NetMapInsertTail (&Instance->DadPassedMap, ManualAddr, NULL);\r
  } else {\r
    NetMapInsertTail (&Instance->DadFailedMap, ManualAddr, NULL);\r
  }\r
\r
  DadPassCount = NetMapGetCount (&Instance->DadPassedMap);\r
  DadFailCount = NetMapGetCount (&Instance->DadFailedMap);\r
\r
  if ((DadPassCount + DadFailCount) == (Item->DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS))) {\r
    //\r
    // All addresses have finished the configuration process.\r
    //\r
    if (DadFailCount != 0) {\r
      //\r
      // There is at least one duplicate address.\r
      //\r
      FreePool (Item->Data.Ptr);\r
\r
      Item->DataSize = DadPassCount * sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS);\r
      if (Item->DataSize == 0) {\r
        //\r
        // All failed, bad luck.\r
        //\r
        Item->Data.Ptr = NULL;\r
        Item->Status   = EFI_NOT_FOUND;\r
      } else {\r
        //\r
        // Part of addresses are detected to be duplicates, so update the\r
        // data with those passed.\r
        //\r
        PassedAddr = (EFI_IP6_CONFIG_MANUAL_ADDRESS *) AllocatePool (Item->DataSize);\r
        ASSERT (PassedAddr != NULL);\r
\r
        Item->Data.Ptr = PassedAddr;\r
        Item->Status   = EFI_SUCCESS;\r
\r
        while (!NetMapIsEmpty (&Instance->DadPassedMap)) {\r
          ManualAddr = (EFI_IP6_CONFIG_MANUAL_ADDRESS *) NetMapRemoveHead (&Instance->DadPassedMap, NULL);\r
          CopyMem (PassedAddr, ManualAddr, sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS));\r
\r
          PassedAddr++;\r
        }\r
\r
        ASSERT ((UINTN) PassedAddr - (UINTN) Item->Data.Ptr == Item->DataSize);\r
      }\r
    } else {\r
      //\r
      // All addresses are valid.\r
      //\r
      Item->Status = EFI_SUCCESS;\r
    }\r
\r
    //\r
    // Remove the tags we put in the NET_MAPs.\r
    //\r
    while (!NetMapIsEmpty (&Instance->DadFailedMap)) {\r
      NetMapRemoveHead (&Instance->DadFailedMap, NULL);\r
    }\r
\r
    while (!NetMapIsEmpty (&Instance->DadPassedMap)) {\r
      NetMapRemoveHead (&Instance->DadPassedMap, NULL);\r
    }\r
\r
    //\r
    // Signal the waiting events.\r
    //\r
    NetMapIterate (&Item->EventMap, Ip6ConfigSignalEvent, NULL);\r
    IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
    Ip6ConfigWriteConfigData (IpSb->MacString, Instance);\r
  }\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigSetData() to set the station addresses manually\r
  for the EFI IPv6 network stack. It is only configurable when the policy is\r
  Ip6ConfigPolicyManual.\r
\r
  @param[in]     Instance Pointer to the IP6 configuration instance data.\r
  @param[in]     DataSize Size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data     The data buffer to set.\r
\r
  @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.\r
  @retval EFI_WRITE_PROTECTED   The specified configuration data cannot be set\r
                                under the current policy.\r
  @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.\r
  @retval EFI_OUT_OF_RESOURCES  Fail to allocate resource to complete the operation.\r
  @retval EFI_NOT_READY         An asynchrous process is invoked to set the specified\r
                                configuration data, and the process is not finished.\r
  @retval EFI_ABORTED           The manual addresses to be set equal current\r
                                configuration.\r
  @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6\r
                                network stack was set.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigSetMaunualAddress (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN UINTN                DataSize,\r
  IN VOID                 *Data\r
  )\r
{\r
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *NewAddress;\r
  EFI_IP6_CONFIG_MANUAL_ADDRESS  *TmpAddress;\r
  IP6_CONFIG_DATA_ITEM           *DataItem;\r
  UINTN                          NewAddressCount;\r
  UINTN                          Index1;\r
  UINTN                          Index2;\r
  IP6_SERVICE                    *IpSb;\r
  IP6_ADDRESS_INFO               *CurrentAddrInfo;\r
  IP6_ADDRESS_INFO               *Copy;\r
  LIST_ENTRY                     CurrentSourceList;\r
  UINT32                         CurrentSourceCount;\r
  LIST_ENTRY                     *Entry;\r
  LIST_ENTRY                     *Entry2;\r
  IP6_INTERFACE                  *IpIf;\r
  IP6_PREFIX_LIST_ENTRY          *PrefixEntry;\r
  EFI_STATUS                     Status;\r
  BOOLEAN                        IsUpdated;\r
\r
  ASSERT (Instance->DataItem[Ip6ConfigDataTypeManualAddress].Status != EFI_NOT_READY);\r
\r
  if (((DataSize % sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS)) != 0) || (DataSize == 0)) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  if (Instance->Policy != Ip6ConfigPolicyManual) {\r
    return EFI_WRITE_PROTECTED;\r
  }\r
\r
  NewAddressCount = DataSize / sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS);\r
  NewAddress      = (EFI_IP6_CONFIG_MANUAL_ADDRESS *) Data;\r
\r
  for (Index1 = 0; Index1 < NewAddressCount; Index1++, NewAddress++) {\r
\r
    if (NetIp6IsLinkLocalAddr (&NewAddress->Address)    ||\r
        !NetIp6IsValidUnicast (&NewAddress->Address)    ||\r
        (NewAddress->PrefixLength > 128)\r
        ) {\r
      //\r
      // make sure the IPv6 address is unicast and not link-local address &&\r
      // the prefix length is valid.\r
      //\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    TmpAddress = NewAddress + 1;\r
    for (Index2 = Index1 + 1; Index2 < NewAddressCount; Index2++, TmpAddress++) {\r
      //\r
      // Any two addresses in the array can't be equal.\r
      //\r
      if (EFI_IP6_EQUAL (&TmpAddress->Address, &NewAddress->Address)) {\r
\r
        return EFI_INVALID_PARAMETER;\r
      }\r
    }\r
  }\r
\r
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
\r
  //\r
  // Build the current source address list.\r
  //\r
  InitializeListHead (&CurrentSourceList);\r
  CurrentSourceCount = 0;\r
\r
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {\r
    IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);\r
\r
    NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) {\r
      CurrentAddrInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);\r
\r
      Copy            = AllocateCopyPool (sizeof (IP6_ADDRESS_INFO), CurrentAddrInfo);\r
      if (Copy == NULL) {\r
        break;\r
      }\r
\r
      InsertTailList (&CurrentSourceList, &Copy->Link);\r
      CurrentSourceCount++;\r
    }\r
  }\r
\r
  //\r
  // Update the value... a long journey starts\r
  //\r
  NewAddress = AllocateCopyPool (DataSize, Data);\r
  if (NewAddress == NULL) {\r
    Ip6RemoveAddr (NULL, &CurrentSourceList, &CurrentSourceCount, NULL, 0);\r
\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Store the new data, and init the DataItem status to EFI_NOT_READY because\r
  // we may have an asynchronous configuration process.\r
  //\r
  DataItem = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];\r
  if (DataItem->Data.Ptr != NULL) {\r
    FreePool (DataItem->Data.Ptr);\r
  }\r
  DataItem->Data.Ptr = NewAddress;\r
  DataItem->DataSize = DataSize;\r
  DataItem->Status   = EFI_NOT_READY;\r
\r
  //\r
  // Trigger DAD, it's an asynchronous process.\r
  //\r
  IsUpdated  = FALSE;\r
\r
  for (Index1 = 0; Index1 < NewAddressCount; Index1++, NewAddress++) {\r
    if (Ip6IsOneOfSetAddress (IpSb, &NewAddress->Address, NULL, &CurrentAddrInfo)) {\r
      ASSERT (CurrentAddrInfo != NULL);\r
      //\r
      // Remove this already existing source address from the CurrentSourceList\r
      // built before.\r
      //\r
      Ip6RemoveAddr (\r
        NULL,\r
        &CurrentSourceList,\r
        &CurrentSourceCount,\r
        &CurrentAddrInfo->Address,\r
        128\r
        );\r
\r
      //\r
      // If the new address's prefix length is not specified, just use the previous configured\r
      // prefix length for this address.\r
      //\r
      if (NewAddress->PrefixLength == 0) {\r
        NewAddress->PrefixLength = CurrentAddrInfo->PrefixLength;\r
      }\r
\r
      //\r
      // This manual address is already in use, see whether prefix length is changed.\r
      //\r
      if (NewAddress->PrefixLength != CurrentAddrInfo->PrefixLength) {\r
        //\r
        // Remove the on-link prefix table, the route entry will be removed\r
        // implicitly.\r
        //\r
        PrefixEntry = Ip6FindPrefixListEntry (\r
                        IpSb,\r
                        TRUE,\r
                        CurrentAddrInfo->PrefixLength,\r
                        &CurrentAddrInfo->Address\r
                        );\r
        if (PrefixEntry != NULL) {\r
          Ip6DestroyPrefixListEntry (IpSb, PrefixEntry, TRUE, FALSE);\r
        }\r
\r
        //\r
        // Save the prefix length.\r
        //\r
        CurrentAddrInfo->PrefixLength = NewAddress->PrefixLength;\r
        IsUpdated = TRUE;\r
      }\r
\r
      //\r
      // create a new on-link prefix entry.\r
      //\r
      PrefixEntry = Ip6FindPrefixListEntry (\r
                      IpSb,\r
                      TRUE,\r
                      NewAddress->PrefixLength,\r
                      &NewAddress->Address\r
                      );\r
      if (PrefixEntry == NULL) {\r
        Ip6CreatePrefixListEntry (\r
          IpSb,\r
          TRUE,\r
          (UINT32) IP6_INFINIT_LIFETIME,\r
          (UINT32) IP6_INFINIT_LIFETIME,\r
          NewAddress->PrefixLength,\r
          &NewAddress->Address\r
          );\r
      }\r
\r
      CurrentAddrInfo->IsAnycast = NewAddress->IsAnycast;\r
      //\r
      // Artificially mark this address passed DAD be'coz it is already in use.\r
      //\r
      Ip6ManualAddrDadCallback (TRUE, &NewAddress->Address, Instance);\r
    } else {\r
      //\r
      // A new address.\r
      //\r
      IsUpdated = TRUE;\r
\r
      //\r
      // Set the new address, this will trigger DAD and activate the address if\r
      // DAD succeeds.\r
      //\r
      Ip6SetAddress (\r
        IpSb->DefaultInterface,\r
        &NewAddress->Address,\r
        NewAddress->IsAnycast,\r
        NewAddress->PrefixLength,\r
        (UINT32) IP6_INFINIT_LIFETIME,\r
        (UINT32) IP6_INFINIT_LIFETIME,\r
        Ip6ManualAddrDadCallback,\r
        Instance\r
        );\r
    }\r
  }\r
\r
  //\r
  // Check the CurrentSourceList, it now contains those addresses currently in\r
  // use and will be removed.\r
  //\r
  IpIf = IpSb->DefaultInterface;\r
\r
  while (!IsListEmpty (&CurrentSourceList)) {\r
    IsUpdated = TRUE;\r
\r
    CurrentAddrInfo = NET_LIST_HEAD (&CurrentSourceList, IP6_ADDRESS_INFO, Link);\r
\r
    //\r
    // This local address is going to be removed, the IP instances that are\r
    // currently using it will be destroyed.\r
    //\r
    Ip6RemoveAddr (\r
      IpSb,\r
      &IpIf->AddressList,\r
      &IpIf->AddressCount,\r
      &CurrentAddrInfo->Address,\r
      128\r
      );\r
\r
    //\r
    // Remove the on-link prefix table, the route entry will be removed\r
    // implicitly.\r
    //\r
    PrefixEntry = Ip6FindPrefixListEntry (\r
                    IpSb,\r
                    TRUE,\r
                    CurrentAddrInfo->PrefixLength,\r
                    &CurrentAddrInfo->Address\r
                    );\r
    if (PrefixEntry != NULL) {\r
      Ip6DestroyPrefixListEntry (IpSb, PrefixEntry, TRUE, FALSE);\r
    }\r
\r
    RemoveEntryList (&CurrentAddrInfo->Link);\r
    FreePool (CurrentAddrInfo);\r
  }\r
\r
  if (IsUpdated) {\r
    if (DataItem->Status == EFI_NOT_READY) {\r
      //\r
      // If DAD is disabled on this interface, the configuration process is\r
      // actually synchronous, and the data item's status will be changed to\r
      // the final status before we reach here, just check it.\r
      //\r
      Status = EFI_NOT_READY;\r
    } else {\r
      Status = EFI_SUCCESS;\r
    }\r
  } else {\r
    //\r
    // No update is taken, reset the status to success and return EFI_ABORTED.\r
    //\r
    DataItem->Status = EFI_SUCCESS;\r
    Status           = EFI_ABORTED;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigSetData() to set the gateway addresses manually\r
  for the EFI IPv6 network stack that is running on the communication device that\r
  this EFI IPv6 Configuration Protocol manages. It is not configurable when the policy is\r
  Ip6ConfigPolicyAutomatic. The gateway addresses must be unicast IPv6 addresses.\r
\r
  @param[in]     Instance The pointer to the IP6 config instance data.\r
  @param[in]     DataSize The size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data     The data buffer to set. This points to an array of\r
                          EFI_IPv6_ADDRESS instances.\r
\r
  @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.\r
  @retval EFI_WRITE_PROTECTED   The specified configuration data cannot be set\r
                                under the current policy.\r
  @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource to complete the operation.\r
  @retval EFI_ABORTED           The manual gateway addresses to be set equal the\r
                                current configuration.\r
  @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6\r
                                network stack was set.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigSetGateway (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN UINTN                DataSize,\r
  IN VOID                 *Data\r
  )\r
{\r
  UINTN                 Index1;\r
  UINTN                 Index2;\r
  EFI_IPv6_ADDRESS      *OldGateway;\r
  EFI_IPv6_ADDRESS      *NewGateway;\r
  UINTN                 OldGatewayCount;\r
  UINTN                 NewGatewayCount;\r
  IP6_CONFIG_DATA_ITEM  *Item;\r
  BOOLEAN               OneRemoved;\r
  BOOLEAN               OneAdded;\r
  IP6_SERVICE           *IpSb;\r
  IP6_DEFAULT_ROUTER    *DefaultRouter;\r
  VOID                  *Tmp;\r
\r
  if ((DataSize % sizeof (EFI_IPv6_ADDRESS) != 0) || (DataSize == 0)) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  if (Instance->Policy != Ip6ConfigPolicyManual) {\r
    return EFI_WRITE_PROTECTED;\r
  }\r
\r
  NewGateway      = (EFI_IPv6_ADDRESS *) Data;\r
  NewGatewayCount = DataSize / sizeof (EFI_IPv6_ADDRESS);\r
  for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {\r
\r
    if (!NetIp6IsValidUnicast (NewGateway + Index1)) {\r
\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    for (Index2 = Index1 + 1; Index2 < NewGatewayCount; Index2++) {\r
      if (EFI_IP6_EQUAL (NewGateway + Index1, NewGateway + Index2)) {\r
        return EFI_INVALID_PARAMETER;\r
      }\r
    }\r
  }\r
\r
  IpSb            = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
  Item            = &Instance->DataItem[Ip6ConfigDataTypeGateway];\r
  OldGateway      = Item->Data.Gateway;\r
  OldGatewayCount = Item->DataSize / sizeof (EFI_IPv6_ADDRESS);\r
  OneRemoved      = FALSE;\r
  OneAdded        = FALSE;\r
\r
  if (NewGatewayCount != OldGatewayCount) {\r
    Tmp = AllocatePool (DataSize);\r
    if (Tmp == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
  } else {\r
    Tmp = NULL;\r
  }\r
\r
  for (Index1 = 0; Index1 < OldGatewayCount; Index1++) {\r
    //\r
    // Find the gateways that are no long in the new setting and remove them.\r
    //\r
    for (Index2 = 0; Index2 < NewGatewayCount; Index2++) {\r
      if (EFI_IP6_EQUAL (OldGateway + Index1, NewGateway + Index2)) {\r
        OneRemoved = TRUE;\r
        break;\r
      }\r
    }\r
\r
    if (Index2 == NewGatewayCount) {\r
      //\r
      // Remove this default router.\r
      //\r
      DefaultRouter = Ip6FindDefaultRouter (IpSb, OldGateway + Index1);\r
      if (DefaultRouter != NULL) {\r
        Ip6DestroyDefaultRouter (IpSb, DefaultRouter);\r
      }\r
    }\r
  }\r
\r
  for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {\r
\r
    DefaultRouter = Ip6FindDefaultRouter (IpSb, NewGateway + Index1);\r
    if (DefaultRouter == NULL) {\r
      Ip6CreateDefaultRouter (IpSb, NewGateway + Index1, IP6_INF_ROUTER_LIFETIME);\r
      OneAdded = TRUE;\r
    }\r
  }\r
\r
  if (!OneRemoved && !OneAdded) {\r
    Item->Status = EFI_SUCCESS;\r
    return EFI_ABORTED;\r
  } else {\r
\r
    if (Tmp != NULL) {\r
      if (Item->Data.Ptr != NULL) {\r
        FreePool (Item->Data.Ptr);\r
      }\r
      Item->Data.Ptr = Tmp;\r
    }\r
\r
    CopyMem (Item->Data.Ptr, Data, DataSize);\r
    Item->DataSize = DataSize;\r
    Item->Status   = EFI_SUCCESS;\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
/**\r
  The work function for EfiIp6ConfigSetData() to set the DNS server list for the\r
  EFI IPv6 network stack running on the communication device that this EFI IPv6\r
  Configuration Protocol manages. It is not configurable when the policy is\r
  Ip6ConfigPolicyAutomatic. The DNS server addresses must be unicast IPv6 addresses.\r
\r
  @param[in]     Instance The pointer to the IP6 config instance data.\r
  @param[in]     DataSize The size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data     The data buffer to set, points to an array of\r
                          EFI_IPv6_ADDRESS instances.\r
\r
  @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type.\r
  @retval EFI_WRITE_PROTECTED   The specified configuration data cannot be set\r
                                under the current policy.\r
  @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resources to complete the operation.\r
  @retval EFI_ABORTED           The DNS server addresses to be set equal the current\r
                                configuration.\r
  @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6\r
                                network stack was set.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigSetDnsServer (\r
  IN IP6_CONFIG_INSTANCE  *Instance,\r
  IN UINTN                DataSize,\r
  IN VOID                 *Data\r
  )\r
{\r
  UINTN                 OldIndex;\r
  UINTN                 NewIndex;\r
  UINTN                 Index1;\r
  EFI_IPv6_ADDRESS      *OldDns;\r
  EFI_IPv6_ADDRESS      *NewDns;\r
  UINTN                 OldDnsCount;\r
  UINTN                 NewDnsCount;\r
  IP6_CONFIG_DATA_ITEM  *Item;\r
  BOOLEAN               OneAdded;\r
  VOID                  *Tmp;\r
\r
  if ((DataSize % sizeof (EFI_IPv6_ADDRESS) != 0) || (DataSize == 0)) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  if (Instance->Policy != Ip6ConfigPolicyManual) {\r
    return EFI_WRITE_PROTECTED;\r
  }\r
\r
  Item        = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];\r
  NewDns      = (EFI_IPv6_ADDRESS *) Data;\r
  OldDns      = Item->Data.DnsServers;\r
  NewDnsCount = DataSize / sizeof (EFI_IPv6_ADDRESS);\r
  OldDnsCount = Item->DataSize / sizeof (EFI_IPv6_ADDRESS);\r
  OneAdded    = FALSE;\r
\r
  if (NewDnsCount != OldDnsCount) {\r
    Tmp = AllocatePool (DataSize);\r
    if (Tmp == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
  } else {\r
    Tmp = NULL;\r
  }\r
\r
  for (NewIndex = 0; NewIndex < NewDnsCount; NewIndex++) {\r
\r
    if (!NetIp6IsValidUnicast (NewDns + NewIndex)) {\r
      //\r
      // The dns server address must be unicast.\r
      //\r
      FreePool (Tmp);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    for (Index1 = NewIndex + 1; Index1 < NewDnsCount; Index1++) {\r
      if (EFI_IP6_EQUAL (NewDns + NewIndex, NewDns + Index1)) {\r
        FreePool (Tmp);\r
        return EFI_INVALID_PARAMETER;\r
      }\r
    }\r
\r
    if (OneAdded) {\r
      //\r
      // If any address in the new setting is not in the old settings, skip the\r
      // comparision below.\r
      //\r
      continue;\r
    }\r
\r
    for (OldIndex = 0; OldIndex < OldDnsCount; OldIndex++) {\r
      if (EFI_IP6_EQUAL (NewDns + NewIndex, OldDns + OldIndex)) {\r
        //\r
        // If found break out.\r
        //\r
        break;\r
      }\r
    }\r
\r
    if (OldIndex == OldDnsCount) {\r
      OneAdded = TRUE;\r
    }\r
  }\r
\r
  if (!OneAdded && (DataSize == Item->DataSize)) {\r
    //\r
    // No new item is added and the size is the same.\r
    //\r
    Item->Status = EFI_SUCCESS;\r
    return EFI_ABORTED;\r
  } else {\r
    if (Tmp != NULL) {\r
      if (Item->Data.Ptr != NULL) {\r
        FreePool (Item->Data.Ptr);\r
      }\r
      Item->Data.Ptr = Tmp;\r
    }\r
\r
    CopyMem (Item->Data.Ptr, Data, DataSize);\r
    Item->DataSize = DataSize;\r
    Item->Status   = EFI_SUCCESS;\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
/**\r
  Generate the operational state of the interface this IP6 config instance manages\r
  and output in EFI_IP6_CONFIG_INTERFACE_INFO.\r
\r
  @param[in]      IpSb     The pointer to the IP6 service binding instance.\r
  @param[out]     IfInfo   The pointer to the IP6 configuration interface information structure.\r
\r
**/\r
VOID\r
Ip6ConfigInitIfInfo (\r
  IN  IP6_SERVICE                    *IpSb,\r
  OUT EFI_IP6_CONFIG_INTERFACE_INFO  *IfInfo\r
  )\r
{\r
  IfInfo->Name[0] = L'e';\r
  IfInfo->Name[1] = L't';\r
  IfInfo->Name[2] = L'h';\r
  IfInfo->Name[3] = (CHAR16) (L'0' + IpSb->Ip6ConfigInstance.IfIndex);\r
  IfInfo->Name[4] = 0;\r
\r
  IfInfo->IfType        = IpSb->SnpMode.IfType;\r
  IfInfo->HwAddressSize = IpSb->SnpMode.HwAddressSize;\r
  CopyMem (&IfInfo->HwAddress, &IpSb->SnpMode.CurrentAddress, IfInfo->HwAddressSize);\r
}\r
\r
/**\r
  Parse DHCPv6 reply packet to get the DNS server list.\r
  It is the work function for Ip6ConfigOnDhcp6Reply and Ip6ConfigOnDhcp6Event.\r
\r
  @param[in]      Dhcp6    The pointer to the EFI_DHCP6_PROTOCOL instance.\r
  @param[in, out] Instance The pointer to the IP6 configuration instance data.\r
  @param[in]      Reply    The pointer to the DHCPv6 reply packet.\r
\r
  @retval EFI_SUCCESS      The DNS server address was retrieved from the reply packet.\r
  @retval EFI_NOT_READY    The reply packet does not contain the DNS server option, or\r
                           the DNS server address is not valid.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigParseDhcpReply (\r
  IN     EFI_DHCP6_PROTOCOL  *Dhcp6,\r
  IN OUT IP6_CONFIG_INSTANCE *Instance,\r
  IN     EFI_DHCP6_PACKET    *Reply\r
  )\r
{\r
  EFI_STATUS               Status;\r
  UINT32                   OptCount;\r
  EFI_DHCP6_PACKET_OPTION  **OptList;\r
  UINT16                   OpCode;\r
  UINT16                   Length;\r
  UINTN                    Index;\r
  UINTN                    Index2;\r
  EFI_IPv6_ADDRESS         *DnsServer;\r
  IP6_CONFIG_DATA_ITEM     *Item;\r
\r
  //\r
  // A DHCPv6 reply packet is received as the response to our InfoRequest\r
  // packet.\r
  //\r
  OptCount = 0;\r
  Status   = Dhcp6->Parse (Dhcp6, Reply, &OptCount, NULL);\r
  if (Status != EFI_BUFFER_TOO_SMALL) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  OptList = AllocatePool (OptCount * sizeof (EFI_DHCP6_PACKET_OPTION *));\r
  if (OptList == NULL) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  Status = Dhcp6->Parse (Dhcp6, Reply, &OptCount, OptList);\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_NOT_READY;\r
    goto ON_EXIT;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
  for (Index = 0; Index < OptCount; Index++) {\r
    //\r
    // Go through all the options to check the ones we are interested in.\r
    // The OpCode and Length are in network byte-order and may not be naturally\r
    // aligned.\r
    //\r
    CopyMem (&OpCode, &OptList[Index]->OpCode, sizeof (OpCode));\r
    OpCode = NTOHS (OpCode);\r
\r
    if (OpCode == IP6_CONFIG_DHCP6_OPTION_DNS_SERVERS) {\r
      CopyMem (&Length, &OptList[Index]->OpLen, sizeof (Length));\r
      Length = NTOHS (Length);\r
\r
      if ((Length == 0) || ((Length % sizeof (EFI_IPv6_ADDRESS)) != 0)) {\r
        //\r
        // The length should be a multiple of 16 bytes.\r
        //\r
        Status = EFI_NOT_READY;\r
        break;\r
      }\r
\r
      //\r
      // Validate the DnsServers: whether they are unicast addresses.\r
      //\r
      DnsServer = (EFI_IPv6_ADDRESS *) OptList[Index]->Data;\r
      for (Index2 = 0; Index2 < Length / sizeof (EFI_IPv6_ADDRESS); Index2++) {\r
        if (!NetIp6IsValidUnicast (DnsServer)) {\r
          Status = EFI_NOT_READY;\r
          goto ON_EXIT;\r
        }\r
\r
        DnsServer++;\r
      }\r
\r
      Item = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];\r
\r
      if (Item->DataSize != Length) {\r
        if (Item->Data.Ptr != NULL) {\r
          FreePool (Item->Data.Ptr);\r
        }\r
\r
        Item->Data.Ptr = AllocatePool (Length);\r
        ASSERT (Item->Data.Ptr != NULL);\r
      }\r
\r
      CopyMem (Item->Data.Ptr, OptList[Index]->Data, Length);\r
      Item->DataSize = Length;\r
      Item->Status   = EFI_SUCCESS;\r
\r
      //\r
      // Signal the waiting events.\r
      //\r
      NetMapIterate (&Item->EventMap, Ip6ConfigSignalEvent, NULL);\r
\r
      break;\r
    }\r
  }\r
\r
ON_EXIT:\r
\r
  FreePool (OptList);\r
  return Status;\r
}\r
\r
/**\r
  The callback function for Ip6SetAddr. The prototype is defined\r
  as IP6_DAD_CALLBACK. It is called after Duplicate Address Detection is performed\r
  on the tentative address by DHCPv6 in Ip6ConfigOnDhcp6Event().\r
\r
  @param[in]     IsDadPassed   If TRUE, Duplicate Address Detection passes.\r
  @param[in]     TargetAddress The tentative IPv6 address to be checked.\r
  @param[in]     Context       Pointer to the IP6 configuration instance data.\r
\r
**/\r
VOID\r
Ip6ConfigSetStatefulAddrCallback (\r
  IN BOOLEAN           IsDadPassed,\r
  IN EFI_IPv6_ADDRESS  *TargetAddress,\r
  IN VOID              *Context\r
  )\r
{\r
  IP6_CONFIG_INSTANCE  *Instance;\r
\r
  Instance = (IP6_CONFIG_INSTANCE *) Context;\r
  NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);\r
\r
  //\r
  // We should record the addresses that fail the DAD, and DECLINE them.\r
  //\r
  if (IsDadPassed) {\r
    //\r
    // Decrease the count, no interests in those passed DAD.\r
    //\r
    if (Instance->FailedIaAddressCount > 0 ) {\r
      Instance->FailedIaAddressCount--;\r
    }\r
  } else {\r
    //\r
    // Record it.\r
    //\r
    IP6_COPY_ADDRESS (Instance->DeclineAddress + Instance->DeclineAddressCount, TargetAddress);\r
    Instance->DeclineAddressCount++;\r
  }\r
\r
  if (Instance->FailedIaAddressCount == Instance->DeclineAddressCount) {\r
    //\r
    // The checking on all addresses are finished.\r
    //\r
    if (Instance->DeclineAddressCount != 0) {\r
      //\r
      // Decline those duplicates.\r
      //\r
      if (Instance->Dhcp6 != NULL) {\r
        Instance->Dhcp6->Decline (\r
                           Instance->Dhcp6,\r
                           Instance->DeclineAddressCount,\r
                           Instance->DeclineAddress\r
                           );\r
      }\r
    }\r
\r
    if (Instance->DeclineAddress != NULL) {\r
      FreePool (Instance->DeclineAddress);\r
    }\r
    Instance->DeclineAddress      = NULL;\r
    Instance->DeclineAddressCount = 0;\r
  }\r
}\r
\r
/**\r
  The event handle routine when DHCPv6 process is finished or is updated.\r
\r
  @param[in]     Event         Not used.\r
  @param[in]     Context       The pointer to the IP6 configuration instance data.\r
\r
**/\r
VOID\r
EFIAPI\r
Ip6ConfigOnDhcp6Event (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  IP6_CONFIG_INSTANCE      *Instance;\r
  EFI_DHCP6_PROTOCOL       *Dhcp6;\r
  EFI_STATUS               Status;\r
  EFI_DHCP6_MODE_DATA      Dhcp6ModeData;\r
  EFI_DHCP6_IA             *Ia;\r
  EFI_DHCP6_IA_ADDRESS     *IaAddr;\r
  UINT32                   Index;\r
  IP6_SERVICE              *IpSb;\r
  IP6_ADDRESS_INFO         *AddrInfo;\r
  IP6_INTERFACE            *IpIf;\r
\r
  Instance = (IP6_CONFIG_INSTANCE *) Context;\r
\r
  if ((Instance->Policy != Ip6ConfigPolicyAutomatic) || Instance->OtherInfoOnly) {\r
    //\r
    // IPv6 is not operating in the automatic policy now or\r
    // the DHCPv6 information request message exchange is aborted.\r
    //\r
    return ;\r
  }\r
\r
  //\r
  // The stateful address autoconfiguration is done or updated.\r
  //\r
  Dhcp6 = Instance->Dhcp6;\r
\r
  Status = Dhcp6->GetModeData (Dhcp6, &Dhcp6ModeData, NULL);\r
  if (EFI_ERROR (Status)) {\r
    return ;\r
  }\r
\r
  IpSb   = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
  IpIf   = IpSb->DefaultInterface;\r
  Ia     = Dhcp6ModeData.Ia;\r
  IaAddr = Ia->IaAddress;\r
\r
  if (Instance->DeclineAddress != NULL) {\r
    FreePool (Instance->DeclineAddress);\r
  }\r
\r
  Instance->DeclineAddress = (EFI_IPv6_ADDRESS *) AllocatePool (Ia->IaAddressCount * sizeof (EFI_IPv6_ADDRESS));\r
  if (Instance->DeclineAddress == NULL) {\r
    goto ON_EXIT;\r
  }\r
\r
  Instance->FailedIaAddressCount = Ia->IaAddressCount;\r
  Instance->DeclineAddressCount   = 0;\r
\r
  for (Index = 0; Index < Ia->IaAddressCount; Index++, IaAddr++) {\r
    if (Ia->IaAddress[Index].ValidLifetime != 0 && Ia->State == Dhcp6Bound) {\r
      //\r
      // Set this address, either it's a new address or with updated lifetimes.\r
      // An appropriate prefix length will be set.\r
      //\r
      Ip6SetAddress (\r
        IpIf,\r
        &IaAddr->IpAddress,\r
        FALSE,\r
        0,\r
        IaAddr->ValidLifetime,\r
        IaAddr->PreferredLifetime,\r
        Ip6ConfigSetStatefulAddrCallback,\r
        Instance\r
        );\r
    } else {\r
      //\r
      // discard this address, artificially decrease the count as if this address\r
      // passed DAD.\r
      //\r
      if (Ip6IsOneOfSetAddress (IpSb, &IaAddr->IpAddress, NULL, &AddrInfo)) {\r
        ASSERT (AddrInfo != NULL);\r
        Ip6RemoveAddr (\r
          IpSb,\r
          &IpIf->AddressList,\r
          &IpIf->AddressCount,\r
          &AddrInfo->Address,\r
          AddrInfo->PrefixLength\r
          );\r
      }\r
\r
      if (Instance->FailedIaAddressCount > 0) {\r
        Instance->FailedIaAddressCount--;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Parse the Reply packet to get the options we need.\r
  //\r
  if (Dhcp6ModeData.Ia->ReplyPacket != NULL) {\r
    Ip6ConfigParseDhcpReply (Dhcp6, Instance, Dhcp6ModeData.Ia->ReplyPacket);\r
  }\r
\r
ON_EXIT:\r
\r
  FreePool (Dhcp6ModeData.ClientId);\r
  FreePool (Dhcp6ModeData.Ia);\r
}\r
\r
/**\r
  The event process routine when the DHCPv6 server is answered with a reply packet\r
  for an information request.\r
\r
  @param[in]     This          Points to the EFI_DHCP6_PROTOCOL.\r
  @param[in]     Context       The pointer to the IP6 configuration instance data.\r
  @param[in]     Packet        The DHCPv6 reply packet.\r
\r
  @retval EFI_SUCCESS      The DNS server address was retrieved from the reply packet.\r
  @retval EFI_NOT_READY    The reply packet does not contain the DNS server option, or\r
                           the DNS server address is not valid.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
Ip6ConfigOnDhcp6Reply (\r
  IN EFI_DHCP6_PROTOCOL  *This,\r
  IN VOID                *Context,\r
  IN EFI_DHCP6_PACKET    *Packet\r
  )\r
{\r
  return Ip6ConfigParseDhcpReply (This, (IP6_CONFIG_INSTANCE *) Context, Packet);\r
}\r
\r
/**\r
  The event process routine when the DHCPv6 service binding protocol is installed\r
  in the system.\r
\r
  @param[in]     Event         Not used.\r
  @param[in]     Context       The pointer to the IP6 config instance data.\r
\r
**/\r
VOID\r
EFIAPI\r
Ip6ConfigOnDhcp6SbInstalled (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  IP6_CONFIG_INSTANCE  *Instance;\r
\r
  Instance = (IP6_CONFIG_INSTANCE *) Context;\r
\r
  if ((Instance->Dhcp6Handle != NULL) || (Instance->Policy != Ip6ConfigPolicyAutomatic)) {\r
    //\r
    // The DHCP6 child is already created or the policy is no longer AUTOMATIC.\r
    //\r
    return ;\r
  }\r
\r
  Ip6ConfigStartStatefulAutoConfig (Instance, Instance->OtherInfoOnly);\r
}\r
\r
/**\r
  Set the configuration for the EFI IPv6 network stack running on the communication\r
  device this EFI IPv6 Configuration Protocol instance manages.\r
\r
  This function is used to set the configuration data of type DataType for the EFI\r
  IPv6 network stack that is running on the communication device that this EFI IPv6\r
  Configuration Protocol instance manages.\r
\r
  DataSize is used to calculate the count of structure instances in the Data for\r
  a DataType in which multiple structure instances are allowed.\r
\r
  This function is always non-blocking. When setting some type of configuration data,\r
  an asynchronous process is invoked to check the correctness of the data, such as\r
  performing Duplicate Address Detection on the manually set local IPv6 addresses.\r
  EFI_NOT_READY is returned immediately to indicate that such an asynchronous process\r
  is invoked, and the process is not finished yet. The caller wanting to get the result\r
  of the asynchronous process is required to call RegisterDataNotify() to register an\r
  event on the specified configuration data. Once the event is signaled, the caller\r
  can call GetData() to obtain the configuration data and know the result.\r
  For other types of configuration data that do not require an asynchronous configuration\r
  process, the result of the operation is immediately returned.\r
\r
  @param[in]     This           The pointer to the EFI_IP6_CONFIG_PROTOCOL instance.\r
  @param[in]     DataType       The type of data to set.\r
  @param[in]     DataSize       Size of the buffer pointed to by Data in bytes.\r
  @param[in]     Data           The data buffer to set. The type of the data buffer is\r
                                associated with the DataType.\r
\r
  @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6\r
                                network stack was set successfully.\r
  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:\r
                                - This is NULL.\r
                                - Data is NULL.\r
                                - One or more fields in Data do not match the requirement of the\r
                                  data type indicated by DataType.\r
  @retval EFI_WRITE_PROTECTED   The specified configuration data is read-only or the specified\r
                                configuration data cannot be set under the current policy.\r
  @retval EFI_ACCESS_DENIED     Another set operation on the specified configuration\r
                                data is already in process.\r
  @retval EFI_NOT_READY         An asynchronous process was invoked to set the specified\r
                                configuration data, and the process is not finished yet.\r
  @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type\r
                                indicated by DataType.\r
  @retval EFI_UNSUPPORTED       This DataType is not supported.\r
  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.\r
  @retval EFI_DEVICE_ERROR      An unexpected system error or network error occurred.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EfiIp6ConfigSetData (\r
  IN EFI_IP6_CONFIG_PROTOCOL    *This,\r
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,\r
  IN UINTN                      DataSize,\r
  IN VOID                       *Data\r
  )\r
{\r
  EFI_TPL              OldTpl;\r
  EFI_STATUS           Status;\r
  IP6_CONFIG_INSTANCE  *Instance;\r
  IP6_SERVICE          *IpSb;\r
\r
  if ((This == NULL) || (Data == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (DataType >= Ip6ConfigDataTypeMaximum) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);\r
  IpSb     = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
\r
  if (IpSb->LinkLocalDadFail) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  Status = Instance->DataItem[DataType].Status;\r
  if (Status != EFI_NOT_READY) {\r
\r
    if (Instance->DataItem[DataType].SetData == NULL) {\r
      //\r
      // This type of data is readonly.\r
      //\r
      Status = EFI_WRITE_PROTECTED;\r
    } else {\r
\r
      Status = Instance->DataItem[DataType].SetData (Instance, DataSize, Data);\r
      if (!EFI_ERROR (Status)) {\r
        //\r
        // Fire up the events registered with this type of data.\r
        //\r
        NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip6ConfigSignalEvent, NULL);\r
        Ip6ConfigWriteConfigData (IpSb->MacString, Instance);\r
      } else if (Status == EFI_ABORTED) {\r
        //\r
        // The SetData is aborted because the data to set is the same with\r
        // the one maintained.\r
        //\r
        Status = EFI_SUCCESS;\r
        NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip6ConfigSignalEvent, NULL);\r
      }\r
    }\r
  } else {\r
    //\r
    // Another asynchornous process is on the way.\r
    //\r
    Status = EFI_ACCESS_DENIED;\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Get the configuration data for the EFI IPv6 network stack running on the communication\r
  device that this EFI IPv6 Configuration Protocol instance manages.\r
\r
  This function returns the configuration data of type DataType for the EFI IPv6 network\r
  stack running on the communication device that this EFI IPv6 Configuration Protocol instance\r
  manages.\r
\r
  The caller is responsible for allocating the buffer used to return the specified\r
  configuration data. The required size will be returned to the caller if the size of\r
  the buffer is too small.\r
\r
  EFI_NOT_READY is returned if the specified configuration data is not ready due to an\r
  asynchronous configuration process already in progress. The caller can call RegisterDataNotify()\r
  to register an event on the specified configuration data. Once the asynchronous configuration\r
  process is finished, the event will be signaled, and a subsequent GetData() call will return\r
  the specified configuration data.\r
\r
  @param[in]      This           Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.\r
  @param[in]      DataType       The type of data to get.\r
  @param[in, out] DataSize       On input, in bytes, the size of Data. On output, in bytes, the\r
                                 size of buffer required to store the specified configuration data.\r
  @param[in]     Data            The data buffer in which the configuration data is returned. The\r
                                 type of the data buffer is associated with the DataType.\r
                                 This is an optional parameter that may be NULL.\r
\r
  @retval EFI_SUCCESS           The specified configuration data was obtained successfully.\r
  @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:\r
                                - This is NULL.\r
                                - DataSize is NULL.\r
                                - Data is NULL if *DataSize is not zero.\r
  @retval EFI_BUFFER_TOO_SMALL  The size of Data is too small for the specified configuration data,\r
                                and the required size is returned in DataSize.\r
  @retval EFI_NOT_READY         The specified configuration data is not ready due to an\r
                                asynchronous configuration process already in progress.\r
  @retval EFI_NOT_FOUND         The specified configuration data is not found.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EfiIp6ConfigGetData (\r
  IN EFI_IP6_CONFIG_PROTOCOL    *This,\r
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,\r
  IN OUT UINTN                  *DataSize,\r
  IN VOID                       *Data   OPTIONAL\r
  )\r
{\r
  EFI_TPL               OldTpl;\r
  EFI_STATUS            Status;\r
  IP6_CONFIG_INSTANCE   *Instance;\r
  IP6_CONFIG_DATA_ITEM  *DataItem;\r
\r
  if ((This == NULL) || (DataSize == NULL) || ((*DataSize != 0) && (Data == NULL))) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (DataType >= Ip6ConfigDataTypeMaximum) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);\r
  DataItem = &Instance->DataItem[DataType];\r
\r
  Status   = Instance->DataItem[DataType].Status;\r
  if (!EFI_ERROR (Status)) {\r
\r
    if (DataItem->GetData != NULL) {\r
\r
      Status = DataItem->GetData (Instance, DataSize, Data);\r
    } else if (*DataSize < Instance->DataItem[DataType].DataSize) {\r
      //\r
      // Update the buffer length.\r
      //\r
      *DataSize = Instance->DataItem[DataType].DataSize;\r
      Status    = EFI_BUFFER_TOO_SMALL;\r
    } else {\r
\r
      *DataSize = Instance->DataItem[DataType].DataSize;\r
      CopyMem (Data, Instance->DataItem[DataType].Data.Ptr, *DataSize);\r
    }\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Register an event that is signaled whenever a configuration process on the specified\r
  configuration data is done.\r
\r
  This function registers an event that is to be signaled whenever a configuration\r
  process on the specified configuration data is performed. An event can be registered\r
  for a different DataType simultaneously. The caller is responsible for determining\r
  which type of configuration data causes the signaling of the event in such an event.\r
\r
  @param[in]     This           Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.\r
  @param[in]     DataType       The type of data to unregister the event for.\r
  @param[in]     Event          The event to register.\r
\r
  @retval EFI_SUCCESS           The notification event for the specified configuration data is\r
                                registered.\r
  @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.\r
  @retval EFI_UNSUPPORTED       The configuration data type specified by DataType is not\r
                                supported.\r
  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.\r
  @retval EFI_ACCESS_DENIED     The Event is already registered for the DataType.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EfiIp6ConfigRegisterDataNotify (\r
  IN EFI_IP6_CONFIG_PROTOCOL    *This,\r
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,\r
  IN EFI_EVENT                  Event\r
  )\r
{\r
  EFI_TPL              OldTpl;\r
  EFI_STATUS           Status;\r
  IP6_CONFIG_INSTANCE  *Instance;\r
  NET_MAP              *EventMap;\r
  NET_MAP_ITEM         *Item;\r
\r
  if ((This == NULL) || (Event == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (DataType >= Ip6ConfigDataTypeMaximum) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  OldTpl    = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  Instance  = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);\r
  EventMap  = &Instance->DataItem[DataType].EventMap;\r
\r
  //\r
  // Check whether this event is already registered for this DataType.\r
  //\r
  Item = NetMapFindKey (EventMap, Event);\r
  if (Item == NULL) {\r
\r
    Status = NetMapInsertTail (EventMap, Event, NULL);\r
\r
    if (EFI_ERROR (Status)) {\r
\r
      Status = EFI_OUT_OF_RESOURCES;\r
    }\r
\r
  } else {\r
\r
    Status = EFI_ACCESS_DENIED;\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Remove a previously registered event for the specified configuration data.\r
\r
  @param  This                   The pointer to the EFI_IP6_CONFIG_PROTOCOL instance.\r
  @param  DataType               The type of data to remove from the previously\r
                                 registered event.\r
  @param  Event                  The event to be unregistered.\r
\r
  @retval EFI_SUCCESS            The event registered for the specified\r
                                 configuration data was removed.\r
  @retval EFI_INVALID_PARAMETER  This is NULL or Event is NULL.\r
  @retval EFI_NOT_FOUND          The Event has not been registered for the\r
                                 specified DataType.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EfiIp6ConfigUnregisterDataNotify (\r
  IN EFI_IP6_CONFIG_PROTOCOL    *This,\r
  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,\r
  IN EFI_EVENT                  Event\r
  )\r
{\r
  EFI_TPL              OldTpl;\r
  EFI_STATUS           Status;\r
  IP6_CONFIG_INSTANCE  *Instance;\r
  NET_MAP_ITEM         *Item;\r
\r
  if ((This == NULL) || (Event == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (DataType >= Ip6ConfigDataTypeMaximum) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  Instance = IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This);\r
\r
  Item = NetMapFindKey (&Instance->DataItem[DataType].EventMap, Event);\r
  if (Item != NULL) {\r
\r
    NetMapRemoveItem (&Instance->DataItem[DataType].EventMap, Item, NULL);\r
    Status = EFI_SUCCESS;\r
  } else {\r
\r
    Status = EFI_NOT_FOUND;\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
/**\r
  Initialize an IP6_CONFIG_INSTANCE.\r
\r
  @param[out]    Instance       The buffer of IP6_CONFIG_INSTANCE to be initialized.\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resources to complete the operation.\r
  @retval EFI_SUCCESS           The IP6_CONFIG_INSTANCE initialized successfully.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigInitInstance (\r
  OUT IP6_CONFIG_INSTANCE  *Instance\r
  )\r
{\r
  IP6_SERVICE           *IpSb;\r
  IP6_CONFIG_INSTANCE   *TmpInstance;\r
  LIST_ENTRY            *Entry;\r
  EFI_STATUS            Status;\r
  UINTN                 Index;\r
  UINT16                IfIndex;\r
  IP6_CONFIG_DATA_ITEM  *DataItem;\r
\r
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
\r
  Instance->Signature = IP6_CONFIG_INSTANCE_SIGNATURE;\r
\r
  //\r
  // Determine the index of this interface.\r
  //\r
  IfIndex = 0;\r
  NET_LIST_FOR_EACH (Entry, &mIp6ConfigInstanceList) {\r
    TmpInstance = NET_LIST_USER_STRUCT_S (Entry, IP6_CONFIG_INSTANCE, Link, IP6_CONFIG_INSTANCE_SIGNATURE);\r
\r
    if (TmpInstance->IfIndex > IfIndex) {\r
      //\r
      // There is a sequence hole because some interface is down.\r
      //\r
      break;\r
    }\r
\r
    IfIndex++;\r
  }\r
\r
  Instance->IfIndex = IfIndex;\r
  NetListInsertBefore (Entry, &Instance->Link);\r
\r
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {\r
    //\r
    // Initialize the event map for each data item.\r
    //\r
    NetMapInit (&Instance->DataItem[Index].EventMap);\r
  }\r
\r
  //\r
  // Initialize the NET_MAPs used for DAD on manually configured source addresses.\r
  //\r
  NetMapInit (&Instance->DadFailedMap);\r
  NetMapInit (&Instance->DadPassedMap);\r
\r
  //\r
  // Initialize each data type: associate storage and set data size for the\r
  // fixed size data types, hook the SetData function, set the data attribute.\r
  //\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeInterfaceInfo];\r
  DataItem->GetData  = Ip6ConfigGetIfInfo;\r
  DataItem->Data.Ptr = &Instance->InterfaceInfo;\r
  DataItem->DataSize = sizeof (Instance->InterfaceInfo);\r
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED | DATA_ATTRIB_VOLATILE);\r
  Ip6ConfigInitIfInfo (IpSb, &Instance->InterfaceInfo);\r
\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeAltInterfaceId];\r
  DataItem->SetData  = Ip6ConfigSetAltIfId;\r
  DataItem->Data.Ptr = &Instance->AltIfId;\r
  DataItem->DataSize = sizeof (Instance->AltIfId);\r
  DataItem->Status   = EFI_NOT_FOUND;\r
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);\r
\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypePolicy];\r
  DataItem->SetData  = Ip6ConfigSetPolicy;\r
  DataItem->Data.Ptr = &Instance->Policy;\r
  DataItem->DataSize = sizeof (Instance->Policy);\r
  Instance->Policy   = Ip6ConfigPolicyAutomatic;\r
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);\r
\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeDupAddrDetectTransmits];\r
  DataItem->SetData  = Ip6ConfigSetDadXmits;\r
  DataItem->Data.Ptr = &Instance->DadXmits;\r
  DataItem->DataSize = sizeof (Instance->DadXmits);\r
  Instance->DadXmits.DupAddrDetectTransmits = IP6_CONFIG_DEFAULT_DAD_XMITS;\r
  SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);\r
\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeManualAddress];\r
  DataItem->SetData  = Ip6ConfigSetMaunualAddress;\r
  DataItem->Status   = EFI_NOT_FOUND;\r
\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeGateway];\r
  DataItem->SetData  = Ip6ConfigSetGateway;\r
  DataItem->Status   = EFI_NOT_FOUND;\r
\r
  DataItem           = &Instance->DataItem[Ip6ConfigDataTypeDnsServer];\r
  DataItem->SetData  = Ip6ConfigSetDnsServer;\r
  DataItem->Status   = EFI_NOT_FOUND;\r
\r
  //\r
  // Create the event used for DHCP.\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  Ip6ConfigOnDhcp6Event,\r
                  Instance,\r
                  &Instance->Dhcp6Event\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Instance->Configured  = TRUE;\r
\r
  //\r
  // Try to read the config data from NV variable.\r
  //\r
  Status = Ip6ConfigReadConfigData (IpSb->MacString, Instance);\r
  if (Status == EFI_NOT_FOUND) {\r
    //\r
    // The NV variable is not set, so generate a random IAID, and write down the\r
    // fresh new configuration as the NV variable now.\r
    //\r
    Instance->IaId = NET_RANDOM (NetRandomInitSeed ());\r
\r
    for (Index = 0; Index < IpSb->SnpMode.HwAddressSize; Index++) {\r
      Instance->IaId |= (IpSb->SnpMode.CurrentAddress.Addr[Index] << ((Index << 3) & 31));\r
    }\r
\r
    Ip6ConfigWriteConfigData (IpSb->MacString, Instance);\r
  } else if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Instance->Ip6Config.SetData              = EfiIp6ConfigSetData;\r
  Instance->Ip6Config.GetData              = EfiIp6ConfigGetData;\r
  Instance->Ip6Config.RegisterDataNotify   = EfiIp6ConfigRegisterDataNotify;\r
  Instance->Ip6Config.UnregisterDataNotify = EfiIp6ConfigUnregisterDataNotify;\r
\r
\r
  //\r
  // Publish the IP6 configuration form\r
  //\r
  return Ip6ConfigFormInit (Instance);\r
}\r
\r
/**\r
  Release an IP6_CONFIG_INSTANCE.\r
\r
  @param[in, out] Instance    The buffer of IP6_CONFIG_INSTANCE to be freed.\r
\r
**/\r
VOID\r
Ip6ConfigCleanInstance (\r
  IN OUT IP6_CONFIG_INSTANCE  *Instance\r
  )\r
{\r
  UINTN                 Index;\r
  IP6_CONFIG_DATA_ITEM  *DataItem;\r
\r
  if (Instance->DeclineAddress != NULL) {\r
    FreePool (Instance->DeclineAddress);\r
  }\r
\r
  if (!Instance->Configured) {\r
    return ;\r
  }\r
\r
  if (Instance->Dhcp6Handle != NULL) {\r
\r
    Ip6ConfigDestroyDhcp6 (Instance);\r
  }\r
\r
  //\r
  // Close the event.\r
  //\r
  if (Instance->Dhcp6Event != NULL) {\r
    gBS->CloseEvent (Instance->Dhcp6Event);\r
  }\r
\r
  NetMapClean (&Instance->DadPassedMap);\r
  NetMapClean (&Instance->DadFailedMap);\r
\r
  for (Index = 0; Index < Ip6ConfigDataTypeMaximum; Index++) {\r
\r
    DataItem = &Instance->DataItem[Index];\r
\r
    if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {\r
      if (DataItem->Data.Ptr != NULL) {\r
        FreePool (DataItem->Data.Ptr);\r
      }\r
      DataItem->Data.Ptr = NULL;\r
      DataItem->DataSize = 0;\r
    }\r
\r
    NetMapClean (&Instance->DataItem[Index].EventMap);\r
  }\r
\r
  Ip6ConfigFormUnload (Instance);\r
\r
  RemoveEntryList (&Instance->Link);\r
}\r
\r
/**\r
  Destroy the Dhcp6 child in IP6_CONFIG_INSTANCE and release the resources.\r
\r
  @param[in, out] Instance    The buffer of IP6_CONFIG_INSTANCE to be freed.\r
\r
  @retval EFI_SUCCESS         The child was successfully destroyed.\r
  @retval Others              Failed to destroy the child.\r
\r
**/\r
EFI_STATUS\r
Ip6ConfigDestroyDhcp6 (\r
  IN OUT IP6_CONFIG_INSTANCE  *Instance\r
  )\r
{\r
  IP6_SERVICE                 *IpSb;\r
  EFI_STATUS                  Status;\r
  EFI_DHCP6_PROTOCOL          *Dhcp6;\r
\r
  Dhcp6 = Instance->Dhcp6;\r
  ASSERT (Dhcp6 != NULL);\r
\r
  Dhcp6->Stop (Dhcp6);\r
  Dhcp6->Configure (Dhcp6, NULL);\r
  Instance->Dhcp6 = NULL;\r
\r
  IpSb = IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance);\r
\r
  //\r
  // Close DHCPv6 protocol and destroy the child.\r
  //\r
  Status = gBS->CloseProtocol (\r
                  Instance->Dhcp6Handle,\r
                  &gEfiDhcp6ProtocolGuid,\r
                  IpSb->Image,\r
                  IpSb->Controller\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = NetLibDestroyServiceChild (\r
             IpSb->Controller,\r
             IpSb->Image,\r
             &gEfiDhcp6ServiceBindingProtocolGuid,\r
             Instance->Dhcp6Handle\r
             );\r
\r
  Instance->Dhcp6Handle = NULL;\r
\r
  return Status;\r
}\r
\r