From f215e02bf85f68d3a6106c2a1f4f7f063f819064 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 11 Apr 2024 10:17:27 +0200 Subject: Adding upstream version 7.0.14-dfsg. Signed-off-by: Daniel Baumann --- .../EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c | 2533 ++++++++++++++++++++ 1 file changed, 2533 insertions(+) create mode 100644 src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c (limited to 'src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c') diff --git a/src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c b/src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c new file mode 100644 index 00000000..a147d1ff --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c @@ -0,0 +1,2533 @@ +/** @file + The implementation of EFI IPv6 Configuration Protocol. + + Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.
+ Copyright (c) Microsoft Corporation.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "Ip6Impl.h" + +LIST_ENTRY mIp6ConfigInstanceList = {&mIp6ConfigInstanceList, &mIp6ConfigInstanceList}; + +/** + The event process routine when the DHCPv6 service binding protocol is installed + in the system. + + @param[in] Event Not used. + @param[in] Context Pointer to the IP6 config instance data. + +**/ +VOID +EFIAPI +Ip6ConfigOnDhcp6SbInstalled ( + IN EFI_EVENT Event, + IN VOID *Context + ); + +/** + Update the current policy to NewPolicy. During the transition + period, the default router list, on-link prefix list, autonomous prefix list + and address list in all interfaces will be released. + + @param[in] IpSb The IP6 service binding instance. + @param[in] NewPolicy The new policy to be updated to. + +**/ +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); + } +} + +/** + The work function to trigger the DHCPv6 process to perform a stateful autoconfiguration. + + @param[in] Instance Pointer to the IP6 config instance data. + @param[in] OtherInfoOnly If FALSE, get stateful address and other information + via DHCPv6. Otherwise, only get the other information. + + @retval EFI_SUCCESS The operation finished successfully. + @retval EFI_UNSUPPORTED The DHCP6 driver is not available. + +**/ +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; +} + +/** + Signal the registered event. It is the callback routine for NetMapIterate. + + @param[in] Map Points to the list of registered event. + @param[in] Item The registered event. + @param[in] Arg Not used. + +**/ +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; +} + +/** + Read the configuration data from variable storage according to the VarName and + gEfiIp6ConfigProtocolGuid. It checks the integrity of variable data. If the + data is corrupted, it clears the variable data to ZERO. Otherwise, it outputs the + configuration data to IP6_CONFIG_INSTANCE. + + @param[in] VarName The pointer to the variable name + @param[in, out] Instance The pointer to the IP6 config instance data. + + @retval EFI_NOT_FOUND The variable can not be found or already corrupted. + @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation. + @retval EFI_SUCCESS The configuration data was retrieved successfully. + +**/ +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; +} + +/** + Write the configuration data from IP6_CONFIG_INSTANCE to variable storage. + + @param[in] VarName The pointer to the variable name. + @param[in] Instance The pointer to the IP6 configuration instance data. + + @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation. + @retval EFI_SUCCESS The configuration data is written successfully. + +**/ +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; +} + +/** + The work function for EfiIp6ConfigGetData() to get the interface information + of the communication device this IP6Config instance manages. + + @param[in] Instance Pointer to the IP6 config instance data. + @param[in, out] DataSize On input, in bytes, the size of Data. On output, in + bytes, the size of buffer required to store the specified + configuration data. + @param[in] Data The data buffer in which the configuration data is returned. + Ignored if DataSize is ZERO. + + @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified + configuration data, and the required size is + returned in DataSize. + @retval EFI_SUCCESS The specified configuration data was obtained. + +**/ +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; +} + +/** + The work function for EfiIp6ConfigSetData() to set the alternative interface ID + for the communication device managed by this IP6Config instance, if the link local + IPv6 addresses generated from the interface ID based on the default source the + EFI IPv6 Protocol uses is a duplicate address. + + @param[in] Instance Pointer to the IP6 configuration instance data. + @param[in] DataSize Size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set. + + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type, + 8 bytes. + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set. + +**/ +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; +} + +/** + The work function for EfiIp6ConfigSetData() to set the general configuration + policy for the EFI IPv6 network stack that is running on the communication device + managed by this IP6Config instance. The policy will affect other configuration settings. + + @param[in] Instance Pointer to the IP6 config instance data. + @param[in] DataSize Size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set. + + @retval EFI_INVALID_PARAMETER The to be set policy is invalid. + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type. + @retval EFI_ABORTED The new policy equals the current policy. + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set. + +**/ +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; + } +} + +/** + The work function for EfiIp6ConfigSetData() to set the number of consecutive + Neighbor Solicitation messages sent while performing Duplicate Address Detection + on a tentative address. A value of ZERO indicates that Duplicate Address Detection + will not be performed on a tentative address. + + @param[in] Instance The Instance Pointer to the IP6 config instance data. + @param[in] DataSize Size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set. + + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type. + @retval EFI_ABORTED The new transmit count equals the current configuration. + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set. + +**/ +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; + } +} + +/** + The callback function for Ip6SetAddr. The prototype is defined + as IP6_DAD_CALLBACK. It is called after Duplicate Address Detection is performed + for the manual address set by Ip6ConfigSetManualAddress. + + @param[in] IsDadPassed If TRUE, Duplicate Address Detection passed. + @param[in] TargetAddress The tentative IPv6 address to be checked. + @param[in] Context Pointer to the IP6 configuration instance data. + +**/ +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); + } +} + +/** + The work function for EfiIp6ConfigSetData() to set the station addresses manually + for the EFI IPv6 network stack. It is only configurable when the policy is + Ip6ConfigPolicyManual. + + @param[in] Instance Pointer to the IP6 configuration instance data. + @param[in] DataSize Size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set. + + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type. + @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set + under the current policy. + @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid. + @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation. + @retval EFI_NOT_READY An asynchronous process is invoked to set the specified + configuration data, and the process is not finished. + @retval EFI_ABORTED The manual addresses to be set equal current + configuration. + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set. + +**/ +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; +} + +/** + The work function for EfiIp6ConfigSetData() to set the gateway addresses manually + for the EFI IPv6 network stack that is running on the communication device that + this EFI IPv6 Configuration Protocol manages. It is not configurable when the policy is + Ip6ConfigPolicyAutomatic. The gateway addresses must be unicast IPv6 addresses. + + @param[in] Instance The pointer to the IP6 config instance data. + @param[in] DataSize The size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set. This points to an array of + EFI_IPv6_ADDRESS instances. + + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type. + @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set + under the current policy. + @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid. + @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to complete the operation. + @retval EFI_ABORTED The manual gateway addresses to be set equal the + current configuration. + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set. + +**/ +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; +} + +/** + The work function for EfiIp6ConfigSetData() to set the DNS server list for the + EFI IPv6 network stack running on the communication device that this EFI IPv6 + Configuration Protocol manages. It is not configurable when the policy is + Ip6ConfigPolicyAutomatic. The DNS server addresses must be unicast IPv6 addresses. + + @param[in] Instance The pointer to the IP6 config instance data. + @param[in] DataSize The size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set, points to an array of + EFI_IPv6_ADDRESS instances. + + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type. + @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set + under the current policy. + @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid. + @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation. + @retval EFI_ABORTED The DNS server addresses to be set equal the current + configuration. + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set. + +**/ +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; +} + +/** + Generate the operational state of the interface this IP6 config instance manages + and output in EFI_IP6_CONFIG_INTERFACE_INFO. + + @param[in] IpSb The pointer to the IP6 service binding instance. + @param[out] IfInfo The pointer to the IP6 configuration interface information structure. + +**/ +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); +} + +/** + Parse DHCPv6 reply packet to get the DNS server list. + It is the work function for Ip6ConfigOnDhcp6Reply and Ip6ConfigOnDhcp6Event. + + @param[in] Dhcp6 The pointer to the EFI_DHCP6_PROTOCOL instance. + @param[in, out] Instance The pointer to the IP6 configuration instance data. + @param[in] Reply The pointer to the DHCPv6 reply packet. + + @retval EFI_SUCCESS The DNS server address was retrieved from the reply packet. + @retval EFI_NOT_READY The reply packet does not contain the DNS server option, or + the DNS server address is not valid. + +**/ +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; +} + +/** + The callback function for Ip6SetAddr. The prototype is defined + as IP6_DAD_CALLBACK. It is called after Duplicate Address Detection is performed + on the tentative address by DHCPv6 in Ip6ConfigOnDhcp6Event(). + + @param[in] IsDadPassed If TRUE, Duplicate Address Detection passes. + @param[in] TargetAddress The tentative IPv6 address to be checked. + @param[in] Context Pointer to the IP6 configuration instance data. + +**/ +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; + } +} + +/** + The event handle routine when DHCPv6 process is finished or is updated. + + @param[in] Event Not used. + @param[in] Context The pointer to the IP6 configuration instance data. + +**/ +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); +} + +/** + The event process routine when the DHCPv6 server is answered with a reply packet + for an information request. + + @param[in] This Points to the EFI_DHCP6_PROTOCOL. + @param[in] Context The pointer to the IP6 configuration instance data. + @param[in] Packet The DHCPv6 reply packet. + + @retval EFI_SUCCESS The DNS server address was retrieved from the reply packet. + @retval EFI_NOT_READY The reply packet does not contain the DNS server option, or + the DNS server address is not valid. + +**/ +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); +} + +/** + The event process routine when the DHCPv6 service binding protocol is installed + in the system. + + @param[in] Event Not used. + @param[in] Context The pointer to the IP6 config instance data. + +**/ +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); +} + +/** + Set the configuration for the EFI IPv6 network stack running on the communication + device this EFI IPv6 Configuration Protocol instance manages. + + This function is used to set the configuration data of type DataType for the EFI + IPv6 network stack that is running on the communication device that this EFI IPv6 + Configuration Protocol instance manages. + + DataSize is used to calculate the count of structure instances in the Data for + a DataType in which multiple structure instances are allowed. + + This function is always non-blocking. When setting some type of configuration data, + an asynchronous process is invoked to check the correctness of the data, such as + performing Duplicate Address Detection on the manually set local IPv6 addresses. + EFI_NOT_READY is returned immediately to indicate that such an asynchronous process + is invoked, and the process is not finished yet. The caller wanting to get the result + of the asynchronous process is required to call RegisterDataNotify() to register an + event on the specified configuration data. Once the event is signaled, the caller + can call GetData() to obtain the configuration data and know the result. + For other types of configuration data that do not require an asynchronous configuration + process, the result of the operation is immediately returned. + + @param[in] This The pointer to the EFI_IP6_CONFIG_PROTOCOL instance. + @param[in] DataType The type of data to set. + @param[in] DataSize Size of the buffer pointed to by Data in bytes. + @param[in] Data The data buffer to set. The type of the data buffer is + associated with the DataType. + + @retval EFI_SUCCESS The specified configuration data for the EFI IPv6 + network stack was set successfully. + @retval EFI_INVALID_PARAMETER One or more of the following are TRUE: + - This is NULL. + - One or more fields in Data and DataSizedo not match the + requirement of the data type indicated by DataType. + @retval EFI_WRITE_PROTECTED The specified configuration data is read-only or the specified + configuration data cannot be set under the current policy. + @retval EFI_ACCESS_DENIED Another set operation on the specified configuration + data is already in process. + @retval EFI_NOT_READY An asynchronous process was invoked to set the specified + configuration data, and the process is not finished yet. + @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type + indicated by DataType. + @retval EFI_UNSUPPORTED This DataType is not supported. + @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated. + @retval EFI_DEVICE_ERROR An unexpected system error or network error occurred. + +**/ +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; +} + +/** + Get the configuration data for the EFI IPv6 network stack running on the communication + device that this EFI IPv6 Configuration Protocol instance manages. + + This function returns the configuration data of type DataType for the EFI IPv6 network + stack running on the communication device that this EFI IPv6 Configuration Protocol instance + manages. + + The caller is responsible for allocating the buffer used to return the specified + configuration data. The required size will be returned to the caller if the size of + the buffer is too small. + + EFI_NOT_READY is returned if the specified configuration data is not ready due to an + asynchronous configuration process already in progress. The caller can call RegisterDataNotify() + to register an event on the specified configuration data. Once the asynchronous configuration + process is finished, the event will be signaled, and a subsequent GetData() call will return + the specified configuration data. + + @param[in] This Pointer to the EFI_IP6_CONFIG_PROTOCOL instance. + @param[in] DataType The type of data to get. + @param[in, out] DataSize On input, in bytes, the size of Data. On output, in bytes, the + size of buffer required to store the specified configuration data. + @param[in] Data The data buffer in which the configuration data is returned. The + type of the data buffer is associated with the DataType. + This is an optional parameter that may be NULL. + + @retval EFI_SUCCESS The specified configuration data was obtained successfully. + @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE: + - This is NULL. + - DataSize is NULL. + - Data is NULL if *DataSize is not zero. + @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified configuration data, + and the required size is returned in DataSize. + @retval EFI_NOT_READY The specified configuration data is not ready due to an + asynchronous configuration process already in progress. + @retval EFI_NOT_FOUND The specified configuration data is not found. + +**/ +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; +} + +/** + Register an event that is signaled whenever a configuration process on the specified + configuration data is done. + + This function registers an event that is to be signaled whenever a configuration + process on the specified configuration data is performed. An event can be registered + for a different DataType simultaneously. The caller is responsible for determining + which type of configuration data causes the signaling of the event in such an event. + + @param[in] This Pointer to the EFI_IP6_CONFIG_PROTOCOL instance. + @param[in] DataType The type of data to unregister the event for. + @param[in] Event The event to register. + + @retval EFI_SUCCESS The notification event for the specified configuration data is + registered. + @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL. + @retval EFI_UNSUPPORTED The configuration data type specified by DataType is not + supported. + @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated. + @retval EFI_ACCESS_DENIED The Event is already registered for the DataType. + +**/ +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; +} + +/** + Remove a previously registered event for the specified configuration data. + + @param This The pointer to the EFI_IP6_CONFIG_PROTOCOL instance. + @param DataType The type of data to remove from the previously + registered event. + @param Event The event to be unregistered. + + @retval EFI_SUCCESS The event registered for the specified + configuration data was removed. + @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL. + @retval EFI_NOT_FOUND The Event has not been registered for the + specified DataType. + +**/ +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; +} + +/** + Initialize an IP6_CONFIG_INSTANCE. + + @param[out] Instance The buffer of IP6_CONFIG_INSTANCE to be initialized. + + @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation. + @retval EFI_SUCCESS The IP6_CONFIG_INSTANCE initialized successfully. + +**/ +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; + + 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 = NET_RANDOM (NetRandomInitSeed ()); + + 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); +} + +/** + Release an IP6_CONFIG_INSTANCE. + + @param[in, out] Instance The buffer of IP6_CONFIG_INSTANCE to be freed. + +**/ +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); +} + +/** + Destroy the Dhcp6 child in IP6_CONFIG_INSTANCE and release the resources. + + @param[in, out] Instance The buffer of IP6_CONFIG_INSTANCE to be freed. + + @retval EFI_SUCCESS The child was successfully destroyed. + @retval Others Failed to destroy the child. + +**/ +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; +} + -- cgit v1.2.3