2 The implementation of EFI IPv6 Configuration Protocol.
4 Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 LIST_ENTRY mIp6ConfigInstanceList
= {&mIp6ConfigInstanceList
, &mIp6ConfigInstanceList
};
21 The event process routine when the DHCPv6 service binding protocol is installed
24 @param[in] Event Not used.
25 @param[in] Context Pointer to the IP6 config instance data.
30 Ip6ConfigOnDhcp6SbInstalled (
36 Update the current policy to NewPolicy. During the transition
37 period, the default router list, on-link prefix list, autonomous prefix list
38 and address list in all interfaces will be released.
40 @param[in] IpSb The IP6 service binding instance.
41 @param[in] NewPolicy The new policy to be updated to.
45 Ip6ConfigOnPolicyChanged (
47 IN EFI_IP6_CONFIG_POLICY NewPolicy
54 IP6_DAD_ENTRY
*DadEntry
;
55 IP6_DELAY_JOIN_LIST
*DelayNode
;
58 // Currently there are only two policies: Manual and Automatic. Regardless of
59 // what transition is going on, i.e., Manual -> Automatic and Automatic ->
60 // Manual, we have to free default router list, on-link prefix list, autonomous
61 // prefix list, address list in all the interfaces and destroy any IPv6 child
62 // instance whose local IP is neither 0 nor the link-local address.
64 Ip6CleanDefaultRouterList (IpSb
);
65 Ip6CleanPrefixListTable (IpSb
, &IpSb
->OnlinkPrefix
);
66 Ip6CleanPrefixListTable (IpSb
, &IpSb
->AutonomousPrefix
);
69 // It's tricky... If the LinkLocal address is O.K., add back the link-local
70 // prefix to the on-link prefix table.
72 if (IpSb
->LinkLocalOk
) {
73 Ip6CreatePrefixListEntry (
76 (UINT32
) IP6_INFINIT_LIFETIME
,
77 (UINT32
) IP6_INFINIT_LIFETIME
,
78 IP6_LINK_LOCAL_PREFIX_LENGTH
,
84 // All IPv6 children that use global unicast address as it's source address
85 // should be destryoed now. The survivers are those use the link-local address
86 // or the unspecified address as the source address.
87 // TODO: Conduct a check here.
90 &IpSb
->DefaultInterface
->AddressList
,
91 &IpSb
->DefaultInterface
->AddressCount
,
96 NET_LIST_FOR_EACH (Entry
, &IpSb
->Interfaces
) {
98 // remove all pending delay node and DAD entries for the global addresses.
100 IpIf
= NET_LIST_USER_STRUCT_S (Entry
, IP6_INTERFACE
, Link
, IP6_INTERFACE_SIGNATURE
);
102 NET_LIST_FOR_EACH_SAFE (Entry2
, Next
, &IpIf
->DelayJoinList
) {
103 DelayNode
= NET_LIST_USER_STRUCT (Entry2
, IP6_DELAY_JOIN_LIST
, Link
);
104 if (!NetIp6IsLinkLocalAddr (&DelayNode
->AddressInfo
->Address
)) {
105 RemoveEntryList (&DelayNode
->Link
);
106 FreePool (DelayNode
);
110 NET_LIST_FOR_EACH_SAFE (Entry2
, Next
, &IpIf
->DupAddrDetectList
) {
111 DadEntry
= NET_LIST_USER_STRUCT_S (Entry2
, IP6_DAD_ENTRY
, Link
, IP6_DAD_ENTRY_SIGNATURE
);
113 if (!NetIp6IsLinkLocalAddr (&DadEntry
->AddressInfo
->Address
)) {
115 // Fail this DAD entry if the address is not link-local.
117 Ip6OnDADFinished (FALSE
, IpIf
, DadEntry
);
122 if (NewPolicy
== Ip6ConfigPolicyAutomatic
) {
124 // Set parameters to trigger router solicitation sending in timer handler.
126 IpSb
->RouterAdvertiseReceived
= FALSE
;
127 IpSb
->SolicitTimer
= IP6_MAX_RTR_SOLICITATIONS
;
131 IpSb
->Ticks
= (UINT32
) IP6_GET_TICKS (IP6_ONE_SECOND_IN_MS
);
137 The work function to trigger the DHCPv6 process to perform a stateful autoconfiguration.
139 @param[in] Instance Pointer to the IP6 config instance data.
140 @param[in] OtherInfoOnly If FALSE, get stateful address and other information
141 via DHCPv6. Otherwise, only get the other information.
143 @retval EFI_SUCCESS The operation finished successfully.
144 @retval EFI_UNSUPPORTED The DHCP6 driver is not available.
148 Ip6ConfigStartStatefulAutoConfig (
149 IN IP6_CONFIG_INSTANCE
*Instance
,
150 IN BOOLEAN OtherInfoOnly
155 EFI_DHCP6_CONFIG_DATA Dhcp6CfgData
;
156 EFI_DHCP6_PROTOCOL
*Dhcp6
;
157 EFI_DHCP6_PACKET_OPTION
*OptList
[1];
159 EFI_DHCP6_PACKET_OPTION
*Oro
;
160 EFI_DHCP6_RETRANSMISSION InfoReqReXmit
;
163 // A host must not invoke stateful address configuration if it is already
164 // participating in the statuful protocol as a result of an earlier advertisement.
166 if (Instance
->Dhcp6Handle
!= NULL
) {
170 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
172 Instance
->OtherInfoOnly
= OtherInfoOnly
;
174 Status
= NetLibCreateServiceChild (
177 &gEfiDhcp6ServiceBindingProtocolGuid
,
178 &Instance
->Dhcp6Handle
181 if (Status
== EFI_UNSUPPORTED
) {
183 // No DHCPv6 Service Binding protocol, register a notify.
185 if (Instance
->Dhcp6SbNotifyEvent
== NULL
) {
186 Instance
->Dhcp6SbNotifyEvent
= EfiCreateProtocolNotifyEvent (
187 &gEfiDhcp6ServiceBindingProtocolGuid
,
189 Ip6ConfigOnDhcp6SbInstalled
,
191 &Instance
->Registration
196 if (EFI_ERROR (Status
)) {
200 if (Instance
->Dhcp6SbNotifyEvent
!= NULL
) {
201 gBS
->CloseEvent (Instance
->Dhcp6SbNotifyEvent
);
204 Status
= gBS
->OpenProtocol (
205 Instance
->Dhcp6Handle
,
206 &gEfiDhcp6ProtocolGuid
,
207 (VOID
**) &Instance
->Dhcp6
,
210 EFI_OPEN_PROTOCOL_BY_DRIVER
212 ASSERT_EFI_ERROR (Status
);
214 Dhcp6
= Instance
->Dhcp6
;
215 Dhcp6
->Configure (Dhcp6
, NULL
);
218 // Set the exta options to send. Here we only want the option request option
221 Oro
= (EFI_DHCP6_PACKET_OPTION
*) OptBuf
;
222 Oro
->OpCode
= HTONS (DHCP6_OPT_ORO
);
223 Oro
->OpLen
= HTONS (2);
224 *((UINT16
*) &Oro
->Data
[0]) = HTONS (DHCP6_OPT_DNS_SERVERS
);
227 Status
= EFI_SUCCESS
;
229 if (!OtherInfoOnly
) {
231 // Get stateful address and other information via DHCPv6.
233 Dhcp6CfgData
.Dhcp6Callback
= NULL
;
234 Dhcp6CfgData
.CallbackContext
= NULL
;
235 Dhcp6CfgData
.OptionCount
= 1;
236 Dhcp6CfgData
.OptionList
= &OptList
[0];
237 Dhcp6CfgData
.IaDescriptor
.Type
= EFI_DHCP6_IA_TYPE_NA
;
238 Dhcp6CfgData
.IaDescriptor
.IaId
= Instance
->IaId
;
239 Dhcp6CfgData
.IaInfoEvent
= Instance
->Dhcp6Event
;
240 Dhcp6CfgData
.ReconfigureAccept
= FALSE
;
241 Dhcp6CfgData
.RapidCommit
= FALSE
;
242 Dhcp6CfgData
.SolicitRetransmission
= NULL
;
244 Status
= Dhcp6
->Configure (Dhcp6
, &Dhcp6CfgData
);
246 if (!EFI_ERROR (Status
)) {
248 if (IpSb
->LinkLocalOk
) {
249 Status
= Dhcp6
->Start (Dhcp6
);
251 IpSb
->Dhcp6NeedStart
= TRUE
;
257 // Only get other information via DHCPv6, this doesn't require a config
260 InfoReqReXmit
.Irt
= 4;
261 InfoReqReXmit
.Mrc
= 64;
262 InfoReqReXmit
.Mrt
= 60;
263 InfoReqReXmit
.Mrd
= 0;
265 if (IpSb
->LinkLocalOk
) {
266 Status
= Dhcp6
->InfoRequest (
273 Instance
->Dhcp6Event
,
274 Ip6ConfigOnDhcp6Reply
,
278 IpSb
->Dhcp6NeedInfoRequest
= TRUE
;
287 Signal the registered event. It is the callback routine for NetMapIterate.
289 @param[in] Map Points to the list of registered event.
290 @param[in] Item The registered event.
291 @param[in] Arg Not used.
296 Ip6ConfigSignalEvent (
298 IN NET_MAP_ITEM
*Item
,
302 gBS
->SignalEvent ((EFI_EVENT
) Item
->Key
);
308 Read the configuration data from variable storage according to the VarName and
309 gEfiIp6ConfigProtocolGuid. It checks the integrity of variable data. If the
310 data is corrupted, it clears the variable data to ZERO. Othewise, it outputs the
311 configuration data to IP6_CONFIG_INSTANCE.
313 @param[in] VarName The pointer to the variable name
314 @param[in, out] Instance The pointer to the IP6 config instance data.
316 @retval EFI_NOT_FOUND The variable can not be found or already corrupted.
317 @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation.
318 @retval EFI_SUCCESS The configuration data was retrieved successfully.
322 Ip6ConfigReadConfigData (
324 IN OUT IP6_CONFIG_INSTANCE
*Instance
329 IP6_CONFIG_VARIABLE
*Variable
;
330 IP6_CONFIG_DATA_ITEM
*DataItem
;
332 IP6_CONFIG_DATA_RECORD DataRecord
;
336 // Try to read the configuration variable.
339 Status
= gRT
->GetVariable (
341 &gEfiIp6ConfigProtocolGuid
,
347 if (Status
== EFI_BUFFER_TOO_SMALL
) {
349 // Allocate buffer and read the config variable.
351 Variable
= AllocatePool (VarSize
);
352 if (Variable
== NULL
) {
353 return EFI_OUT_OF_RESOURCES
;
356 Status
= gRT
->GetVariable (
358 &gEfiIp6ConfigProtocolGuid
,
363 if (EFI_ERROR (Status
) || (UINT16
) (~NetblockChecksum ((UINT8
*) Variable
, (UINT32
) VarSize
)) != 0) {
365 // GetVariable still error or the variable is corrupted.
366 // Fall back to the default value.
371 // Remove the problematic variable and return EFI_NOT_FOUND, a new
372 // variable will be set again.
376 &gEfiIp6ConfigProtocolGuid
,
377 IP6_CONFIG_VARIABLE_ATTRIBUTE
,
382 return EFI_NOT_FOUND
;
386 // Get the IAID we use.
388 Instance
->IaId
= Variable
->IaId
;
390 for (Index
= 0; Index
< Variable
->DataRecordCount
; Index
++) {
392 CopyMem (&DataRecord
, &Variable
->DataRecord
[Index
], sizeof (DataRecord
));
394 DataItem
= &Instance
->DataItem
[DataRecord
.DataType
];
395 if (DATA_ATTRIB_SET (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
) &&
396 (DataItem
->DataSize
!= DataRecord
.DataSize
)
399 // Perhaps a corrupted data record...
404 if (!DATA_ATTRIB_SET (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
)) {
406 // This data item has variable length data.
408 DataItem
->Data
.Ptr
= AllocatePool (DataRecord
.DataSize
);
409 if (DataItem
->Data
.Ptr
== NULL
) {
411 // no memory resource
417 Data
= (CHAR8
*) Variable
+ DataRecord
.Offset
;
418 CopyMem (DataItem
->Data
.Ptr
, Data
, DataRecord
.DataSize
);
420 DataItem
->DataSize
= DataRecord
.DataSize
;
421 DataItem
->Status
= EFI_SUCCESS
;
432 Write the configuration data from IP6_CONFIG_INSTANCE to variable storage.
434 @param[in] VarName The pointer to the variable name.
435 @param[in] Instance The pointer to the IP6 configuration instance data.
437 @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation.
438 @retval EFI_SUCCESS The configuration data is written successfully.
442 Ip6ConfigWriteConfigData (
444 IN IP6_CONFIG_INSTANCE
*Instance
449 IP6_CONFIG_DATA_ITEM
*DataItem
;
450 IP6_CONFIG_VARIABLE
*Variable
;
451 IP6_CONFIG_DATA_RECORD
*DataRecord
;
455 VarSize
= sizeof (IP6_CONFIG_VARIABLE
) - sizeof (IP6_CONFIG_DATA_RECORD
);
457 for (Index
= 0; Index
< Ip6ConfigDataTypeMaximum
; Index
++) {
459 DataItem
= &Instance
->DataItem
[Index
];
460 if (!DATA_ATTRIB_SET (DataItem
->Attribute
, DATA_ATTRIB_VOLATILE
) && !EFI_ERROR (DataItem
->Status
)) {
462 VarSize
+= sizeof (IP6_CONFIG_DATA_RECORD
) + DataItem
->DataSize
;
466 Variable
= AllocatePool (VarSize
);
467 if (Variable
== NULL
) {
468 return EFI_OUT_OF_RESOURCES
;
471 Variable
->IaId
= Instance
->IaId
;
472 Heap
= (CHAR8
*) Variable
+ VarSize
;
473 Variable
->DataRecordCount
= 0;
475 for (Index
= 0; Index
< Ip6ConfigDataTypeMaximum
; Index
++) {
477 DataItem
= &Instance
->DataItem
[Index
];
478 if (!DATA_ATTRIB_SET (DataItem
->Attribute
, DATA_ATTRIB_VOLATILE
) && !EFI_ERROR (DataItem
->Status
)) {
480 Heap
-= DataItem
->DataSize
;
481 CopyMem (Heap
, DataItem
->Data
.Ptr
, DataItem
->DataSize
);
483 DataRecord
= &Variable
->DataRecord
[Variable
->DataRecordCount
];
484 DataRecord
->DataType
= (EFI_IP6_CONFIG_DATA_TYPE
) Index
;
485 DataRecord
->DataSize
= (UINT32
) DataItem
->DataSize
;
486 DataRecord
->Offset
= (UINT16
) (Heap
- (CHAR8
*) Variable
);
488 Variable
->DataRecordCount
++;
492 Variable
->Checksum
= 0;
493 Variable
->Checksum
= (UINT16
) ~NetblockChecksum ((UINT8
*) Variable
, (UINT32
) VarSize
);
495 Status
= gRT
->SetVariable (
497 &gEfiIp6ConfigProtocolGuid
,
498 IP6_CONFIG_VARIABLE_ATTRIBUTE
,
509 The work function for EfiIp6ConfigGetData() to get the interface information
510 of the communication device this IP6Config instance manages.
512 @param[in] Instance Pointer to the IP6 config instance data.
513 @param[in, out] DataSize On input, in bytes, the size of Data. On output, in
514 bytes, the size of buffer required to store the specified
516 @param[in] Data The data buffer in which the configuration data is returned.
517 Ignored if DataSize is ZERO.
519 @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified
520 configuration data, and the required size is
521 returned in DataSize.
522 @retval EFI_SUCCESS The specified configuration data was obtained.
527 IN IP6_CONFIG_INSTANCE
*Instance
,
528 IN OUT UINTN
*DataSize
,
529 IN VOID
*Data OPTIONAL
534 IP6_CONFIG_DATA_ITEM
*Item
;
535 EFI_IP6_CONFIG_INTERFACE_INFO
*IfInfo
;
539 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
540 Length
= sizeof (EFI_IP6_CONFIG_INTERFACE_INFO
);
543 // Calculate the required length, add the buffer size for AddressInfo and
546 Ip6BuildEfiAddressList (IpSb
, &AddressCount
, NULL
);
547 Ip6BuildEfiRouteTable (IpSb
->RouteTable
, &RouteCount
, NULL
);
549 Length
+= AddressCount
* sizeof (EFI_IP6_ADDRESS_INFO
) + RouteCount
* sizeof (EFI_IP6_ROUTE_TABLE
);
551 if (*DataSize
< Length
) {
553 return EFI_BUFFER_TOO_SMALL
;
557 // Copy the fixed size part of the interface info.
559 Item
= &Instance
->DataItem
[Ip6ConfigDataTypeInterfaceInfo
];
560 IfInfo
= (EFI_IP6_CONFIG_INTERFACE_INFO
*) Data
;
561 CopyMem (IfInfo
, Item
->Data
.Ptr
, sizeof (EFI_IP6_CONFIG_INTERFACE_INFO
));
566 IfInfo
->AddressInfo
= (EFI_IP6_ADDRESS_INFO
*) (IfInfo
+ 1);
567 Ip6BuildEfiAddressList (IpSb
, &IfInfo
->AddressInfoCount
, &IfInfo
->AddressInfo
);
572 IfInfo
->RouteTable
= (EFI_IP6_ROUTE_TABLE
*) (IfInfo
->AddressInfo
+ IfInfo
->AddressInfoCount
);
573 Ip6BuildEfiRouteTable (IpSb
->RouteTable
, &IfInfo
->RouteCount
, &IfInfo
->RouteTable
);
575 if (IfInfo
->AddressInfoCount
== 0) {
576 IfInfo
->AddressInfo
= NULL
;
579 if (IfInfo
->RouteCount
== 0) {
580 IfInfo
->RouteTable
= NULL
;
587 The work function for EfiIp6ConfigSetData() to set the alternative inteface ID
588 for the communication device managed by this IP6Config instance, if the link local
589 IPv6 addresses generated from the interface ID based on the default source the
590 EFI IPv6 Protocol uses is a duplicate address.
592 @param[in] Instance Pointer to the IP6 configuration instance data.
593 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
594 @param[in] Data The data buffer to set.
596 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type,
598 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
599 network stack was set.
603 Ip6ConfigSetAltIfId (
604 IN IP6_CONFIG_INSTANCE
*Instance
,
609 EFI_IP6_CONFIG_INTERFACE_ID
*OldIfId
;
610 EFI_IP6_CONFIG_INTERFACE_ID
*NewIfId
;
611 IP6_CONFIG_DATA_ITEM
*DataItem
;
613 if (DataSize
!= sizeof (EFI_IP6_CONFIG_INTERFACE_ID
)) {
614 return EFI_BAD_BUFFER_SIZE
;
617 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeAltInterfaceId
];
618 OldIfId
= DataItem
->Data
.AltIfId
;
619 NewIfId
= (EFI_IP6_CONFIG_INTERFACE_ID
*) Data
;
621 CopyMem (OldIfId
, NewIfId
, DataSize
);
622 DataItem
->Status
= EFI_SUCCESS
;
628 The work function for EfiIp6ConfigSetData() to set the general configuration
629 policy for the EFI IPv6 network stack that is running on the communication device
630 managed by this IP6Config instance. The policy will affect other configuration settings.
632 @param[in] Instance Pointer to the IP6 config instance data.
633 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
634 @param[in] Data The data buffer to set.
636 @retval EFI_INVALID_PARAMETER The to be set policy is invalid.
637 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
638 @retval EFI_ABORTED The new policy equals the current policy.
639 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
640 network stack was set.
645 IN IP6_CONFIG_INSTANCE
*Instance
,
650 EFI_IP6_CONFIG_POLICY NewPolicy
;
651 IP6_CONFIG_DATA_ITEM
*DataItem
;
654 if (DataSize
!= sizeof (EFI_IP6_CONFIG_POLICY
)) {
655 return EFI_BAD_BUFFER_SIZE
;
658 NewPolicy
= *((EFI_IP6_CONFIG_POLICY
*) Data
);
660 if (NewPolicy
> Ip6ConfigPolicyAutomatic
) {
661 return EFI_INVALID_PARAMETER
;
664 if (NewPolicy
== Instance
->Policy
) {
669 // Clean the ManualAddress, Gateway and DnsServers, shrink the variable
670 // data size, and fire up all the related events.
672 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeManualAddress
];
673 if (DataItem
->Data
.Ptr
!= NULL
) {
674 FreePool (DataItem
->Data
.Ptr
);
676 DataItem
->Data
.Ptr
= NULL
;
677 DataItem
->DataSize
= 0;
678 DataItem
->Status
= EFI_NOT_FOUND
;
679 NetMapIterate (&DataItem
->EventMap
, Ip6ConfigSignalEvent
, NULL
);
681 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeGateway
];
682 if (DataItem
->Data
.Ptr
!= NULL
) {
683 FreePool (DataItem
->Data
.Ptr
);
685 DataItem
->Data
.Ptr
= NULL
;
686 DataItem
->DataSize
= 0;
687 DataItem
->Status
= EFI_NOT_FOUND
;
688 NetMapIterate (&DataItem
->EventMap
, Ip6ConfigSignalEvent
, NULL
);
690 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeDnsServer
];
691 DataItem
->Data
.Ptr
= NULL
;
692 DataItem
->DataSize
= 0;
693 DataItem
->Status
= EFI_NOT_FOUND
;
694 NetMapIterate (&DataItem
->EventMap
, Ip6ConfigSignalEvent
, NULL
);
696 if (NewPolicy
== Ip6ConfigPolicyManual
) {
698 // The policy is changed from automatic to manual. Stop the DHCPv6 process
699 // and destroy the DHCPv6 child.
701 if (Instance
->Dhcp6Handle
!= NULL
) {
702 Ip6ConfigDestroyDhcp6 (Instance
);
706 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
707 Ip6ConfigOnPolicyChanged (IpSb
, NewPolicy
);
709 Instance
->Policy
= NewPolicy
;
716 The work function for EfiIp6ConfigSetData() to set the number of consecutive
717 Neighbor Solicitation messages sent while performing Duplicate Address Detection
718 on a tentative address. A value of ZERO indicates that Duplicate Address Detection
719 will not be performed on a tentative address.
721 @param[in] Instance The Instance Pointer to the IP6 config instance data.
722 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
723 @param[in] Data The data buffer to set.
725 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
726 @retval EFI_ABORTED The new transmit count equals the current configuration.
727 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
728 network stack was set.
732 Ip6ConfigSetDadXmits (
733 IN IP6_CONFIG_INSTANCE
*Instance
,
738 EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS
*OldDadXmits
;
740 if (DataSize
!= sizeof (EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS
)) {
741 return EFI_BAD_BUFFER_SIZE
;
744 OldDadXmits
= Instance
->DataItem
[Ip6ConfigDataTypeDupAddrDetectTransmits
].Data
.DadXmits
;
746 if ((*(UINT32
*) Data
) == OldDadXmits
->DupAddrDetectTransmits
) {
751 OldDadXmits
->DupAddrDetectTransmits
= *((UINT32
*) Data
);
757 The callback function for Ip6SetAddr. The prototype is defined
758 as IP6_DAD_CALLBACK. It is called after Duplicate Address Detection is performed
759 for the manual address set by Ip6ConfigSetMaunualAddress.
761 @param[in] IsDadPassed If TRUE, Duplicate Address Detection passed.
762 @param[in] TargetAddress The tentative IPv6 address to be checked.
763 @param[in] Context Pointer to the IP6 configuration instance data.
767 Ip6ManualAddrDadCallback (
768 IN BOOLEAN IsDadPassed
,
769 IN EFI_IPv6_ADDRESS
*TargetAddress
,
773 IP6_CONFIG_INSTANCE
*Instance
;
775 IP6_CONFIG_DATA_ITEM
*Item
;
776 EFI_IP6_CONFIG_MANUAL_ADDRESS
*ManualAddr
;
777 EFI_IP6_CONFIG_MANUAL_ADDRESS
*PassedAddr
;
782 Instance
= (IP6_CONFIG_INSTANCE
*) Context
;
783 NET_CHECK_SIGNATURE (Instance
, IP6_CONFIG_INSTANCE_SIGNATURE
);
784 Item
= &Instance
->DataItem
[Ip6ConfigDataTypeManualAddress
];
787 for (Index
= 0; Index
< Item
->DataSize
/ sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
); Index
++) {
789 // Find the original tag used to place into the NET_MAP.
791 ManualAddr
= Item
->Data
.ManualAddress
+ Index
;
792 if (EFI_IP6_EQUAL (TargetAddress
, &ManualAddr
->Address
)) {
797 ASSERT (Index
!= Item
->DataSize
/ sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
));
800 NetMapInsertTail (&Instance
->DadPassedMap
, ManualAddr
, NULL
);
802 NetMapInsertTail (&Instance
->DadFailedMap
, ManualAddr
, NULL
);
805 DadPassCount
= NetMapGetCount (&Instance
->DadPassedMap
);
806 DadFailCount
= NetMapGetCount (&Instance
->DadFailedMap
);
808 if ((DadPassCount
+ DadFailCount
) == (Item
->DataSize
/ sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
))) {
810 // All addresses have finished the configuration process.
812 if (DadFailCount
!= 0) {
814 // There is at least one duplicate address.
816 FreePool (Item
->Data
.Ptr
);
818 Item
->DataSize
= DadPassCount
* sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
);
819 if (Item
->DataSize
== 0) {
821 // All failed, bad luck.
823 Item
->Data
.Ptr
= NULL
;
824 Item
->Status
= EFI_NOT_FOUND
;
827 // Part of addresses are detected to be duplicates, so update the
828 // data with those passed.
830 PassedAddr
= (EFI_IP6_CONFIG_MANUAL_ADDRESS
*) AllocatePool (Item
->DataSize
);
831 ASSERT (PassedAddr
!= NULL
);
833 Item
->Data
.Ptr
= PassedAddr
;
834 Item
->Status
= EFI_SUCCESS
;
836 while (!NetMapIsEmpty (&Instance
->DadPassedMap
)) {
837 ManualAddr
= (EFI_IP6_CONFIG_MANUAL_ADDRESS
*) NetMapRemoveHead (&Instance
->DadPassedMap
, NULL
);
838 CopyMem (PassedAddr
, ManualAddr
, sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
));
843 ASSERT ((UINTN
) PassedAddr
- (UINTN
) Item
->Data
.Ptr
== Item
->DataSize
);
847 // All addresses are valid.
849 Item
->Status
= EFI_SUCCESS
;
853 // Remove the tags we put in the NET_MAPs.
855 while (!NetMapIsEmpty (&Instance
->DadFailedMap
)) {
856 NetMapRemoveHead (&Instance
->DadFailedMap
, NULL
);
859 while (!NetMapIsEmpty (&Instance
->DadPassedMap
)) {
860 NetMapRemoveHead (&Instance
->DadPassedMap
, NULL
);
864 // Signal the waiting events.
866 NetMapIterate (&Item
->EventMap
, Ip6ConfigSignalEvent
, NULL
);
867 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
868 Ip6ConfigWriteConfigData (IpSb
->MacString
, Instance
);
873 The work function for EfiIp6ConfigSetData() to set the station addresses manually
874 for the EFI IPv6 network stack. It is only configurable when the policy is
875 Ip6ConfigPolicyManual.
877 @param[in] Instance Pointer to the IP6 configuration instance data.
878 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
879 @param[in] Data The data buffer to set.
881 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
882 @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set
883 under the current policy.
884 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
885 @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation.
886 @retval EFI_NOT_READY An asynchrous process is invoked to set the specified
887 configuration data, and the process is not finished.
888 @retval EFI_ABORTED The manual addresses to be set equal current
890 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
891 network stack was set.
895 Ip6ConfigSetMaunualAddress (
896 IN IP6_CONFIG_INSTANCE
*Instance
,
901 EFI_IP6_CONFIG_MANUAL_ADDRESS
*NewAddress
;
902 EFI_IP6_CONFIG_MANUAL_ADDRESS
*TmpAddress
;
903 IP6_CONFIG_DATA_ITEM
*DataItem
;
904 UINTN NewAddressCount
;
908 IP6_ADDRESS_INFO
*CurrentAddrInfo
;
909 IP6_ADDRESS_INFO
*Copy
;
910 LIST_ENTRY CurrentSourceList
;
911 UINT32 CurrentSourceCount
;
915 IP6_PREFIX_LIST_ENTRY
*PrefixEntry
;
919 ASSERT (Instance
->DataItem
[Ip6ConfigDataTypeManualAddress
].Status
!= EFI_NOT_READY
);
921 if (((DataSize
% sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
)) != 0) || (DataSize
== 0)) {
922 return EFI_BAD_BUFFER_SIZE
;
925 if (Instance
->Policy
!= Ip6ConfigPolicyManual
) {
926 return EFI_WRITE_PROTECTED
;
929 NewAddressCount
= DataSize
/ sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS
);
930 NewAddress
= (EFI_IP6_CONFIG_MANUAL_ADDRESS
*) Data
;
932 for (Index1
= 0; Index1
< NewAddressCount
; Index1
++, NewAddress
++) {
934 if (NetIp6IsLinkLocalAddr (&NewAddress
->Address
) ||
935 !NetIp6IsValidUnicast (&NewAddress
->Address
) ||
936 (NewAddress
->PrefixLength
> 128)
939 // make sure the IPv6 address is unicast and not link-local address &&
940 // the prefix length is valid.
942 return EFI_INVALID_PARAMETER
;
945 TmpAddress
= NewAddress
+ 1;
946 for (Index2
= Index1
+ 1; Index2
< NewAddressCount
; Index2
++, TmpAddress
++) {
948 // Any two addresses in the array can't be equal.
950 if (EFI_IP6_EQUAL (&TmpAddress
->Address
, &NewAddress
->Address
)) {
952 return EFI_INVALID_PARAMETER
;
957 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
960 // Build the current source address list.
962 InitializeListHead (&CurrentSourceList
);
963 CurrentSourceCount
= 0;
965 NET_LIST_FOR_EACH (Entry
, &IpSb
->Interfaces
) {
966 IpIf
= NET_LIST_USER_STRUCT_S (Entry
, IP6_INTERFACE
, Link
, IP6_INTERFACE_SIGNATURE
);
968 NET_LIST_FOR_EACH (Entry2
, &IpIf
->AddressList
) {
969 CurrentAddrInfo
= NET_LIST_USER_STRUCT_S (Entry2
, IP6_ADDRESS_INFO
, Link
, IP6_ADDR_INFO_SIGNATURE
);
971 Copy
= AllocateCopyPool (sizeof (IP6_ADDRESS_INFO
), CurrentAddrInfo
);
976 InsertTailList (&CurrentSourceList
, &Copy
->Link
);
977 CurrentSourceCount
++;
982 // Update the value... a long journey starts
984 NewAddress
= AllocateCopyPool (DataSize
, Data
);
985 if (NewAddress
== NULL
) {
986 Ip6RemoveAddr (NULL
, &CurrentSourceList
, &CurrentSourceCount
, NULL
, 0);
988 return EFI_OUT_OF_RESOURCES
;
992 // Store the new data, and init the DataItem status to EFI_NOT_READY because
993 // we may have an asynchronous configuration process.
995 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeManualAddress
];
996 if (DataItem
->Data
.Ptr
!= NULL
) {
997 FreePool (DataItem
->Data
.Ptr
);
999 DataItem
->Data
.Ptr
= NewAddress
;
1000 DataItem
->DataSize
= DataSize
;
1001 DataItem
->Status
= EFI_NOT_READY
;
1004 // Trigger DAD, it's an asynchronous process.
1008 for (Index1
= 0; Index1
< NewAddressCount
; Index1
++, NewAddress
++) {
1009 if (Ip6IsOneOfSetAddress (IpSb
, &NewAddress
->Address
, NULL
, &CurrentAddrInfo
)) {
1010 ASSERT (CurrentAddrInfo
!= NULL
);
1012 // Remove this already existing source address from the CurrentSourceList
1018 &CurrentSourceCount
,
1019 &CurrentAddrInfo
->Address
,
1024 // If the new address's prefix length is not specified, just use the previous configured
1025 // prefix length for this address.
1027 if (NewAddress
->PrefixLength
== 0) {
1028 NewAddress
->PrefixLength
= CurrentAddrInfo
->PrefixLength
;
1032 // This manual address is already in use, see whether prefix length is changed.
1034 if (NewAddress
->PrefixLength
!= CurrentAddrInfo
->PrefixLength
) {
1036 // Remove the on-link prefix table, the route entry will be removed
1039 PrefixEntry
= Ip6FindPrefixListEntry (
1042 CurrentAddrInfo
->PrefixLength
,
1043 &CurrentAddrInfo
->Address
1045 if (PrefixEntry
!= NULL
) {
1046 Ip6DestroyPrefixListEntry (IpSb
, PrefixEntry
, TRUE
, FALSE
);
1050 // Save the prefix length.
1052 CurrentAddrInfo
->PrefixLength
= NewAddress
->PrefixLength
;
1057 // create a new on-link prefix entry.
1059 PrefixEntry
= Ip6FindPrefixListEntry (
1062 NewAddress
->PrefixLength
,
1063 &NewAddress
->Address
1065 if (PrefixEntry
== NULL
) {
1066 Ip6CreatePrefixListEntry (
1069 (UINT32
) IP6_INFINIT_LIFETIME
,
1070 (UINT32
) IP6_INFINIT_LIFETIME
,
1071 NewAddress
->PrefixLength
,
1072 &NewAddress
->Address
1076 CurrentAddrInfo
->IsAnycast
= NewAddress
->IsAnycast
;
1078 // Artificially mark this address passed DAD be'coz it is already in use.
1080 Ip6ManualAddrDadCallback (TRUE
, &NewAddress
->Address
, Instance
);
1088 // Set the new address, this will trigger DAD and activate the address if
1092 IpSb
->DefaultInterface
,
1093 &NewAddress
->Address
,
1094 NewAddress
->IsAnycast
,
1095 NewAddress
->PrefixLength
,
1096 (UINT32
) IP6_INFINIT_LIFETIME
,
1097 (UINT32
) IP6_INFINIT_LIFETIME
,
1098 Ip6ManualAddrDadCallback
,
1105 // Check the CurrentSourceList, it now contains those addresses currently in
1106 // use and will be removed.
1108 IpIf
= IpSb
->DefaultInterface
;
1110 while (!IsListEmpty (&CurrentSourceList
)) {
1113 CurrentAddrInfo
= NET_LIST_HEAD (&CurrentSourceList
, IP6_ADDRESS_INFO
, Link
);
1116 // This local address is going to be removed, the IP instances that are
1117 // currently using it will be destroyed.
1122 &IpIf
->AddressCount
,
1123 &CurrentAddrInfo
->Address
,
1128 // Remove the on-link prefix table, the route entry will be removed
1131 PrefixEntry
= Ip6FindPrefixListEntry (
1134 CurrentAddrInfo
->PrefixLength
,
1135 &CurrentAddrInfo
->Address
1137 if (PrefixEntry
!= NULL
) {
1138 Ip6DestroyPrefixListEntry (IpSb
, PrefixEntry
, TRUE
, FALSE
);
1141 RemoveEntryList (&CurrentAddrInfo
->Link
);
1142 FreePool (CurrentAddrInfo
);
1146 if (DataItem
->Status
== EFI_NOT_READY
) {
1148 // If DAD is disabled on this interface, the configuration process is
1149 // actually synchronous, and the data item's status will be changed to
1150 // the final status before we reach here, just check it.
1152 Status
= EFI_NOT_READY
;
1154 Status
= EFI_SUCCESS
;
1158 // No update is taken, reset the status to success and return EFI_ABORTED.
1160 DataItem
->Status
= EFI_SUCCESS
;
1161 Status
= EFI_ABORTED
;
1168 The work function for EfiIp6ConfigSetData() to set the gateway addresses manually
1169 for the EFI IPv6 network stack that is running on the communication device that
1170 this EFI IPv6 Configuration Protocol manages. It is not configurable when the policy is
1171 Ip6ConfigPolicyAutomatic. The gateway addresses must be unicast IPv6 addresses.
1173 @param[in] Instance The pointer to the IP6 config instance data.
1174 @param[in] DataSize The size of the buffer pointed to by Data in bytes.
1175 @param[in] Data The data buffer to set. This points to an array of
1176 EFI_IPv6_ADDRESS instances.
1178 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
1179 @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set
1180 under the current policy.
1181 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1182 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to complete the operation.
1183 @retval EFI_ABORTED The manual gateway addresses to be set equal the
1184 current configuration.
1185 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1186 network stack was set.
1190 Ip6ConfigSetGateway (
1191 IN IP6_CONFIG_INSTANCE
*Instance
,
1198 EFI_IPv6_ADDRESS
*OldGateway
;
1199 EFI_IPv6_ADDRESS
*NewGateway
;
1200 UINTN OldGatewayCount
;
1201 UINTN NewGatewayCount
;
1202 IP6_CONFIG_DATA_ITEM
*Item
;
1206 IP6_DEFAULT_ROUTER
*DefaultRouter
;
1209 if ((DataSize
% sizeof (EFI_IPv6_ADDRESS
) != 0) || (DataSize
== 0)) {
1210 return EFI_BAD_BUFFER_SIZE
;
1213 if (Instance
->Policy
!= Ip6ConfigPolicyManual
) {
1214 return EFI_WRITE_PROTECTED
;
1217 NewGateway
= (EFI_IPv6_ADDRESS
*) Data
;
1218 NewGatewayCount
= DataSize
/ sizeof (EFI_IPv6_ADDRESS
);
1219 for (Index1
= 0; Index1
< NewGatewayCount
; Index1
++) {
1221 if (!NetIp6IsValidUnicast (NewGateway
+ Index1
)) {
1223 return EFI_INVALID_PARAMETER
;
1226 for (Index2
= Index1
+ 1; Index2
< NewGatewayCount
; Index2
++) {
1227 if (EFI_IP6_EQUAL (NewGateway
+ Index1
, NewGateway
+ Index2
)) {
1228 return EFI_INVALID_PARAMETER
;
1233 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
1234 Item
= &Instance
->DataItem
[Ip6ConfigDataTypeGateway
];
1235 OldGateway
= Item
->Data
.Gateway
;
1236 OldGatewayCount
= Item
->DataSize
/ sizeof (EFI_IPv6_ADDRESS
);
1240 if (NewGatewayCount
!= OldGatewayCount
) {
1241 Tmp
= AllocatePool (DataSize
);
1243 return EFI_OUT_OF_RESOURCES
;
1249 for (Index1
= 0; Index1
< OldGatewayCount
; Index1
++) {
1251 // Find the gateways that are no long in the new setting and remove them.
1253 for (Index2
= 0; Index2
< NewGatewayCount
; Index2
++) {
1254 if (EFI_IP6_EQUAL (OldGateway
+ Index1
, NewGateway
+ Index2
)) {
1260 if (Index2
== NewGatewayCount
) {
1262 // Remove this default router.
1264 DefaultRouter
= Ip6FindDefaultRouter (IpSb
, OldGateway
+ Index1
);
1265 if (DefaultRouter
!= NULL
) {
1266 Ip6DestroyDefaultRouter (IpSb
, DefaultRouter
);
1271 for (Index1
= 0; Index1
< NewGatewayCount
; Index1
++) {
1273 DefaultRouter
= Ip6FindDefaultRouter (IpSb
, NewGateway
+ Index1
);
1274 if (DefaultRouter
== NULL
) {
1275 Ip6CreateDefaultRouter (IpSb
, NewGateway
+ Index1
, IP6_INF_ROUTER_LIFETIME
);
1280 if (!OneRemoved
&& !OneAdded
) {
1281 Item
->Status
= EFI_SUCCESS
;
1286 if (Item
->Data
.Ptr
!= NULL
) {
1287 FreePool (Item
->Data
.Ptr
);
1289 Item
->Data
.Ptr
= Tmp
;
1292 CopyMem (Item
->Data
.Ptr
, Data
, DataSize
);
1293 Item
->DataSize
= DataSize
;
1294 Item
->Status
= EFI_SUCCESS
;
1300 The work function for EfiIp6ConfigSetData() to set the DNS server list for the
1301 EFI IPv6 network stack running on the communication device that this EFI IPv6
1302 Configuration Protocol manages. It is not configurable when the policy is
1303 Ip6ConfigPolicyAutomatic. The DNS server addresses must be unicast IPv6 addresses.
1305 @param[in] Instance The pointer to the IP6 config instance data.
1306 @param[in] DataSize The size of the buffer pointed to by Data in bytes.
1307 @param[in] Data The data buffer to set, points to an array of
1308 EFI_IPv6_ADDRESS instances.
1310 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
1311 @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set
1312 under the current policy.
1313 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1314 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.
1315 @retval EFI_ABORTED The DNS server addresses to be set equal the current
1317 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1318 network stack was set.
1322 Ip6ConfigSetDnsServer (
1323 IN IP6_CONFIG_INSTANCE
*Instance
,
1331 EFI_IPv6_ADDRESS
*OldDns
;
1332 EFI_IPv6_ADDRESS
*NewDns
;
1335 IP6_CONFIG_DATA_ITEM
*Item
;
1339 if ((DataSize
% sizeof (EFI_IPv6_ADDRESS
) != 0) || (DataSize
== 0)) {
1340 return EFI_BAD_BUFFER_SIZE
;
1343 if (Instance
->Policy
!= Ip6ConfigPolicyManual
) {
1344 return EFI_WRITE_PROTECTED
;
1347 Item
= &Instance
->DataItem
[Ip6ConfigDataTypeDnsServer
];
1348 NewDns
= (EFI_IPv6_ADDRESS
*) Data
;
1349 OldDns
= Item
->Data
.DnsServers
;
1350 NewDnsCount
= DataSize
/ sizeof (EFI_IPv6_ADDRESS
);
1351 OldDnsCount
= Item
->DataSize
/ sizeof (EFI_IPv6_ADDRESS
);
1354 if (NewDnsCount
!= OldDnsCount
) {
1355 Tmp
= AllocatePool (DataSize
);
1357 return EFI_OUT_OF_RESOURCES
;
1363 for (NewIndex
= 0; NewIndex
< NewDnsCount
; NewIndex
++) {
1365 if (!NetIp6IsValidUnicast (NewDns
+ NewIndex
)) {
1367 // The dns server address must be unicast.
1370 return EFI_INVALID_PARAMETER
;
1373 for (Index1
= NewIndex
+ 1; Index1
< NewDnsCount
; Index1
++) {
1374 if (EFI_IP6_EQUAL (NewDns
+ NewIndex
, NewDns
+ Index1
)) {
1376 return EFI_INVALID_PARAMETER
;
1382 // If any address in the new setting is not in the old settings, skip the
1383 // comparision below.
1388 for (OldIndex
= 0; OldIndex
< OldDnsCount
; OldIndex
++) {
1389 if (EFI_IP6_EQUAL (NewDns
+ NewIndex
, OldDns
+ OldIndex
)) {
1391 // If found break out.
1397 if (OldIndex
== OldDnsCount
) {
1402 if (!OneAdded
&& (DataSize
== Item
->DataSize
)) {
1404 // No new item is added and the size is the same.
1406 Item
->Status
= EFI_SUCCESS
;
1410 if (Item
->Data
.Ptr
!= NULL
) {
1411 FreePool (Item
->Data
.Ptr
);
1413 Item
->Data
.Ptr
= Tmp
;
1416 CopyMem (Item
->Data
.Ptr
, Data
, DataSize
);
1417 Item
->DataSize
= DataSize
;
1418 Item
->Status
= EFI_SUCCESS
;
1424 Generate the operational state of the interface this IP6 config instance manages
1425 and output in EFI_IP6_CONFIG_INTERFACE_INFO.
1427 @param[in] IpSb The pointer to the IP6 service binding instance.
1428 @param[out] IfInfo The pointer to the IP6 configuration interface information structure.
1432 Ip6ConfigInitIfInfo (
1433 IN IP6_SERVICE
*IpSb
,
1434 OUT EFI_IP6_CONFIG_INTERFACE_INFO
*IfInfo
1437 IfInfo
->Name
[0] = L
'e';
1438 IfInfo
->Name
[1] = L
't';
1439 IfInfo
->Name
[2] = L
'h';
1440 IfInfo
->Name
[3] = (CHAR16
) (L
'0' + IpSb
->Ip6ConfigInstance
.IfIndex
);
1441 IfInfo
->Name
[4] = 0;
1443 IfInfo
->IfType
= IpSb
->SnpMode
.IfType
;
1444 IfInfo
->HwAddressSize
= IpSb
->SnpMode
.HwAddressSize
;
1445 CopyMem (&IfInfo
->HwAddress
, &IpSb
->SnpMode
.CurrentAddress
, IfInfo
->HwAddressSize
);
1449 Parse DHCPv6 reply packet to get the DNS server list.
1450 It is the work function for Ip6ConfigOnDhcp6Reply and Ip6ConfigOnDhcp6Event.
1452 @param[in] Dhcp6 The pointer to the EFI_DHCP6_PROTOCOL instance.
1453 @param[in, out] Instance The pointer to the IP6 configuration instance data.
1454 @param[in] Reply The pointer to the DHCPv6 reply packet.
1456 @retval EFI_SUCCESS The DNS server address was retrieved from the reply packet.
1457 @retval EFI_NOT_READY The reply packet does not contain the DNS server option, or
1458 the DNS server address is not valid.
1462 Ip6ConfigParseDhcpReply (
1463 IN EFI_DHCP6_PROTOCOL
*Dhcp6
,
1464 IN OUT IP6_CONFIG_INSTANCE
*Instance
,
1465 IN EFI_DHCP6_PACKET
*Reply
1470 EFI_DHCP6_PACKET_OPTION
**OptList
;
1475 EFI_IPv6_ADDRESS
*DnsServer
;
1476 IP6_CONFIG_DATA_ITEM
*Item
;
1479 // A DHCPv6 reply packet is received as the response to our InfoRequest
1483 Status
= Dhcp6
->Parse (Dhcp6
, Reply
, &OptCount
, NULL
);
1484 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
1485 return EFI_NOT_READY
;
1488 OptList
= AllocatePool (OptCount
* sizeof (EFI_DHCP6_PACKET_OPTION
*));
1489 if (OptList
== NULL
) {
1490 return EFI_NOT_READY
;
1493 Status
= Dhcp6
->Parse (Dhcp6
, Reply
, &OptCount
, OptList
);
1494 if (EFI_ERROR (Status
)) {
1495 Status
= EFI_NOT_READY
;
1499 Status
= EFI_SUCCESS
;
1501 for (Index
= 0; Index
< OptCount
; Index
++) {
1503 // Go through all the options to check the ones we are interested in.
1504 // The OpCode and Length are in network byte-order and may not be naturally
1507 CopyMem (&OpCode
, &OptList
[Index
]->OpCode
, sizeof (OpCode
));
1508 OpCode
= NTOHS (OpCode
);
1510 if (OpCode
== DHCP6_OPT_DNS_SERVERS
) {
1511 CopyMem (&Length
, &OptList
[Index
]->OpLen
, sizeof (Length
));
1512 Length
= NTOHS (Length
);
1514 if ((Length
== 0) || ((Length
% sizeof (EFI_IPv6_ADDRESS
)) != 0)) {
1516 // The length should be a multiple of 16 bytes.
1518 Status
= EFI_NOT_READY
;
1523 // Validate the DnsServers: whether they are unicast addresses.
1525 DnsServer
= (EFI_IPv6_ADDRESS
*) OptList
[Index
]->Data
;
1526 for (Index2
= 0; Index2
< Length
/ sizeof (EFI_IPv6_ADDRESS
); Index2
++) {
1527 if (!NetIp6IsValidUnicast (DnsServer
)) {
1528 Status
= EFI_NOT_READY
;
1535 Item
= &Instance
->DataItem
[Ip6ConfigDataTypeDnsServer
];
1537 if (Item
->DataSize
!= Length
) {
1538 if (Item
->Data
.Ptr
!= NULL
) {
1539 FreePool (Item
->Data
.Ptr
);
1542 Item
->Data
.Ptr
= AllocatePool (Length
);
1543 ASSERT (Item
->Data
.Ptr
!= NULL
);
1546 CopyMem (Item
->Data
.Ptr
, OptList
[Index
]->Data
, Length
);
1547 Item
->DataSize
= Length
;
1548 Item
->Status
= EFI_SUCCESS
;
1551 // Signal the waiting events.
1553 NetMapIterate (&Item
->EventMap
, Ip6ConfigSignalEvent
, NULL
);
1566 The callback function for Ip6SetAddr. The prototype is defined
1567 as IP6_DAD_CALLBACK. It is called after Duplicate Address Detection is performed
1568 on the tentative address by DHCPv6 in Ip6ConfigOnDhcp6Event().
1570 @param[in] IsDadPassed If TRUE, Duplicate Address Detection passes.
1571 @param[in] TargetAddress The tentative IPv6 address to be checked.
1572 @param[in] Context Pointer to the IP6 configuration instance data.
1576 Ip6ConfigSetStatefulAddrCallback (
1577 IN BOOLEAN IsDadPassed
,
1578 IN EFI_IPv6_ADDRESS
*TargetAddress
,
1582 IP6_CONFIG_INSTANCE
*Instance
;
1584 Instance
= (IP6_CONFIG_INSTANCE
*) Context
;
1585 NET_CHECK_SIGNATURE (Instance
, IP6_CONFIG_INSTANCE_SIGNATURE
);
1588 // We should record the addresses that fail the DAD, and DECLINE them.
1592 // Decrease the count, no interests in those passed DAD.
1594 if (Instance
->FailedIaAddressCount
> 0 ) {
1595 Instance
->FailedIaAddressCount
--;
1601 IP6_COPY_ADDRESS (Instance
->DeclineAddress
+ Instance
->DeclineAddressCount
, TargetAddress
);
1602 Instance
->DeclineAddressCount
++;
1605 if (Instance
->FailedIaAddressCount
== Instance
->DeclineAddressCount
) {
1607 // The checking on all addresses are finished.
1609 if (Instance
->DeclineAddressCount
!= 0) {
1611 // Decline those duplicates.
1613 if (Instance
->Dhcp6
!= NULL
) {
1614 Instance
->Dhcp6
->Decline (
1616 Instance
->DeclineAddressCount
,
1617 Instance
->DeclineAddress
1622 if (Instance
->DeclineAddress
!= NULL
) {
1623 FreePool (Instance
->DeclineAddress
);
1625 Instance
->DeclineAddress
= NULL
;
1626 Instance
->DeclineAddressCount
= 0;
1631 The event handle routine when DHCPv6 process is finished or is updated.
1633 @param[in] Event Not used.
1634 @param[in] Context The pointer to the IP6 configuration instance data.
1639 Ip6ConfigOnDhcp6Event (
1644 IP6_CONFIG_INSTANCE
*Instance
;
1645 EFI_DHCP6_PROTOCOL
*Dhcp6
;
1647 EFI_DHCP6_MODE_DATA Dhcp6ModeData
;
1649 EFI_DHCP6_IA_ADDRESS
*IaAddr
;
1652 IP6_ADDRESS_INFO
*AddrInfo
;
1653 IP6_INTERFACE
*IpIf
;
1655 Instance
= (IP6_CONFIG_INSTANCE
*) Context
;
1657 if ((Instance
->Policy
!= Ip6ConfigPolicyAutomatic
) || Instance
->OtherInfoOnly
) {
1659 // IPv6 is not operating in the automatic policy now or
1660 // the DHCPv6 information request message exchange is aborted.
1666 // The stateful address autoconfiguration is done or updated.
1668 Dhcp6
= Instance
->Dhcp6
;
1670 Status
= Dhcp6
->GetModeData (Dhcp6
, &Dhcp6ModeData
, NULL
);
1671 if (EFI_ERROR (Status
)) {
1675 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
1676 IpIf
= IpSb
->DefaultInterface
;
1677 Ia
= Dhcp6ModeData
.Ia
;
1678 IaAddr
= Ia
->IaAddress
;
1680 if (Instance
->DeclineAddress
!= NULL
) {
1681 FreePool (Instance
->DeclineAddress
);
1684 Instance
->DeclineAddress
= (EFI_IPv6_ADDRESS
*) AllocatePool (Ia
->IaAddressCount
* sizeof (EFI_IPv6_ADDRESS
));
1685 if (Instance
->DeclineAddress
== NULL
) {
1689 Instance
->FailedIaAddressCount
= Ia
->IaAddressCount
;
1690 Instance
->DeclineAddressCount
= 0;
1692 for (Index
= 0; Index
< Ia
->IaAddressCount
; Index
++, IaAddr
++) {
1693 if (Ia
->IaAddress
[Index
].ValidLifetime
!= 0 && Ia
->State
== Dhcp6Bound
) {
1695 // Set this address, either it's a new address or with updated lifetimes.
1696 // An appropriate prefix length will be set.
1703 IaAddr
->ValidLifetime
,
1704 IaAddr
->PreferredLifetime
,
1705 Ip6ConfigSetStatefulAddrCallback
,
1710 // discard this address, artificially decrease the count as if this address
1713 if (Ip6IsOneOfSetAddress (IpSb
, &IaAddr
->IpAddress
, NULL
, &AddrInfo
)) {
1714 ASSERT (AddrInfo
!= NULL
);
1718 &IpIf
->AddressCount
,
1720 AddrInfo
->PrefixLength
1724 if (Instance
->FailedIaAddressCount
> 0) {
1725 Instance
->FailedIaAddressCount
--;
1731 // Parse the Reply packet to get the options we need.
1733 if (Dhcp6ModeData
.Ia
->ReplyPacket
!= NULL
) {
1734 Ip6ConfigParseDhcpReply (Dhcp6
, Instance
, Dhcp6ModeData
.Ia
->ReplyPacket
);
1739 FreePool (Dhcp6ModeData
.ClientId
);
1740 FreePool (Dhcp6ModeData
.Ia
);
1744 The event process routine when the DHCPv6 server is answered with a reply packet
1745 for an information request.
1747 @param[in] This Points to the EFI_DHCP6_PROTOCOL.
1748 @param[in] Context The pointer to the IP6 configuration instance data.
1749 @param[in] Packet The DHCPv6 reply packet.
1751 @retval EFI_SUCCESS The DNS server address was retrieved from the reply packet.
1752 @retval EFI_NOT_READY The reply packet does not contain the DNS server option, or
1753 the DNS server address is not valid.
1758 Ip6ConfigOnDhcp6Reply (
1759 IN EFI_DHCP6_PROTOCOL
*This
,
1761 IN EFI_DHCP6_PACKET
*Packet
1764 return Ip6ConfigParseDhcpReply (This
, (IP6_CONFIG_INSTANCE
*) Context
, Packet
);
1768 The event process routine when the DHCPv6 service binding protocol is installed
1771 @param[in] Event Not used.
1772 @param[in] Context The pointer to the IP6 config instance data.
1777 Ip6ConfigOnDhcp6SbInstalled (
1782 IP6_CONFIG_INSTANCE
*Instance
;
1784 Instance
= (IP6_CONFIG_INSTANCE
*) Context
;
1786 if ((Instance
->Dhcp6Handle
!= NULL
) || (Instance
->Policy
!= Ip6ConfigPolicyAutomatic
)) {
1788 // The DHCP6 child is already created or the policy is no longer AUTOMATIC.
1793 Ip6ConfigStartStatefulAutoConfig (Instance
, Instance
->OtherInfoOnly
);
1797 Set the configuration for the EFI IPv6 network stack running on the communication
1798 device this EFI IPv6 Configuration Protocol instance manages.
1800 This function is used to set the configuration data of type DataType for the EFI
1801 IPv6 network stack that is running on the communication device that this EFI IPv6
1802 Configuration Protocol instance manages.
1804 DataSize is used to calculate the count of structure instances in the Data for
1805 a DataType in which multiple structure instances are allowed.
1807 This function is always non-blocking. When setting some type of configuration data,
1808 an asynchronous process is invoked to check the correctness of the data, such as
1809 performing Duplicate Address Detection on the manually set local IPv6 addresses.
1810 EFI_NOT_READY is returned immediately to indicate that such an asynchronous process
1811 is invoked, and the process is not finished yet. The caller wanting to get the result
1812 of the asynchronous process is required to call RegisterDataNotify() to register an
1813 event on the specified configuration data. Once the event is signaled, the caller
1814 can call GetData() to obtain the configuration data and know the result.
1815 For other types of configuration data that do not require an asynchronous configuration
1816 process, the result of the operation is immediately returned.
1818 @param[in] This The pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
1819 @param[in] DataType The type of data to set.
1820 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
1821 @param[in] Data The data buffer to set. The type of the data buffer is
1822 associated with the DataType.
1824 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1825 network stack was set successfully.
1826 @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
1829 - One or more fields in Data do not match the requirement of the
1830 data type indicated by DataType.
1831 @retval EFI_WRITE_PROTECTED The specified configuration data is read-only or the specified
1832 configuration data cannot be set under the current policy.
1833 @retval EFI_ACCESS_DENIED Another set operation on the specified configuration
1834 data is already in process.
1835 @retval EFI_NOT_READY An asynchronous process was invoked to set the specified
1836 configuration data, and the process is not finished yet.
1837 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type
1838 indicated by DataType.
1839 @retval EFI_UNSUPPORTED This DataType is not supported.
1840 @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated.
1841 @retval EFI_DEVICE_ERROR An unexpected system error or network error occurred.
1846 EfiIp6ConfigSetData (
1847 IN EFI_IP6_CONFIG_PROTOCOL
*This
,
1848 IN EFI_IP6_CONFIG_DATA_TYPE DataType
,
1855 IP6_CONFIG_INSTANCE
*Instance
;
1858 if ((This
== NULL
) || (Data
== NULL
)) {
1859 return EFI_INVALID_PARAMETER
;
1862 if (DataType
>= Ip6ConfigDataTypeMaximum
) {
1863 return EFI_UNSUPPORTED
;
1866 Instance
= IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This
);
1867 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
1868 NET_CHECK_SIGNATURE (IpSb
, IP6_SERVICE_SIGNATURE
);
1870 if (IpSb
->LinkLocalDadFail
) {
1871 return EFI_DEVICE_ERROR
;
1874 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1876 Status
= Instance
->DataItem
[DataType
].Status
;
1877 if (Status
!= EFI_NOT_READY
) {
1879 if (Instance
->DataItem
[DataType
].SetData
== NULL
) {
1881 // This type of data is readonly.
1883 Status
= EFI_WRITE_PROTECTED
;
1886 Status
= Instance
->DataItem
[DataType
].SetData (Instance
, DataSize
, Data
);
1887 if (!EFI_ERROR (Status
)) {
1889 // Fire up the events registered with this type of data.
1891 NetMapIterate (&Instance
->DataItem
[DataType
].EventMap
, Ip6ConfigSignalEvent
, NULL
);
1892 Ip6ConfigWriteConfigData (IpSb
->MacString
, Instance
);
1893 } else if (Status
== EFI_ABORTED
) {
1895 // The SetData is aborted because the data to set is the same with
1896 // the one maintained.
1898 Status
= EFI_SUCCESS
;
1899 NetMapIterate (&Instance
->DataItem
[DataType
].EventMap
, Ip6ConfigSignalEvent
, NULL
);
1904 // Another asynchornous process is on the way.
1906 Status
= EFI_ACCESS_DENIED
;
1909 gBS
->RestoreTPL (OldTpl
);
1915 Get the configuration data for the EFI IPv6 network stack running on the communication
1916 device that this EFI IPv6 Configuration Protocol instance manages.
1918 This function returns the configuration data of type DataType for the EFI IPv6 network
1919 stack running on the communication device that this EFI IPv6 Configuration Protocol instance
1922 The caller is responsible for allocating the buffer used to return the specified
1923 configuration data. The required size will be returned to the caller if the size of
1924 the buffer is too small.
1926 EFI_NOT_READY is returned if the specified configuration data is not ready due to an
1927 asynchronous configuration process already in progress. The caller can call RegisterDataNotify()
1928 to register an event on the specified configuration data. Once the asynchronous configuration
1929 process is finished, the event will be signaled, and a subsequent GetData() call will return
1930 the specified configuration data.
1932 @param[in] This Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
1933 @param[in] DataType The type of data to get.
1934 @param[in, out] DataSize On input, in bytes, the size of Data. On output, in bytes, the
1935 size of buffer required to store the specified configuration data.
1936 @param[in] Data The data buffer in which the configuration data is returned. The
1937 type of the data buffer is associated with the DataType.
1938 This is an optional parameter that may be NULL.
1940 @retval EFI_SUCCESS The specified configuration data was obtained successfully.
1941 @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
1944 - Data is NULL if *DataSize is not zero.
1945 @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified configuration data,
1946 and the required size is returned in DataSize.
1947 @retval EFI_NOT_READY The specified configuration data is not ready due to an
1948 asynchronous configuration process already in progress.
1949 @retval EFI_NOT_FOUND The specified configuration data is not found.
1954 EfiIp6ConfigGetData (
1955 IN EFI_IP6_CONFIG_PROTOCOL
*This
,
1956 IN EFI_IP6_CONFIG_DATA_TYPE DataType
,
1957 IN OUT UINTN
*DataSize
,
1958 IN VOID
*Data OPTIONAL
1963 IP6_CONFIG_INSTANCE
*Instance
;
1964 IP6_CONFIG_DATA_ITEM
*DataItem
;
1966 if ((This
== NULL
) || (DataSize
== NULL
) || ((*DataSize
!= 0) && (Data
== NULL
))) {
1967 return EFI_INVALID_PARAMETER
;
1970 if (DataType
>= Ip6ConfigDataTypeMaximum
) {
1971 return EFI_NOT_FOUND
;
1974 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1976 Instance
= IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This
);
1977 DataItem
= &Instance
->DataItem
[DataType
];
1979 Status
= Instance
->DataItem
[DataType
].Status
;
1980 if (!EFI_ERROR (Status
)) {
1982 if (DataItem
->GetData
!= NULL
) {
1984 Status
= DataItem
->GetData (Instance
, DataSize
, Data
);
1985 } else if (*DataSize
< Instance
->DataItem
[DataType
].DataSize
) {
1987 // Update the buffer length.
1989 *DataSize
= Instance
->DataItem
[DataType
].DataSize
;
1990 Status
= EFI_BUFFER_TOO_SMALL
;
1993 *DataSize
= Instance
->DataItem
[DataType
].DataSize
;
1994 CopyMem (Data
, Instance
->DataItem
[DataType
].Data
.Ptr
, *DataSize
);
1998 gBS
->RestoreTPL (OldTpl
);
2004 Register an event that is signaled whenever a configuration process on the specified
2005 configuration data is done.
2007 This function registers an event that is to be signaled whenever a configuration
2008 process on the specified configuration data is performed. An event can be registered
2009 for a different DataType simultaneously. The caller is responsible for determining
2010 which type of configuration data causes the signaling of the event in such an event.
2012 @param[in] This Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
2013 @param[in] DataType The type of data to unregister the event for.
2014 @param[in] Event The event to register.
2016 @retval EFI_SUCCESS The notification event for the specified configuration data is
2018 @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
2019 @retval EFI_UNSUPPORTED The configuration data type specified by DataType is not
2021 @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated.
2022 @retval EFI_ACCESS_DENIED The Event is already registered for the DataType.
2027 EfiIp6ConfigRegisterDataNotify (
2028 IN EFI_IP6_CONFIG_PROTOCOL
*This
,
2029 IN EFI_IP6_CONFIG_DATA_TYPE DataType
,
2035 IP6_CONFIG_INSTANCE
*Instance
;
2039 if ((This
== NULL
) || (Event
== NULL
)) {
2040 return EFI_INVALID_PARAMETER
;
2043 if (DataType
>= Ip6ConfigDataTypeMaximum
) {
2044 return EFI_UNSUPPORTED
;
2047 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
2049 Instance
= IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This
);
2050 EventMap
= &Instance
->DataItem
[DataType
].EventMap
;
2053 // Check whether this event is already registered for this DataType.
2055 Item
= NetMapFindKey (EventMap
, Event
);
2058 Status
= NetMapInsertTail (EventMap
, Event
, NULL
);
2060 if (EFI_ERROR (Status
)) {
2062 Status
= EFI_OUT_OF_RESOURCES
;
2067 Status
= EFI_ACCESS_DENIED
;
2070 gBS
->RestoreTPL (OldTpl
);
2076 Remove a previously registered event for the specified configuration data.
2078 @param This The pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
2079 @param DataType The type of data to remove from the previously
2081 @param Event The event to be unregistered.
2083 @retval EFI_SUCCESS The event registered for the specified
2084 configuration data was removed.
2085 @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
2086 @retval EFI_NOT_FOUND The Event has not been registered for the
2092 EfiIp6ConfigUnregisterDataNotify (
2093 IN EFI_IP6_CONFIG_PROTOCOL
*This
,
2094 IN EFI_IP6_CONFIG_DATA_TYPE DataType
,
2100 IP6_CONFIG_INSTANCE
*Instance
;
2103 if ((This
== NULL
) || (Event
== NULL
)) {
2104 return EFI_INVALID_PARAMETER
;
2107 if (DataType
>= Ip6ConfigDataTypeMaximum
) {
2108 return EFI_NOT_FOUND
;
2111 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
2113 Instance
= IP6_CONFIG_INSTANCE_FROM_PROTOCOL (This
);
2115 Item
= NetMapFindKey (&Instance
->DataItem
[DataType
].EventMap
, Event
);
2118 NetMapRemoveItem (&Instance
->DataItem
[DataType
].EventMap
, Item
, NULL
);
2119 Status
= EFI_SUCCESS
;
2122 Status
= EFI_NOT_FOUND
;
2125 gBS
->RestoreTPL (OldTpl
);
2131 Initialize an IP6_CONFIG_INSTANCE.
2133 @param[out] Instance The buffer of IP6_CONFIG_INSTANCE to be initialized.
2135 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.
2136 @retval EFI_SUCCESS The IP6_CONFIG_INSTANCE initialized successfully.
2140 Ip6ConfigInitInstance (
2141 OUT IP6_CONFIG_INSTANCE
*Instance
2145 IP6_CONFIG_INSTANCE
*TmpInstance
;
2150 IP6_CONFIG_DATA_ITEM
*DataItem
;
2152 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
2154 Instance
->Signature
= IP6_CONFIG_INSTANCE_SIGNATURE
;
2157 // Determine the index of this interface.
2160 NET_LIST_FOR_EACH (Entry
, &mIp6ConfigInstanceList
) {
2161 TmpInstance
= NET_LIST_USER_STRUCT_S (Entry
, IP6_CONFIG_INSTANCE
, Link
, IP6_CONFIG_INSTANCE_SIGNATURE
);
2163 if (TmpInstance
->IfIndex
> IfIndex
) {
2165 // There is a sequence hole because some interface is down.
2173 Instance
->IfIndex
= IfIndex
;
2174 NetListInsertBefore (Entry
, &Instance
->Link
);
2176 for (Index
= 0; Index
< Ip6ConfigDataTypeMaximum
; Index
++) {
2178 // Initialize the event map for each data item.
2180 NetMapInit (&Instance
->DataItem
[Index
].EventMap
);
2184 // Initialize the NET_MAPs used for DAD on manually configured source addresses.
2186 NetMapInit (&Instance
->DadFailedMap
);
2187 NetMapInit (&Instance
->DadPassedMap
);
2190 // Initialize each data type: associate storage and set data size for the
2191 // fixed size data types, hook the SetData function, set the data attribute.
2193 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeInterfaceInfo
];
2194 DataItem
->GetData
= Ip6ConfigGetIfInfo
;
2195 DataItem
->Data
.Ptr
= &Instance
->InterfaceInfo
;
2196 DataItem
->DataSize
= sizeof (Instance
->InterfaceInfo
);
2197 SET_DATA_ATTRIB (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
| DATA_ATTRIB_VOLATILE
);
2198 Ip6ConfigInitIfInfo (IpSb
, &Instance
->InterfaceInfo
);
2200 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeAltInterfaceId
];
2201 DataItem
->SetData
= Ip6ConfigSetAltIfId
;
2202 DataItem
->Data
.Ptr
= &Instance
->AltIfId
;
2203 DataItem
->DataSize
= sizeof (Instance
->AltIfId
);
2204 DataItem
->Status
= EFI_NOT_FOUND
;
2205 SET_DATA_ATTRIB (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
);
2207 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypePolicy
];
2208 DataItem
->SetData
= Ip6ConfigSetPolicy
;
2209 DataItem
->Data
.Ptr
= &Instance
->Policy
;
2210 DataItem
->DataSize
= sizeof (Instance
->Policy
);
2211 Instance
->Policy
= Ip6ConfigPolicyManual
;
2212 SET_DATA_ATTRIB (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
);
2214 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeDupAddrDetectTransmits
];
2215 DataItem
->SetData
= Ip6ConfigSetDadXmits
;
2216 DataItem
->Data
.Ptr
= &Instance
->DadXmits
;
2217 DataItem
->DataSize
= sizeof (Instance
->DadXmits
);
2218 Instance
->DadXmits
.DupAddrDetectTransmits
= IP6_CONFIG_DEFAULT_DAD_XMITS
;
2219 SET_DATA_ATTRIB (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
);
2221 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeManualAddress
];
2222 DataItem
->SetData
= Ip6ConfigSetMaunualAddress
;
2223 DataItem
->Status
= EFI_NOT_FOUND
;
2225 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeGateway
];
2226 DataItem
->SetData
= Ip6ConfigSetGateway
;
2227 DataItem
->Status
= EFI_NOT_FOUND
;
2229 DataItem
= &Instance
->DataItem
[Ip6ConfigDataTypeDnsServer
];
2230 DataItem
->SetData
= Ip6ConfigSetDnsServer
;
2231 DataItem
->Status
= EFI_NOT_FOUND
;
2234 // Create the event used for DHCP.
2236 Status
= gBS
->CreateEvent (
2239 Ip6ConfigOnDhcp6Event
,
2241 &Instance
->Dhcp6Event
2243 ASSERT_EFI_ERROR (Status
);
2245 Instance
->Configured
= TRUE
;
2248 // Try to read the config data from NV variable.
2250 Status
= Ip6ConfigReadConfigData (IpSb
->MacString
, Instance
);
2251 if (Status
== EFI_NOT_FOUND
) {
2253 // The NV variable is not set, so generate a random IAID, and write down the
2254 // fresh new configuration as the NV variable now.
2256 Instance
->IaId
= NET_RANDOM (NetRandomInitSeed ());
2258 for (Index
= 0; Index
< IpSb
->SnpMode
.HwAddressSize
; Index
++) {
2259 Instance
->IaId
|= (IpSb
->SnpMode
.CurrentAddress
.Addr
[Index
] << ((Index
<< 3) & 31));
2262 Ip6ConfigWriteConfigData (IpSb
->MacString
, Instance
);
2263 } else if (EFI_ERROR (Status
)) {
2267 Instance
->Ip6Config
.SetData
= EfiIp6ConfigSetData
;
2268 Instance
->Ip6Config
.GetData
= EfiIp6ConfigGetData
;
2269 Instance
->Ip6Config
.RegisterDataNotify
= EfiIp6ConfigRegisterDataNotify
;
2270 Instance
->Ip6Config
.UnregisterDataNotify
= EfiIp6ConfigUnregisterDataNotify
;
2274 // Publish the IP6 configuration form
2276 return Ip6ConfigFormInit (Instance
);
2280 Release an IP6_CONFIG_INSTANCE.
2282 @param[in, out] Instance The buffer of IP6_CONFIG_INSTANCE to be freed.
2286 Ip6ConfigCleanInstance (
2287 IN OUT IP6_CONFIG_INSTANCE
*Instance
2291 IP6_CONFIG_DATA_ITEM
*DataItem
;
2293 if (Instance
->DeclineAddress
!= NULL
) {
2294 FreePool (Instance
->DeclineAddress
);
2297 if (!Instance
->Configured
) {
2301 if (Instance
->Dhcp6Handle
!= NULL
) {
2303 Ip6ConfigDestroyDhcp6 (Instance
);
2309 if (Instance
->Dhcp6Event
!= NULL
) {
2310 gBS
->CloseEvent (Instance
->Dhcp6Event
);
2313 NetMapClean (&Instance
->DadPassedMap
);
2314 NetMapClean (&Instance
->DadFailedMap
);
2316 for (Index
= 0; Index
< Ip6ConfigDataTypeMaximum
; Index
++) {
2318 DataItem
= &Instance
->DataItem
[Index
];
2320 if (!DATA_ATTRIB_SET (DataItem
->Attribute
, DATA_ATTRIB_SIZE_FIXED
)) {
2321 if (DataItem
->Data
.Ptr
!= NULL
) {
2322 FreePool (DataItem
->Data
.Ptr
);
2324 DataItem
->Data
.Ptr
= NULL
;
2325 DataItem
->DataSize
= 0;
2328 NetMapClean (&Instance
->DataItem
[Index
].EventMap
);
2331 Ip6ConfigFormUnload (Instance
);
2333 RemoveEntryList (&Instance
->Link
);
2337 Destroy the Dhcp6 child in IP6_CONFIG_INSTANCE and release the resources.
2339 @param[in, out] Instance The buffer of IP6_CONFIG_INSTANCE to be freed.
2341 @retval EFI_SUCCESS The child was successfully destroyed.
2342 @retval Others Failed to destroy the child.
2346 Ip6ConfigDestroyDhcp6 (
2347 IN OUT IP6_CONFIG_INSTANCE
*Instance
2352 EFI_DHCP6_PROTOCOL
*Dhcp6
;
2354 Dhcp6
= Instance
->Dhcp6
;
2355 ASSERT (Dhcp6
!= NULL
);
2357 Dhcp6
->Stop (Dhcp6
);
2358 Dhcp6
->Configure (Dhcp6
, NULL
);
2359 Instance
->Dhcp6
= NULL
;
2361 IpSb
= IP6_SERVICE_FROM_IP6_CONFIG_INSTANCE (Instance
);
2364 // Close DHCPv6 protocol and destroy the child.
2366 Status
= gBS
->CloseProtocol (
2367 Instance
->Dhcp6Handle
,
2368 &gEfiDhcp6ProtocolGuid
,
2372 if (EFI_ERROR (Status
)) {
2376 Status
= NetLibDestroyServiceChild (
2379 &gEfiDhcp6ServiceBindingProtocolGuid
,
2380 Instance
->Dhcp6Handle
2383 Instance
->Dhcp6Handle
= NULL
;