VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Ip4Dxe/Ip4Config2Impl.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 62.9 KB
Line 
1/** @file
2 The implementation of EFI IPv4 Configuration II Protocol.
3
4 Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
6
7 SPDX-License-Identifier: BSD-2-Clause-Patent
8
9**/
10
11#include "Ip4Impl.h"
12
13LIST_ENTRY mIp4Config2InstanceList = { &mIp4Config2InstanceList, &mIp4Config2InstanceList };
14
15/**
16 The event process routine when the DHCPv4 service binding protocol is installed
17 in the system.
18
19 @param[in] Event Not used.
20 @param[in] Context Pointer to the IP4 config2 instance data.
21
22**/
23VOID
24EFIAPI
25Ip4Config2OnDhcp4SbInstalled (
26 IN EFI_EVENT Event,
27 IN VOID *Context
28 );
29
30/**
31 Destroy the Dhcp4 child in IP4_CONFIG2_INSTANCE and release the resources.
32
33 @param[in, out] Instance The buffer of IP4 config2 instance to be freed.
34
35 @retval EFI_SUCCESS The child was successfully destroyed.
36 @retval Others Failed to destroy the child.
37
38**/
39EFI_STATUS
40Ip4Config2DestroyDhcp4 (
41 IN OUT IP4_CONFIG2_INSTANCE *Instance
42 )
43{
44 IP4_SERVICE *IpSb;
45 EFI_STATUS Status;
46 EFI_DHCP4_PROTOCOL *Dhcp4;
47
48 Dhcp4 = Instance->Dhcp4;
49 ASSERT (Dhcp4 != NULL);
50
51 Dhcp4->Stop (Dhcp4);
52 Dhcp4->Configure (Dhcp4, NULL);
53 Instance->Dhcp4 = NULL;
54
55 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
56
57 //
58 // Close DHCPv4 protocol and destroy the child.
59 //
60 Status = gBS->CloseProtocol (
61 Instance->Dhcp4Handle,
62 &gEfiDhcp4ProtocolGuid,
63 IpSb->Image,
64 IpSb->Controller
65 );
66 if (EFI_ERROR (Status)) {
67 return Status;
68 }
69
70 Status = NetLibDestroyServiceChild (
71 IpSb->Controller,
72 IpSb->Image,
73 &gEfiDhcp4ServiceBindingProtocolGuid,
74 Instance->Dhcp4Handle
75 );
76
77 Instance->Dhcp4Handle = NULL;
78
79 return Status;
80}
81
82/**
83 Update the current policy to NewPolicy. During the transition
84 period, the default router list
85 and address list in all interfaces will be released.
86
87 @param[in] IpSb The IP4 service binding instance.
88 @param[in] NewPolicy The new policy to be updated to.
89
90**/
91VOID
92Ip4Config2OnPolicyChanged (
93 IN IP4_SERVICE *IpSb,
94 IN EFI_IP4_CONFIG2_POLICY NewPolicy
95 )
96{
97 IP4_INTERFACE *IpIf;
98 IP4_ROUTE_TABLE *RouteTable;
99
100 //
101 // Currently there are only two policies: static and dhcp. Regardless of
102 // what transition is going on, i.e., static -> dhcp and dhcp ->
103 // static, we have to free default router table and all addresses.
104 //
105
106 if (IpSb->DefaultInterface != NULL) {
107 if (IpSb->DefaultRouteTable != NULL) {
108 Ip4FreeRouteTable (IpSb->DefaultRouteTable);
109 IpSb->DefaultRouteTable = NULL;
110 }
111
112 Ip4CancelReceive (IpSb->DefaultInterface);
113
114 Ip4FreeInterface (IpSb->DefaultInterface, NULL);
115 IpSb->DefaultInterface = NULL;
116 }
117
118 Ip4CleanAssembleTable (&IpSb->Assemble);
119
120 //
121 // Create new default interface and route table.
122 //
123 IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
124 if (IpIf == NULL) {
125 return;
126 }
127
128 RouteTable = Ip4CreateRouteTable ();
129 if (RouteTable == NULL) {
130 Ip4FreeInterface (IpIf, NULL);
131 return;
132 }
133
134 IpSb->DefaultInterface = IpIf;
135 InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
136 IpSb->DefaultRouteTable = RouteTable;
137 Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
138
139 if ((IpSb->State == IP4_SERVICE_CONFIGED) || (IpSb->State == IP4_SERVICE_STARTED)) {
140 IpSb->State = IP4_SERVICE_UNSTARTED;
141 }
142
143 //
144 // Start the dhcp configuration.
145 //
146 if (NewPolicy == Ip4Config2PolicyDhcp) {
147 Ip4StartAutoConfig (&IpSb->Ip4Config2Instance);
148 }
149}
150
151/**
152 Signal the registered event. It is the callback routine for NetMapIterate.
153
154 @param[in] Map Points to the list of registered event.
155 @param[in] Item The registered event.
156 @param[in] Arg Not used.
157
158 @retval EFI_SUCCESS The event was signaled successfully.
159**/
160EFI_STATUS
161EFIAPI
162Ip4Config2SignalEvent (
163 IN NET_MAP *Map,
164 IN NET_MAP_ITEM *Item,
165 IN VOID *Arg
166 )
167{
168 gBS->SignalEvent ((EFI_EVENT)Item->Key);
169
170 return EFI_SUCCESS;
171}
172
173/**
174 Read the configuration data from variable storage according to the VarName and
175 gEfiIp4Config2ProtocolGuid. It checks the integrity of variable data. If the
176 data is corrupted, it clears the variable data to ZERO. Otherwise, it outputs the
177 configuration data to IP4_CONFIG2_INSTANCE.
178
179 @param[in] VarName The pointer to the variable name
180 @param[in, out] Instance The pointer to the IP4 config2 instance data.
181
182 @retval EFI_NOT_FOUND The variable can not be found or already corrupted.
183 @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation.
184 @retval EFI_SUCCESS The configuration data was retrieved successfully.
185
186**/
187EFI_STATUS
188Ip4Config2ReadConfigData (
189 IN CHAR16 *VarName,
190 IN OUT IP4_CONFIG2_INSTANCE *Instance
191 )
192{
193 EFI_STATUS Status;
194 UINTN VarSize;
195 IP4_CONFIG2_VARIABLE *Variable;
196 IP4_CONFIG2_DATA_ITEM *DataItem;
197 UINTN Index;
198 IP4_CONFIG2_DATA_RECORD DataRecord;
199 CHAR8 *Data;
200
201 //
202 // Try to read the configuration variable.
203 //
204 VarSize = 0;
205 Status = gRT->GetVariable (
206 VarName,
207 &gEfiIp4Config2ProtocolGuid,
208 NULL,
209 &VarSize,
210 NULL
211 );
212
213 if (Status == EFI_BUFFER_TOO_SMALL) {
214 //
215 // Allocate buffer and read the config variable.
216 //
217 Variable = AllocatePool (VarSize);
218 if (Variable == NULL) {
219 return EFI_OUT_OF_RESOURCES;
220 }
221
222 Status = gRT->GetVariable (
223 VarName,
224 &gEfiIp4Config2ProtocolGuid,
225 NULL,
226 &VarSize,
227 Variable
228 );
229 if (EFI_ERROR (Status) || ((UINT16)(~NetblockChecksum ((UINT8 *)Variable, (UINT32)VarSize)) != 0)) {
230 //
231 // GetVariable still error or the variable is corrupted.
232 // Fall back to the default value.
233 //
234 FreePool (Variable);
235
236 //
237 // Remove the problematic variable and return EFI_NOT_FOUND, a new
238 // variable will be set again.
239 //
240 gRT->SetVariable (
241 VarName,
242 &gEfiIp4Config2ProtocolGuid,
243 IP4_CONFIG2_VARIABLE_ATTRIBUTE,
244 0,
245 NULL
246 );
247
248 return EFI_NOT_FOUND;
249 }
250
251 for (Index = 0; Index < Variable->DataRecordCount; Index++) {
252 CopyMem (&DataRecord, &Variable->DataRecord[Index], sizeof (DataRecord));
253
254 DataItem = &Instance->DataItem[DataRecord.DataType];
255 if (DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED) &&
256 (DataItem->DataSize != DataRecord.DataSize)
257 )
258 {
259 //
260 // Perhaps a corrupted data record...
261 //
262 continue;
263 }
264
265 if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
266 //
267 // This data item has variable length data.
268 //
269 DataItem->Data.Ptr = AllocatePool (DataRecord.DataSize);
270 if (DataItem->Data.Ptr == NULL) {
271 //
272 // no memory resource
273 //
274 continue;
275 }
276 }
277
278 Data = (CHAR8 *)Variable + DataRecord.Offset;
279 CopyMem (DataItem->Data.Ptr, Data, DataRecord.DataSize);
280
281 DataItem->DataSize = DataRecord.DataSize;
282 DataItem->Status = EFI_SUCCESS;
283 }
284
285 FreePool (Variable);
286 return EFI_SUCCESS;
287 }
288
289 return Status;
290}
291
292/**
293 Write the configuration data from IP4_CONFIG2_INSTANCE to variable storage.
294
295 @param[in] VarName The pointer to the variable name.
296 @param[in] Instance The pointer to the IP4 config2 instance data.
297
298 @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation.
299 @retval EFI_SUCCESS The configuration data is written successfully.
300
301**/
302EFI_STATUS
303Ip4Config2WriteConfigData (
304 IN CHAR16 *VarName,
305 IN IP4_CONFIG2_INSTANCE *Instance
306 )
307{
308 UINTN Index;
309 UINTN VarSize;
310 IP4_CONFIG2_DATA_ITEM *DataItem;
311 IP4_CONFIG2_VARIABLE *Variable;
312 IP4_CONFIG2_DATA_RECORD *DataRecord;
313 CHAR8 *Heap;
314 EFI_STATUS Status;
315
316 VarSize = sizeof (IP4_CONFIG2_VARIABLE) - sizeof (IP4_CONFIG2_DATA_RECORD);
317
318 for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
319 DataItem = &Instance->DataItem[Index];
320 if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
321 VarSize += sizeof (IP4_CONFIG2_DATA_RECORD) + DataItem->DataSize;
322 }
323 }
324
325 Variable = AllocatePool (VarSize);
326 if (Variable == NULL) {
327 return EFI_OUT_OF_RESOURCES;
328 }
329
330 Heap = (CHAR8 *)Variable + VarSize;
331 Variable->DataRecordCount = 0;
332
333 for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
334 DataItem = &Instance->DataItem[Index];
335 if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_VOLATILE) && !EFI_ERROR (DataItem->Status)) {
336 Heap -= DataItem->DataSize;
337 CopyMem (Heap, DataItem->Data.Ptr, DataItem->DataSize);
338
339 DataRecord = &Variable->DataRecord[Variable->DataRecordCount];
340 DataRecord->DataType = (EFI_IP4_CONFIG2_DATA_TYPE)Index;
341 DataRecord->DataSize = (UINT32)DataItem->DataSize;
342 DataRecord->Offset = (UINT16)(Heap - (CHAR8 *)Variable);
343
344 Variable->DataRecordCount++;
345 }
346 }
347
348 Variable->Checksum = 0;
349 Variable->Checksum = (UINT16) ~NetblockChecksum ((UINT8 *)Variable, (UINT32)VarSize);
350
351 Status = gRT->SetVariable (
352 VarName,
353 &gEfiIp4Config2ProtocolGuid,
354 IP4_CONFIG2_VARIABLE_ATTRIBUTE,
355 VarSize,
356 Variable
357 );
358
359 FreePool (Variable);
360
361 return Status;
362}
363
364/**
365 Build a EFI_IP4_ROUTE_TABLE to be returned to the caller of GetModeData.
366 The EFI_IP4_ROUTE_TABLE is clumsy to use in the internal operation of the
367 IP4 driver.
368
369 @param[in] IpSb The IP4 service binding instance.
370 @param[out] Table The built IP4 route table.
371
372 @retval EFI_SUCCESS The route table is successfully build
373 @retval EFI_NOT_FOUND Failed to allocate the memory for the route table.
374
375**/
376EFI_STATUS
377Ip4Config2BuildDefaultRouteTable (
378 IN IP4_SERVICE *IpSb,
379 OUT EFI_IP4_ROUTE_TABLE *Table
380 )
381{
382 LIST_ENTRY *Entry;
383 IP4_ROUTE_ENTRY *RtEntry;
384 UINT32 Count;
385 INT32 Index;
386
387 if (IpSb->DefaultRouteTable == NULL) {
388 return EFI_NOT_FOUND;
389 }
390
391 Count = IpSb->DefaultRouteTable->TotalNum;
392
393 if (Count == 0) {
394 return EFI_NOT_FOUND;
395 }
396
397 //
398 // Copy the route entry to EFI route table. Keep the order of
399 // route entry copied from most specific to default route. That
400 // is, interlevel the route entry from the instance's route area
401 // and those from the default route table's route area.
402 //
403 Count = 0;
404
405 for (Index = IP4_MASK_MAX; Index >= 0; Index--) {
406 NET_LIST_FOR_EACH (Entry, &(IpSb->DefaultRouteTable->RouteArea[Index])) {
407 RtEntry = NET_LIST_USER_STRUCT (Entry, IP4_ROUTE_ENTRY, Link);
408
409 EFI_IP4 (Table[Count].SubnetAddress) = HTONL (RtEntry->Dest & RtEntry->Netmask);
410 EFI_IP4 (Table[Count].SubnetMask) = HTONL (RtEntry->Netmask);
411 EFI_IP4 (Table[Count].GatewayAddress) = HTONL (RtEntry->NextHop);
412
413 Count++;
414 }
415 }
416
417 return EFI_SUCCESS;
418}
419
420/**
421 The event process routine when the DHCPv4 service binding protocol is installed
422 in the system.
423
424 @param[in] Event Not used.
425 @param[in] Context The pointer to the IP4 config2 instance data.
426
427**/
428VOID
429EFIAPI
430Ip4Config2OnDhcp4SbInstalled (
431 IN EFI_EVENT Event,
432 IN VOID *Context
433 )
434{
435 IP4_CONFIG2_INSTANCE *Instance;
436
437 Instance = (IP4_CONFIG2_INSTANCE *)Context;
438
439 if ((Instance->Dhcp4Handle != NULL) || (Instance->Policy != Ip4Config2PolicyDhcp)) {
440 //
441 // The DHCP4 child is already created or the policy is no longer DHCP.
442 //
443 return;
444 }
445
446 Ip4StartAutoConfig (Instance);
447}
448
449/**
450 Set the station address and subnetmask for the default interface.
451
452 @param[in] IpSb The pointer to the IP4 service binding instance.
453 @param[in] StationAddress Ip address to be set.
454 @param[in] SubnetMask Subnet to be set.
455
456 @retval EFI_SUCCESS Set default address successful.
457 @retval Others Some errors occur in setting.
458
459**/
460EFI_STATUS
461Ip4Config2SetDefaultAddr (
462 IN IP4_SERVICE *IpSb,
463 IN IP4_ADDR StationAddress,
464 IN IP4_ADDR SubnetMask
465 )
466{
467 EFI_STATUS Status;
468 IP4_INTERFACE *IpIf;
469 IP4_PROTOCOL *Ip4Instance;
470 EFI_ARP_PROTOCOL *Arp;
471 LIST_ENTRY *Entry;
472 IP4_ADDR Subnet;
473 IP4_ROUTE_TABLE *RouteTable;
474
475 IpIf = IpSb->DefaultInterface;
476 ASSERT (IpIf != NULL);
477
478 if ((IpIf->Ip == StationAddress) && (IpIf->SubnetMask == SubnetMask)) {
479 IpSb->State = IP4_SERVICE_CONFIGED;
480 return EFI_SUCCESS;
481 }
482
483 if (IpSb->Reconfig) {
484 //
485 // The default address is changed, free the previous interface first.
486 //
487 if (IpSb->DefaultRouteTable != NULL) {
488 Ip4FreeRouteTable (IpSb->DefaultRouteTable);
489 IpSb->DefaultRouteTable = NULL;
490 }
491
492 Ip4CancelReceive (IpSb->DefaultInterface);
493 Ip4FreeInterface (IpSb->DefaultInterface, NULL);
494 IpSb->DefaultInterface = NULL;
495 //
496 // Create new default interface and route table.
497 //
498 IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
499 if (IpIf == NULL) {
500 return EFI_OUT_OF_RESOURCES;
501 }
502
503 RouteTable = Ip4CreateRouteTable ();
504 if (RouteTable == NULL) {
505 Ip4FreeInterface (IpIf, NULL);
506 return EFI_OUT_OF_RESOURCES;
507 }
508
509 IpSb->DefaultInterface = IpIf;
510 InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
511 IpSb->DefaultRouteTable = RouteTable;
512 Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
513 }
514
515 if (IpSb->State == IP4_SERVICE_CONFIGED) {
516 IpSb->State = IP4_SERVICE_UNSTARTED;
517 }
518
519 Status = Ip4SetAddress (IpIf, StationAddress, SubnetMask);
520 if (EFI_ERROR (Status)) {
521 return Status;
522 }
523
524 if (IpIf->Arp != NULL) {
525 //
526 // A non-NULL IpIf->Arp here means a new ARP child is created when setting default address,
527 // but some IP children may have referenced the default interface before it is configured,
528 // these IP instances also consume this ARP protocol so they need to open it BY_CHILD_CONTROLLER.
529 //
530 Arp = NULL;
531 NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {
532 Ip4Instance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, AddrLink, IP4_PROTOCOL_SIGNATURE);
533 Status = gBS->OpenProtocol (
534 IpIf->ArpHandle,
535 &gEfiArpProtocolGuid,
536 (VOID **)&Arp,
537 gIp4DriverBinding.DriverBindingHandle,
538 Ip4Instance->Handle,
539 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
540 );
541 if (EFI_ERROR (Status)) {
542 return Status;
543 }
544 }
545 }
546
547 //
548 // Add a route for the connected network.
549 //
550 Subnet = StationAddress & SubnetMask;
551
552 Ip4AddRoute (
553 IpSb->DefaultRouteTable,
554 Subnet,
555 SubnetMask,
556 IP4_ALLZERO_ADDRESS
557 );
558
559 IpSb->State = IP4_SERVICE_CONFIGED;
560 IpSb->Reconfig = FALSE;
561
562 return EFI_SUCCESS;
563}
564
565/**
566 Set the station address, subnetmask and gateway address for the default interface.
567
568 @param[in] Instance The pointer to the IP4 config2 instance data.
569 @param[in] StationAddress Ip address to be set.
570 @param[in] SubnetMask Subnet to be set.
571 @param[in] GatewayAddress Gateway to be set.
572
573 @retval EFI_SUCCESS Set default If successful.
574 @retval Others Errors occur as indicated.
575
576**/
577EFI_STATUS
578Ip4Config2SetDefaultIf (
579 IN IP4_CONFIG2_INSTANCE *Instance,
580 IN IP4_ADDR StationAddress,
581 IN IP4_ADDR SubnetMask,
582 IN IP4_ADDR GatewayAddress
583 )
584{
585 EFI_STATUS Status;
586 IP4_SERVICE *IpSb;
587
588 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
589
590 //
591 // Check whether the StationAddress/SubnetMask pair is valid.
592 //
593 if (!Ip4StationAddressValid (StationAddress, SubnetMask)) {
594 return EFI_INVALID_PARAMETER;
595 }
596
597 Status = Ip4Config2SetDefaultAddr (IpSb, StationAddress, SubnetMask);
598 if (EFI_ERROR (Status)) {
599 return Status;
600 }
601
602 //
603 // Create a route if there is a default router.
604 //
605 if (GatewayAddress != IP4_ALLZERO_ADDRESS) {
606 Ip4AddRoute (
607 IpSb->DefaultRouteTable,
608 IP4_ALLZERO_ADDRESS,
609 IP4_ALLZERO_ADDRESS,
610 GatewayAddress
611 );
612 }
613
614 return EFI_SUCCESS;
615}
616
617/**
618 Release all the DHCP related resources.
619
620 @param Instance The IP4 config2 instance.
621
622 @return None
623
624**/
625VOID
626Ip4Config2CleanDhcp4 (
627 IN IP4_CONFIG2_INSTANCE *Instance
628 )
629{
630 IP4_SERVICE *IpSb;
631
632 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
633
634 if (Instance->Dhcp4 != NULL) {
635 Instance->Dhcp4->Stop (Instance->Dhcp4);
636
637 gBS->CloseProtocol (
638 Instance->Dhcp4Handle,
639 &gEfiDhcp4ProtocolGuid,
640 IpSb->Image,
641 IpSb->Controller
642 );
643
644 Instance->Dhcp4 = NULL;
645 }
646
647 if (Instance->Dhcp4Handle != NULL) {
648 NetLibDestroyServiceChild (
649 IpSb->Controller,
650 IpSb->Image,
651 &gEfiDhcp4ServiceBindingProtocolGuid,
652 Instance->Dhcp4Handle
653 );
654
655 Instance->Dhcp4Handle = NULL;
656 }
657
658 if (Instance->Dhcp4Event != NULL) {
659 gBS->CloseEvent (Instance->Dhcp4Event);
660 Instance->Dhcp4Event = NULL;
661 }
662}
663
664/**
665 This worker function sets the DNS server list for the EFI IPv4 network
666 stack running on the communication device that this EFI_IP4_CONFIG2_PROTOCOL
667 manages. The DNS server addresses must be unicast IPv4 addresses.
668
669 @param[in] Instance The pointer to the IP4 config2 instance data.
670 @param[in] DataSize The size of the buffer pointed to by Data in bytes.
671 @param[in] Data The data buffer to set, points to an array of
672 EFI_IPv4_ADDRESS instances.
673
674 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
675 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
676 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.
677 @retval EFI_ABORTED The DNS server addresses to be set equal the current
678 configuration.
679 @retval EFI_SUCCESS The specified configuration data for the EFI IPv4
680 network stack was set.
681
682**/
683EFI_STATUS
684Ip4Config2SetDnsServerWorker (
685 IN IP4_CONFIG2_INSTANCE *Instance,
686 IN UINTN DataSize,
687 IN VOID *Data
688 )
689{
690 UINTN OldIndex;
691 UINTN NewIndex;
692 EFI_IPv4_ADDRESS *OldDns;
693 EFI_IPv4_ADDRESS *NewDns;
694 UINTN OldDnsCount;
695 UINTN NewDnsCount;
696 IP4_CONFIG2_DATA_ITEM *Item;
697 BOOLEAN OneAdded;
698 VOID *Tmp;
699 IP4_ADDR DnsAddress;
700
701 if ((DataSize % sizeof (EFI_IPv4_ADDRESS) != 0) || (DataSize == 0)) {
702 return EFI_BAD_BUFFER_SIZE;
703 }
704
705 Item = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
706 NewDns = (EFI_IPv4_ADDRESS *)Data;
707 OldDns = Item->Data.DnsServers;
708 NewDnsCount = DataSize / sizeof (EFI_IPv4_ADDRESS);
709 OldDnsCount = Item->DataSize / sizeof (EFI_IPv4_ADDRESS);
710 OneAdded = FALSE;
711
712 if (NewDnsCount != OldDnsCount) {
713 Tmp = AllocatePool (DataSize);
714 if (Tmp == NULL) {
715 return EFI_OUT_OF_RESOURCES;
716 }
717 } else {
718 Tmp = NULL;
719 }
720
721 for (NewIndex = 0; NewIndex < NewDnsCount; NewIndex++) {
722 CopyMem (&DnsAddress, NewDns + NewIndex, sizeof (IP4_ADDR));
723 if (IP4_IS_UNSPECIFIED (NTOHL (DnsAddress)) || IP4_IS_LOCAL_BROADCAST (NTOHL (DnsAddress))) {
724 //
725 // The dns server address must be unicast.
726 //
727 if (Tmp != NULL) {
728 FreePool (Tmp);
729 }
730
731 return EFI_INVALID_PARAMETER;
732 }
733
734 if (OneAdded) {
735 //
736 // If any address in the new setting is not in the old settings, skip the
737 // comparision below.
738 //
739 continue;
740 }
741
742 for (OldIndex = 0; OldIndex < OldDnsCount; OldIndex++) {
743 if (EFI_IP4_EQUAL (NewDns + NewIndex, OldDns + OldIndex)) {
744 //
745 // If found break out.
746 //
747 break;
748 }
749 }
750
751 if (OldIndex == OldDnsCount) {
752 OneAdded = TRUE;
753 }
754 }
755
756 if (!OneAdded && (DataSize == Item->DataSize)) {
757 //
758 // No new item is added and the size is the same.
759 //
760 Item->Status = EFI_SUCCESS;
761 return EFI_ABORTED;
762 } else {
763 if (Tmp != NULL) {
764 if (Item->Data.Ptr != NULL) {
765 FreePool (Item->Data.Ptr);
766 }
767
768 Item->Data.Ptr = Tmp;
769 }
770
771 CopyMem (Item->Data.Ptr, Data, DataSize);
772 Item->DataSize = DataSize;
773 Item->Status = EFI_SUCCESS;
774 return EFI_SUCCESS;
775 }
776}
777
778/**
779 Callback function when DHCP process finished. It will save the
780 retrieved IP configure parameter from DHCP to the NVRam.
781
782 @param Event The callback event
783 @param Context Opaque context to the callback
784
785 @return None
786
787**/
788VOID
789EFIAPI
790Ip4Config2OnDhcp4Complete (
791 IN EFI_EVENT Event,
792 IN VOID *Context
793 )
794{
795 IP4_CONFIG2_INSTANCE *Instance;
796 EFI_DHCP4_MODE_DATA Dhcp4Mode;
797 EFI_STATUS Status;
798 IP4_ADDR StationAddress;
799 IP4_ADDR SubnetMask;
800 IP4_ADDR GatewayAddress;
801 UINT32 Index;
802 UINT32 OptionCount;
803 EFI_DHCP4_PACKET_OPTION **OptionList;
804
805 Instance = (IP4_CONFIG2_INSTANCE *)Context;
806 ASSERT (Instance->Dhcp4 != NULL);
807
808 //
809 // Get the DHCP retrieved parameters
810 //
811 Status = Instance->Dhcp4->GetModeData (Instance->Dhcp4, &Dhcp4Mode);
812
813 if (EFI_ERROR (Status)) {
814 goto Exit;
815 }
816
817 if (Dhcp4Mode.State == Dhcp4Bound) {
818 StationAddress = EFI_NTOHL (Dhcp4Mode.ClientAddress);
819 SubnetMask = EFI_NTOHL (Dhcp4Mode.SubnetMask);
820 GatewayAddress = EFI_NTOHL (Dhcp4Mode.RouterAddress);
821
822 Status = Ip4Config2SetDefaultIf (Instance, StationAddress, SubnetMask, GatewayAddress);
823 if (EFI_ERROR (Status)) {
824 goto Exit;
825 }
826
827 //
828 // Parse the ACK to get required DNS server information.
829 //
830 OptionCount = 0;
831 OptionList = NULL;
832
833 Status = Instance->Dhcp4->Parse (Instance->Dhcp4, Dhcp4Mode.ReplyPacket, &OptionCount, OptionList);
834 if (Status != EFI_BUFFER_TOO_SMALL) {
835 goto Exit;
836 }
837
838 OptionList = AllocateZeroPool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));
839 if (OptionList == NULL) {
840 goto Exit;
841 }
842
843 Status = Instance->Dhcp4->Parse (Instance->Dhcp4, Dhcp4Mode.ReplyPacket, &OptionCount, OptionList);
844 if (EFI_ERROR (Status)) {
845 FreePool (OptionList);
846 goto Exit;
847 }
848
849 for (Index = 0; Index < OptionCount; Index++) {
850 //
851 // Look for DNS Server opcode (6).
852 //
853 if (OptionList[Index]->OpCode == DHCP4_TAG_DNS_SERVER) {
854 if (((OptionList[Index]->Length & 0x3) != 0) || (OptionList[Index]->Length == 0)) {
855 break;
856 }
857
858 Ip4Config2SetDnsServerWorker (Instance, OptionList[Index]->Length, &OptionList[Index]->Data[0]);
859 break;
860 }
861 }
862
863 FreePool (OptionList);
864
865 Instance->DhcpSuccess = TRUE;
866 }
867
868Exit:
869 Ip4Config2CleanDhcp4 (Instance);
870 DispatchDpc ();
871}
872
873/**
874 Start the DHCP configuration for this IP service instance.
875 It will locates the EFI_IP4_CONFIG2_PROTOCOL, then start the
876 DHCP configuration.
877
878 @param[in] Instance The IP4 config2 instance to configure
879
880 @retval EFI_SUCCESS The auto configuration is successfully started
881 @retval Others Failed to start auto configuration.
882
883**/
884EFI_STATUS
885Ip4StartAutoConfig (
886 IN IP4_CONFIG2_INSTANCE *Instance
887 )
888{
889 IP4_SERVICE *IpSb;
890 EFI_DHCP4_PROTOCOL *Dhcp4;
891 EFI_DHCP4_MODE_DATA Dhcp4Mode;
892 EFI_DHCP4_PACKET_OPTION *OptionList[1];
893 IP4_CONFIG2_DHCP4_OPTION ParaList;
894 EFI_STATUS Status;
895
896 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
897
898 if (IpSb->State > IP4_SERVICE_UNSTARTED) {
899 return EFI_SUCCESS;
900 }
901
902 //
903 // A host must not invoke DHCP configuration if it is already
904 // participating in the DHCP configuration process.
905 //
906 if (Instance->Dhcp4Handle != NULL) {
907 return EFI_SUCCESS;
908 }
909
910 Status = NetLibCreateServiceChild (
911 IpSb->Controller,
912 IpSb->Image,
913 &gEfiDhcp4ServiceBindingProtocolGuid,
914 &Instance->Dhcp4Handle
915 );
916
917 if (Status == EFI_UNSUPPORTED) {
918 //
919 // No DHCPv4 Service Binding protocol, register a notify.
920 //
921 if (Instance->Dhcp4SbNotifyEvent == NULL) {
922 Instance->Dhcp4SbNotifyEvent = EfiCreateProtocolNotifyEvent (
923 &gEfiDhcp4ServiceBindingProtocolGuid,
924 TPL_CALLBACK,
925 Ip4Config2OnDhcp4SbInstalled,
926 (VOID *)Instance,
927 &Instance->Registration
928 );
929 }
930 }
931
932 if (EFI_ERROR (Status)) {
933 return Status;
934 }
935
936 if (Instance->Dhcp4SbNotifyEvent != NULL) {
937 gBS->CloseEvent (Instance->Dhcp4SbNotifyEvent);
938 }
939
940 Status = gBS->OpenProtocol (
941 Instance->Dhcp4Handle,
942 &gEfiDhcp4ProtocolGuid,
943 (VOID **)&Instance->Dhcp4,
944 IpSb->Image,
945 IpSb->Controller,
946 EFI_OPEN_PROTOCOL_BY_DRIVER
947 );
948 if (EFI_ERROR (Status)) {
949 NetLibDestroyServiceChild (
950 IpSb->Controller,
951 IpSb->Image,
952 &gEfiDhcp4ServiceBindingProtocolGuid,
953 Instance->Dhcp4Handle
954 );
955
956 Instance->Dhcp4Handle = NULL;
957
958 return Status;
959 }
960
961 //
962 // Check the current DHCP status, if the DHCP process has
963 // already finished, return now.
964 //
965 Dhcp4 = Instance->Dhcp4;
966 Status = Dhcp4->GetModeData (Dhcp4, &Dhcp4Mode);
967 if (Dhcp4Mode.State == Dhcp4Bound) {
968 Ip4Config2OnDhcp4Complete (NULL, Instance);
969
970 return EFI_SUCCESS;
971 }
972
973 //
974 // Try to start the DHCP process. Use most of the current
975 // DHCP configuration to avoid problems if some DHCP client
976 // yields the control of this DHCP service to us.
977 //
978 ParaList.Head.OpCode = DHCP4_TAG_PARA_LIST;
979 ParaList.Head.Length = 3;
980 ParaList.Head.Data[0] = DHCP4_TAG_NETMASK;
981 ParaList.Route = DHCP4_TAG_ROUTER;
982 ParaList.Dns = DHCP4_TAG_DNS_SERVER;
983 OptionList[0] = &ParaList.Head;
984 Dhcp4Mode.ConfigData.OptionCount = 1;
985 Dhcp4Mode.ConfigData.OptionList = OptionList;
986
987 Status = Dhcp4->Configure (Dhcp4, &Dhcp4Mode.ConfigData);
988 if (EFI_ERROR (Status)) {
989 gBS->CloseProtocol (
990 Instance->Dhcp4Handle,
991 &gEfiDhcp4ProtocolGuid,
992 IpSb->Image,
993 IpSb->Controller
994 );
995
996 NetLibDestroyServiceChild (
997 IpSb->Controller,
998 IpSb->Image,
999 &gEfiDhcp4ServiceBindingProtocolGuid,
1000 Instance->Dhcp4Handle
1001 );
1002
1003 Instance->Dhcp4 = NULL;
1004
1005 Instance->Dhcp4Handle = NULL;
1006
1007 return Status;
1008 }
1009
1010 //
1011 // Start the DHCP process
1012 //
1013 Status = gBS->CreateEvent (
1014 EVT_NOTIFY_SIGNAL,
1015 TPL_CALLBACK,
1016 Ip4Config2OnDhcp4Complete,
1017 Instance,
1018 &Instance->Dhcp4Event
1019 );
1020 if (EFI_ERROR (Status)) {
1021 Ip4Config2DestroyDhcp4 (Instance);
1022 return Status;
1023 }
1024
1025 Status = Dhcp4->Start (Dhcp4, Instance->Dhcp4Event);
1026 if (EFI_ERROR (Status)) {
1027 Ip4Config2DestroyDhcp4 (Instance);
1028 gBS->CloseEvent (Instance->Dhcp4Event);
1029 Instance->Dhcp4Event = NULL;
1030
1031 return Status;
1032 }
1033
1034 IpSb->State = IP4_SERVICE_STARTED;
1035 DispatchDpc ();
1036
1037 return EFI_SUCCESS;
1038}
1039
1040/**
1041 The work function is to get the interface information of the communication
1042 device this IP4_CONFIG2_INSTANCE manages.
1043
1044 @param[in] Instance Pointer to the IP4 config2 instance data.
1045 @param[in, out] DataSize On input, in bytes, the size of Data. On output, in
1046 bytes, the size of buffer required to store the specified
1047 configuration data.
1048 @param[in] Data The data buffer in which the configuration data is returned.
1049 Ignored if DataSize is ZERO.
1050
1051 @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified
1052 configuration data, and the required size is
1053 returned in DataSize.
1054 @retval EFI_SUCCESS The specified configuration data was obtained.
1055
1056**/
1057EFI_STATUS
1058Ip4Config2GetIfInfo (
1059 IN IP4_CONFIG2_INSTANCE *Instance,
1060 IN OUT UINTN *DataSize,
1061 IN VOID *Data OPTIONAL
1062 )
1063{
1064 IP4_SERVICE *IpSb;
1065 UINTN Length;
1066 IP4_CONFIG2_DATA_ITEM *Item;
1067 EFI_IP4_CONFIG2_INTERFACE_INFO *IfInfo;
1068 IP4_ADDR Address;
1069
1070 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1071 Length = sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO);
1072
1073 if (IpSb->DefaultRouteTable != NULL) {
1074 Length += IpSb->DefaultRouteTable->TotalNum * sizeof (EFI_IP4_ROUTE_TABLE);
1075 }
1076
1077 if (*DataSize < Length) {
1078 *DataSize = Length;
1079 return EFI_BUFFER_TOO_SMALL;
1080 }
1081
1082 //
1083 // Copy the fixed size part of the interface info.
1084 //
1085 Item = &Instance->DataItem[Ip4Config2DataTypeInterfaceInfo];
1086 IfInfo = (EFI_IP4_CONFIG2_INTERFACE_INFO *)Data;
1087 CopyMem (IfInfo, Item->Data.Ptr, sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO));
1088
1089 //
1090 // Update the address info.
1091 //
1092 if (IpSb->DefaultInterface != NULL) {
1093 Address = HTONL (IpSb->DefaultInterface->Ip);
1094 CopyMem (&IfInfo->StationAddress, &Address, sizeof (EFI_IPv4_ADDRESS));
1095 Address = HTONL (IpSb->DefaultInterface->SubnetMask);
1096 CopyMem (&IfInfo->SubnetMask, &Address, sizeof (EFI_IPv4_ADDRESS));
1097 }
1098
1099 if (IpSb->DefaultRouteTable != NULL) {
1100 IfInfo->RouteTableSize = IpSb->DefaultRouteTable->TotalNum;
1101 IfInfo->RouteTable = (EFI_IP4_ROUTE_TABLE *)((UINT8 *)Data + sizeof (EFI_IP4_CONFIG2_INTERFACE_INFO));
1102
1103 Ip4Config2BuildDefaultRouteTable (IpSb, IfInfo->RouteTable);
1104 }
1105
1106 return EFI_SUCCESS;
1107}
1108
1109/**
1110 The work function is to set the general configuration policy for the EFI IPv4 network
1111 stack that is running on the communication device managed by this IP4_CONFIG2_INSTANCE.
1112 The policy will affect other configuration settings.
1113
1114 @param[in] Instance Pointer to the IP4 config2 instance data.
1115 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
1116 @param[in] Data The data buffer to set.
1117
1118 @retval EFI_INVALID_PARAMETER The to be set policy is invalid.
1119 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
1120 @retval EFI_ABORTED The new policy equals the current policy.
1121 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1122 network stack was set.
1123
1124**/
1125EFI_STATUS
1126Ip4Config2SetPolicy (
1127 IN IP4_CONFIG2_INSTANCE *Instance,
1128 IN UINTN DataSize,
1129 IN VOID *Data
1130 )
1131{
1132 EFI_IP4_CONFIG2_POLICY NewPolicy;
1133 IP4_CONFIG2_DATA_ITEM *DataItem;
1134 IP4_SERVICE *IpSb;
1135
1136 if (DataSize != sizeof (EFI_IP4_CONFIG2_POLICY)) {
1137 return EFI_BAD_BUFFER_SIZE;
1138 }
1139
1140 NewPolicy = *((EFI_IP4_CONFIG2_POLICY *)Data);
1141
1142 if (NewPolicy >= Ip4Config2PolicyMax) {
1143 return EFI_INVALID_PARAMETER;
1144 }
1145
1146 if (NewPolicy == Instance->Policy) {
1147 if ((NewPolicy != Ip4Config2PolicyDhcp) || Instance->DhcpSuccess) {
1148 return EFI_ABORTED;
1149 }
1150 } else {
1151 //
1152 // The policy is changed. Clean the ManualAddress, Gateway and DnsServers,
1153 // shrink the variable data size, and fire up all the related events.
1154 //
1155 DataItem = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
1156 if (DataItem->Data.Ptr != NULL) {
1157 FreePool (DataItem->Data.Ptr);
1158 }
1159
1160 DataItem->Data.Ptr = NULL;
1161 DataItem->DataSize = 0;
1162 DataItem->Status = EFI_NOT_FOUND;
1163 NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
1164
1165 DataItem = &Instance->DataItem[Ip4Config2DataTypeGateway];
1166 if (DataItem->Data.Ptr != NULL) {
1167 FreePool (DataItem->Data.Ptr);
1168 }
1169
1170 DataItem->Data.Ptr = NULL;
1171 DataItem->DataSize = 0;
1172 DataItem->Status = EFI_NOT_FOUND;
1173 NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
1174
1175 DataItem = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
1176 if (DataItem->Data.Ptr != NULL) {
1177 FreePool (DataItem->Data.Ptr);
1178 }
1179
1180 DataItem->Data.Ptr = NULL;
1181 DataItem->DataSize = 0;
1182 DataItem->Status = EFI_NOT_FOUND;
1183 NetMapIterate (&DataItem->EventMap, Ip4Config2SignalEvent, NULL);
1184
1185 if (NewPolicy == Ip4Config2PolicyDhcp) {
1186 SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_VOLATILE);
1187 } else {
1188 //
1189 // The policy is changed from dhcp to static. Stop the DHCPv4 process
1190 // and destroy the DHCPv4 child.
1191 //
1192 if (Instance->Dhcp4Handle != NULL) {
1193 Ip4Config2DestroyDhcp4 (Instance);
1194 }
1195
1196 //
1197 // Close the event.
1198 //
1199 if (Instance->Dhcp4Event != NULL) {
1200 gBS->CloseEvent (Instance->Dhcp4Event);
1201 Instance->Dhcp4Event = NULL;
1202 }
1203 }
1204 }
1205
1206 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1207 Ip4Config2OnPolicyChanged (IpSb, NewPolicy);
1208
1209 Instance->Policy = NewPolicy;
1210
1211 return EFI_SUCCESS;
1212}
1213
1214/**
1215 The work function is to set the station addresses manually for the EFI IPv4
1216 network stack. It is only configurable when the policy is Ip4Config2PolicyStatic.
1217
1218 @param[in] Instance Pointer to the IP4 config2 instance data.
1219 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
1220 @param[in] Data The data buffer to set.
1221
1222 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
1223 @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set
1224 under the current policy.
1225 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1226 @retval EFI_OUT_OF_RESOURCES Fail to allocate resource to complete the operation.
1227 @retval EFI_NOT_READY An asynchronous process is invoked to set the specified
1228 configuration data, and the process is not finished.
1229 @retval EFI_ABORTED The manual addresses to be set equal current
1230 configuration.
1231 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1232 network stack was set.
1233
1234**/
1235EFI_STATUS
1236Ip4Config2SetManualAddress (
1237 IN IP4_CONFIG2_INSTANCE *Instance,
1238 IN UINTN DataSize,
1239 IN VOID *Data
1240 )
1241{
1242 EFI_IP4_CONFIG2_MANUAL_ADDRESS NewAddress;
1243 IP4_CONFIG2_DATA_ITEM *DataItem;
1244 EFI_STATUS Status;
1245 IP4_ADDR StationAddress;
1246 IP4_ADDR SubnetMask;
1247 VOID *Ptr;
1248 IP4_SERVICE *IpSb;
1249 IP4_INTERFACE *IpIf;
1250 IP4_ROUTE_TABLE *RouteTable;
1251
1252 DataItem = NULL;
1253 Status = EFI_SUCCESS;
1254 Ptr = NULL;
1255 IpIf = NULL;
1256 RouteTable = NULL;
1257
1258 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1259
1260 ASSERT (Instance->DataItem[Ip4Config2DataTypeManualAddress].Status != EFI_NOT_READY);
1261
1262 if ((DataSize != 0) && ((DataSize % sizeof (EFI_IP4_CONFIG2_MANUAL_ADDRESS)) != 0)) {
1263 return EFI_BAD_BUFFER_SIZE;
1264 }
1265
1266 if (Instance->Policy != Ip4Config2PolicyStatic) {
1267 return EFI_WRITE_PROTECTED;
1268 }
1269
1270 DataItem = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
1271
1272 if ((Data != NULL) && (DataSize != 0)) {
1273 NewAddress = *((EFI_IP4_CONFIG2_MANUAL_ADDRESS *)Data);
1274
1275 StationAddress = EFI_NTOHL (NewAddress.Address);
1276 SubnetMask = EFI_NTOHL (NewAddress.SubnetMask);
1277
1278 //
1279 // Check whether the StationAddress/SubnetMask pair is valid.
1280 //
1281 if (!Ip4StationAddressValid (StationAddress, SubnetMask)) {
1282 return EFI_INVALID_PARAMETER;
1283 }
1284
1285 //
1286 // Store the new data, and init the DataItem status to EFI_NOT_READY because
1287 // we may have an asynchronous configuration process.
1288 //
1289 Ptr = AllocateCopyPool (DataSize, Data);
1290 if (Ptr == NULL) {
1291 return EFI_OUT_OF_RESOURCES;
1292 }
1293
1294 if (DataItem->Data.Ptr != NULL) {
1295 FreePool (DataItem->Data.Ptr);
1296 }
1297
1298 DataItem->Data.Ptr = Ptr;
1299 DataItem->DataSize = DataSize;
1300 DataItem->Status = EFI_NOT_READY;
1301
1302 IpSb->Reconfig = TRUE;
1303 Status = Ip4Config2SetDefaultAddr (IpSb, StationAddress, SubnetMask);
1304
1305 DataItem->Status = Status;
1306
1307 if (EFI_ERROR (DataItem->Status) && (DataItem->Status != EFI_NOT_READY)) {
1308 if (Ptr != NULL) {
1309 FreePool (Ptr);
1310 }
1311
1312 DataItem->Data.Ptr = NULL;
1313 }
1314 } else {
1315 //
1316 // DataSize is 0 and Data is NULL, clean up the manual address.
1317 //
1318 if (DataItem->Data.Ptr != NULL) {
1319 FreePool (DataItem->Data.Ptr);
1320 }
1321
1322 DataItem->Data.Ptr = NULL;
1323 DataItem->DataSize = 0;
1324 DataItem->Status = EFI_NOT_FOUND;
1325
1326 //
1327 // Free the default router table and Interface, clean up the assemble table.
1328 //
1329 if (IpSb->DefaultInterface != NULL) {
1330 if (IpSb->DefaultRouteTable != NULL) {
1331 Ip4FreeRouteTable (IpSb->DefaultRouteTable);
1332 IpSb->DefaultRouteTable = NULL;
1333 }
1334
1335 Ip4CancelReceive (IpSb->DefaultInterface);
1336
1337 Ip4FreeInterface (IpSb->DefaultInterface, NULL);
1338 IpSb->DefaultInterface = NULL;
1339 }
1340
1341 Ip4CleanAssembleTable (&IpSb->Assemble);
1342
1343 //
1344 // Create new default interface and route table.
1345 //
1346 IpIf = Ip4CreateInterface (IpSb->Mnp, IpSb->Controller, IpSb->Image);
1347 if (IpIf == NULL) {
1348 return EFI_OUT_OF_RESOURCES;
1349 }
1350
1351 RouteTable = Ip4CreateRouteTable ();
1352 if (RouteTable == NULL) {
1353 Ip4FreeInterface (IpIf, NULL);
1354 return EFI_OUT_OF_RESOURCES;
1355 }
1356
1357 IpSb->DefaultInterface = IpIf;
1358 InsertHeadList (&IpSb->Interfaces, &IpIf->Link);
1359 IpSb->DefaultRouteTable = RouteTable;
1360 Ip4ReceiveFrame (IpIf, NULL, Ip4AccpetFrame, IpSb);
1361
1362 //
1363 // Reset the State to unstarted.
1364 //
1365 if ((IpSb->State == IP4_SERVICE_CONFIGED) || (IpSb->State == IP4_SERVICE_STARTED)) {
1366 IpSb->State = IP4_SERVICE_UNSTARTED;
1367 }
1368 }
1369
1370 return Status;
1371}
1372
1373/**
1374 The work function is to set the gateway addresses manually for the EFI IPv4
1375 network stack that is running on the communication device that this EFI IPv4
1376 Configuration Protocol manages. It is not configurable when the policy is
1377 Ip4Config2PolicyDhcp. The gateway addresses must be unicast IPv4 addresses.
1378
1379 @param[in] Instance The pointer to the IP4 config2 instance data.
1380 @param[in] DataSize The size of the buffer pointed to by Data in bytes.
1381 @param[in] Data The data buffer to set. This points to an array of
1382 EFI_IPv6_ADDRESS instances.
1383
1384 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
1385 @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set
1386 under the current policy.
1387 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1388 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to complete the operation.
1389 @retval EFI_ABORTED The manual gateway addresses to be set equal the
1390 current configuration.
1391 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1392 network stack was set.
1393
1394**/
1395EFI_STATUS
1396Ip4Config2SetGateway (
1397 IN IP4_CONFIG2_INSTANCE *Instance,
1398 IN UINTN DataSize,
1399 IN VOID *Data
1400 )
1401{
1402 IP4_SERVICE *IpSb;
1403 IP4_CONFIG2_DATA_ITEM *DataItem;
1404 IP4_ADDR Gateway;
1405
1406 UINTN Index1;
1407 UINTN Index2;
1408 EFI_IPv4_ADDRESS *OldGateway;
1409 EFI_IPv4_ADDRESS *NewGateway;
1410 UINTN OldGatewayCount;
1411 UINTN NewGatewayCount;
1412 BOOLEAN OneRemoved;
1413 BOOLEAN OneAdded;
1414 VOID *Tmp;
1415
1416 OldGateway = NULL;
1417 NewGateway = NULL;
1418 OneRemoved = FALSE;
1419 OneAdded = FALSE;
1420 Tmp = NULL;
1421
1422 if ((DataSize != 0) && (DataSize % sizeof (EFI_IPv4_ADDRESS) != 0)) {
1423 return EFI_BAD_BUFFER_SIZE;
1424 }
1425
1426 if (Instance->Policy != Ip4Config2PolicyStatic) {
1427 return EFI_WRITE_PROTECTED;
1428 }
1429
1430 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1431
1432 DataItem = &Instance->DataItem[Ip4Config2DataTypeGateway];
1433 OldGateway = DataItem->Data.Gateway;
1434 OldGatewayCount = DataItem->DataSize / sizeof (EFI_IPv4_ADDRESS);
1435
1436 for (Index1 = 0; Index1 < OldGatewayCount; Index1++) {
1437 //
1438 // Remove the old route entry.
1439 //
1440 CopyMem (&Gateway, OldGateway + Index1, sizeof (IP4_ADDR));
1441 Ip4DelRoute (
1442 IpSb->DefaultRouteTable,
1443 IP4_ALLZERO_ADDRESS,
1444 IP4_ALLZERO_ADDRESS,
1445 NTOHL (Gateway)
1446 );
1447 OneRemoved = TRUE;
1448 }
1449
1450 if ((Data != NULL) && (DataSize != 0)) {
1451 NewGateway = (EFI_IPv4_ADDRESS *)Data;
1452 NewGatewayCount = DataSize / sizeof (EFI_IPv4_ADDRESS);
1453 for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
1454 CopyMem (&Gateway, NewGateway + Index1, sizeof (IP4_ADDR));
1455
1456 if ((IpSb->DefaultInterface->SubnetMask != 0) &&
1457 !NetIp4IsUnicast (NTOHL (Gateway), IpSb->DefaultInterface->SubnetMask))
1458 {
1459 return EFI_INVALID_PARAMETER;
1460 }
1461
1462 for (Index2 = Index1 + 1; Index2 < NewGatewayCount; Index2++) {
1463 if (EFI_IP4_EQUAL (NewGateway + Index1, NewGateway + Index2)) {
1464 return EFI_INVALID_PARAMETER;
1465 }
1466 }
1467 }
1468
1469 if (NewGatewayCount != OldGatewayCount) {
1470 Tmp = AllocatePool (DataSize);
1471 if (Tmp == NULL) {
1472 return EFI_OUT_OF_RESOURCES;
1473 }
1474 } else {
1475 Tmp = NULL;
1476 }
1477
1478 for (Index1 = 0; Index1 < NewGatewayCount; Index1++) {
1479 //
1480 // Add the new route entry.
1481 //
1482 CopyMem (&Gateway, NewGateway + Index1, sizeof (IP4_ADDR));
1483 Ip4AddRoute (
1484 IpSb->DefaultRouteTable,
1485 IP4_ALLZERO_ADDRESS,
1486 IP4_ALLZERO_ADDRESS,
1487 NTOHL (Gateway)
1488 );
1489
1490 OneAdded = TRUE;
1491 }
1492
1493 if (!OneRemoved && !OneAdded) {
1494 DataItem->Status = EFI_SUCCESS;
1495 return EFI_ABORTED;
1496 } else {
1497 if (Tmp != NULL) {
1498 if (DataItem->Data.Ptr != NULL) {
1499 FreePool (DataItem->Data.Ptr);
1500 }
1501
1502 DataItem->Data.Ptr = Tmp;
1503 }
1504
1505 CopyMem (DataItem->Data.Ptr, Data, DataSize);
1506 DataItem->DataSize = DataSize;
1507 DataItem->Status = EFI_SUCCESS;
1508 }
1509 } else {
1510 //
1511 // DataSize is 0 and Data is NULL, clean up the Gateway address.
1512 //
1513 if (DataItem->Data.Ptr != NULL) {
1514 FreePool (DataItem->Data.Ptr);
1515 }
1516
1517 DataItem->Data.Ptr = NULL;
1518 DataItem->DataSize = 0;
1519 DataItem->Status = EFI_NOT_FOUND;
1520 }
1521
1522 return EFI_SUCCESS;
1523}
1524
1525/**
1526 The work function is to set the DNS server list for the EFI IPv4 network
1527 stack running on the communication device that this EFI_IP4_CONFIG2_PROTOCOL
1528 manages. It is not configurable when the policy is Ip4Config2PolicyDhcp.
1529 The DNS server addresses must be unicast IPv4 addresses.
1530
1531 @param[in] Instance The pointer to the IP4 config2 instance data.
1532 @param[in] DataSize The size of the buffer pointed to by Data in bytes.
1533 @param[in] Data The data buffer to set, points to an array of
1534 EFI_IPv4_ADDRESS instances.
1535
1536 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type.
1537 @retval EFI_WRITE_PROTECTED The specified configuration data cannot be set
1538 under the current policy.
1539 @retval EFI_INVALID_PARAMETER One or more fields in Data is invalid.
1540 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.
1541 @retval EFI_ABORTED The DNS server addresses to be set equal the current
1542 configuration.
1543 @retval EFI_SUCCESS The specified configuration data for the EFI IPv4
1544 network stack was set.
1545
1546**/
1547EFI_STATUS
1548Ip4Config2SetDnsServer (
1549 IN IP4_CONFIG2_INSTANCE *Instance,
1550 IN UINTN DataSize,
1551 IN VOID *Data
1552 )
1553{
1554 EFI_STATUS Status;
1555 IP4_CONFIG2_DATA_ITEM *Item;
1556
1557 Status = EFI_SUCCESS;
1558 Item = NULL;
1559
1560 if (Instance->Policy != Ip4Config2PolicyStatic) {
1561 return EFI_WRITE_PROTECTED;
1562 }
1563
1564 Item = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
1565
1566 if (DATA_ATTRIB_SET (Item->Attribute, DATA_ATTRIB_VOLATILE)) {
1567 REMOVE_DATA_ATTRIB (Item->Attribute, DATA_ATTRIB_VOLATILE);
1568 }
1569
1570 if ((Data != NULL) && (DataSize != 0)) {
1571 Status = Ip4Config2SetDnsServerWorker (Instance, DataSize, Data);
1572 } else {
1573 //
1574 // DataSize is 0 and Data is NULL, clean up the DnsServer address.
1575 //
1576 if (Item->Data.Ptr != NULL) {
1577 FreePool (Item->Data.Ptr);
1578 }
1579
1580 Item->Data.Ptr = NULL;
1581 Item->DataSize = 0;
1582 Item->Status = EFI_NOT_FOUND;
1583 }
1584
1585 return Status;
1586}
1587
1588/**
1589 Generate the operational state of the interface this IP4 config2 instance manages
1590 and output in EFI_IP4_CONFIG2_INTERFACE_INFO.
1591
1592 @param[in] IpSb The pointer to the IP4 service binding instance.
1593 @param[out] IfInfo The pointer to the IP4 config2 interface information structure.
1594
1595**/
1596VOID
1597Ip4Config2InitIfInfo (
1598 IN IP4_SERVICE *IpSb,
1599 OUT EFI_IP4_CONFIG2_INTERFACE_INFO *IfInfo
1600 )
1601{
1602 UnicodeSPrint (
1603 IfInfo->Name,
1604 EFI_IP4_CONFIG2_INTERFACE_INFO_NAME_SIZE,
1605 L"eth%d",
1606 IpSb->Ip4Config2Instance.IfIndex
1607 );
1608
1609 IfInfo->IfType = IpSb->SnpMode.IfType;
1610 IfInfo->HwAddressSize = IpSb->SnpMode.HwAddressSize;
1611 CopyMem (&IfInfo->HwAddress, &IpSb->SnpMode.CurrentAddress, IfInfo->HwAddressSize);
1612}
1613
1614/**
1615 Set the configuration for the EFI IPv4 network stack running on the communication
1616 device this EFI_IP4_CONFIG2_PROTOCOL instance manages.
1617
1618 This function is used to set the configuration data of type DataType for the EFI
1619 IPv4 network stack that is running on the communication device that this EFI IPv4
1620 Configuration Protocol instance manages.
1621
1622 DataSize is used to calculate the count of structure instances in the Data for
1623 a DataType in which multiple structure instances are allowed.
1624
1625 This function is always non-blocking. When setting some type of configuration data,
1626 an asynchronous process is invoked to check the correctness of the data, such as
1627 performing Duplicate Address Detection on the manually set local IPv4 addresses.
1628 EFI_NOT_READY is returned immediately to indicate that such an asynchronous process
1629 is invoked, and the process is not finished yet. The caller wanting to get the result
1630 of the asynchronous process is required to call RegisterDataNotify() to register an
1631 event on the specified configuration data. Once the event is signaled, the caller
1632 can call GetData() to obtain the configuration data and know the result.
1633 For other types of configuration data that do not require an asynchronous configuration
1634 process, the result of the operation is immediately returned.
1635
1636 @param[in] This The pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1637 @param[in] DataType The type of data to set.
1638 @param[in] DataSize Size of the buffer pointed to by Data in bytes.
1639 @param[in] Data The data buffer to set. The type of the data buffer is
1640 associated with the DataType.
1641
1642 @retval EFI_SUCCESS The specified configuration data for the EFI IPv6
1643 network stack was set successfully.
1644 @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
1645 - This is NULL.
1646 - One or more fields in Data and DataSize do not match the
1647 requirement of the data type indicated by DataType.
1648 @retval EFI_WRITE_PROTECTED The specified configuration data is read-only or the specified
1649 configuration data cannot be set under the current policy.
1650 @retval EFI_ACCESS_DENIED Another set operation on the specified configuration
1651 data is already in process.
1652 @retval EFI_NOT_READY An asynchronous process was invoked to set the specified
1653 configuration data, and the process is not finished yet.
1654 @retval EFI_BAD_BUFFER_SIZE The DataSize does not match the size of the type
1655 indicated by DataType.
1656 @retval EFI_UNSUPPORTED This DataType is not supported.
1657 @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated.
1658 @retval EFI_DEVICE_ERROR An unexpected system error or network error occurred.
1659
1660**/
1661EFI_STATUS
1662EFIAPI
1663EfiIp4Config2SetData (
1664 IN EFI_IP4_CONFIG2_PROTOCOL *This,
1665 IN EFI_IP4_CONFIG2_DATA_TYPE DataType,
1666 IN UINTN DataSize,
1667 IN VOID *Data
1668 )
1669{
1670 EFI_TPL OldTpl;
1671 EFI_STATUS Status;
1672 IP4_CONFIG2_INSTANCE *Instance;
1673 IP4_SERVICE *IpSb;
1674
1675 if ((This == NULL) || ((Data == NULL) && (DataSize != 0)) || ((Data != NULL) && (DataSize == 0))) {
1676 return EFI_INVALID_PARAMETER;
1677 }
1678
1679 if (DataType >= Ip4Config2DataTypeMaximum) {
1680 return EFI_UNSUPPORTED;
1681 }
1682
1683 Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1684 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1685 NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);
1686
1687 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1688
1689 Status = Instance->DataItem[DataType].Status;
1690 if (Status != EFI_NOT_READY) {
1691 if (Instance->DataItem[DataType].SetData == NULL) {
1692 //
1693 // This type of data is readonly.
1694 //
1695 Status = EFI_WRITE_PROTECTED;
1696 } else {
1697 Status = Instance->DataItem[DataType].SetData (Instance, DataSize, Data);
1698 if (!EFI_ERROR (Status)) {
1699 //
1700 // Fire up the events registered with this type of data.
1701 //
1702 NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip4Config2SignalEvent, NULL);
1703 Ip4Config2WriteConfigData (IpSb->MacString, Instance);
1704 } else if (Status == EFI_ABORTED) {
1705 //
1706 // The SetData is aborted because the data to set is the same with
1707 // the one maintained.
1708 //
1709 Status = EFI_SUCCESS;
1710 NetMapIterate (&Instance->DataItem[DataType].EventMap, Ip4Config2SignalEvent, NULL);
1711 }
1712 }
1713 } else {
1714 //
1715 // Another asynchronous process is on the way.
1716 //
1717 Status = EFI_ACCESS_DENIED;
1718 }
1719
1720 gBS->RestoreTPL (OldTpl);
1721
1722 return Status;
1723}
1724
1725/**
1726 Get the configuration data for the EFI IPv4 network stack running on the communication
1727 device that this EFI_IP4_CONFIG2_PROTOCOL instance manages.
1728
1729 This function returns the configuration data of type DataType for the EFI IPv4 network
1730 stack running on the communication device that this EFI IPv4 Configuration Protocol instance
1731 manages.
1732
1733 The caller is responsible for allocating the buffer used to return the specified
1734 configuration data. The required size will be returned to the caller if the size of
1735 the buffer is too small.
1736
1737 EFI_NOT_READY is returned if the specified configuration data is not ready due to an
1738 asynchronous configuration process already in progress. The caller can call RegisterDataNotify()
1739 to register an event on the specified configuration data. Once the asynchronous configuration
1740 process is finished, the event will be signaled, and a subsequent GetData() call will return
1741 the specified configuration data.
1742
1743 @param[in] This Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1744 @param[in] DataType The type of data to get.
1745 @param[in, out] DataSize On input, in bytes, the size of Data. On output, in bytes, the
1746 size of buffer required to store the specified configuration data.
1747 @param[in] Data The data buffer in which the configuration data is returned. The
1748 type of the data buffer is associated with the DataType.
1749 This is an optional parameter that may be NULL.
1750
1751 @retval EFI_SUCCESS The specified configuration data was obtained successfully.
1752 @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
1753 - This is NULL.
1754 - DataSize is NULL.
1755 - Data is NULL if *DataSize is not zero.
1756 @retval EFI_BUFFER_TOO_SMALL The size of Data is too small for the specified configuration data,
1757 and the required size is returned in DataSize.
1758 @retval EFI_NOT_READY The specified configuration data is not ready due to an
1759 asynchronous configuration process already in progress.
1760 @retval EFI_NOT_FOUND The specified configuration data is not found.
1761
1762**/
1763EFI_STATUS
1764EFIAPI
1765EfiIp4Config2GetData (
1766 IN EFI_IP4_CONFIG2_PROTOCOL *This,
1767 IN EFI_IP4_CONFIG2_DATA_TYPE DataType,
1768 IN OUT UINTN *DataSize,
1769 IN VOID *Data OPTIONAL
1770 )
1771{
1772 EFI_TPL OldTpl;
1773 EFI_STATUS Status;
1774 IP4_CONFIG2_INSTANCE *Instance;
1775 IP4_CONFIG2_DATA_ITEM *DataItem;
1776
1777 if ((This == NULL) || (DataSize == NULL) || ((*DataSize != 0) && (Data == NULL))) {
1778 return EFI_INVALID_PARAMETER;
1779 }
1780
1781 if (DataType >= Ip4Config2DataTypeMaximum) {
1782 return EFI_NOT_FOUND;
1783 }
1784
1785 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1786
1787 Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1788 DataItem = &Instance->DataItem[DataType];
1789
1790 Status = Instance->DataItem[DataType].Status;
1791 if (!EFI_ERROR (Status)) {
1792 if (DataItem->GetData != NULL) {
1793 Status = DataItem->GetData (Instance, DataSize, Data);
1794 } else if (*DataSize < Instance->DataItem[DataType].DataSize) {
1795 //
1796 // Update the buffer length.
1797 //
1798 *DataSize = Instance->DataItem[DataType].DataSize;
1799 Status = EFI_BUFFER_TOO_SMALL;
1800 } else {
1801 *DataSize = Instance->DataItem[DataType].DataSize;
1802 CopyMem (Data, Instance->DataItem[DataType].Data.Ptr, *DataSize);
1803 }
1804 }
1805
1806 gBS->RestoreTPL (OldTpl);
1807
1808 return Status;
1809}
1810
1811/**
1812 Register an event that is signaled whenever a configuration process on the specified
1813 configuration data is done.
1814
1815 This function registers an event that is to be signaled whenever a configuration
1816 process on the specified configuration data is performed. An event can be registered
1817 for a different DataType simultaneously. The caller is responsible for determining
1818 which type of configuration data causes the signaling of the event in such an event.
1819
1820 @param[in] This Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1821 @param[in] DataType The type of data to unregister the event for.
1822 @param[in] Event The event to register.
1823
1824 @retval EFI_SUCCESS The notification event for the specified configuration data is
1825 registered.
1826 @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
1827 @retval EFI_UNSUPPORTED The configuration data type specified by DataType is not
1828 supported.
1829 @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated.
1830 @retval EFI_ACCESS_DENIED The Event is already registered for the DataType.
1831
1832**/
1833EFI_STATUS
1834EFIAPI
1835EfiIp4Config2RegisterDataNotify (
1836 IN EFI_IP4_CONFIG2_PROTOCOL *This,
1837 IN EFI_IP4_CONFIG2_DATA_TYPE DataType,
1838 IN EFI_EVENT Event
1839 )
1840{
1841 EFI_TPL OldTpl;
1842 EFI_STATUS Status;
1843 IP4_CONFIG2_INSTANCE *Instance;
1844 NET_MAP *EventMap;
1845 NET_MAP_ITEM *Item;
1846
1847 if ((This == NULL) || (Event == NULL)) {
1848 return EFI_INVALID_PARAMETER;
1849 }
1850
1851 if (DataType >= Ip4Config2DataTypeMaximum) {
1852 return EFI_UNSUPPORTED;
1853 }
1854
1855 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1856
1857 Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1858 EventMap = &Instance->DataItem[DataType].EventMap;
1859
1860 //
1861 // Check whether this event is already registered for this DataType.
1862 //
1863 Item = NetMapFindKey (EventMap, Event);
1864 if (Item == NULL) {
1865 Status = NetMapInsertTail (EventMap, Event, NULL);
1866
1867 if (EFI_ERROR (Status)) {
1868 Status = EFI_OUT_OF_RESOURCES;
1869 }
1870 } else {
1871 Status = EFI_ACCESS_DENIED;
1872 }
1873
1874 gBS->RestoreTPL (OldTpl);
1875
1876 return Status;
1877}
1878
1879/**
1880 Remove a previously registered event for the specified configuration data.
1881
1882 @param This The pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.
1883 @param DataType The type of data to remove from the previously
1884 registered event.
1885 @param Event The event to be unregistered.
1886
1887 @retval EFI_SUCCESS The event registered for the specified
1888 configuration data was removed.
1889 @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
1890 @retval EFI_NOT_FOUND The Event has not been registered for the
1891 specified DataType.
1892
1893**/
1894EFI_STATUS
1895EFIAPI
1896EfiIp4Config2UnregisterDataNotify (
1897 IN EFI_IP4_CONFIG2_PROTOCOL *This,
1898 IN EFI_IP4_CONFIG2_DATA_TYPE DataType,
1899 IN EFI_EVENT Event
1900 )
1901{
1902 EFI_TPL OldTpl;
1903 EFI_STATUS Status;
1904 IP4_CONFIG2_INSTANCE *Instance;
1905 NET_MAP_ITEM *Item;
1906
1907 if ((This == NULL) || (Event == NULL)) {
1908 return EFI_INVALID_PARAMETER;
1909 }
1910
1911 if (DataType >= Ip4Config2DataTypeMaximum) {
1912 return EFI_NOT_FOUND;
1913 }
1914
1915 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1916
1917 Instance = IP4_CONFIG2_INSTANCE_FROM_PROTOCOL (This);
1918
1919 Item = NetMapFindKey (&Instance->DataItem[DataType].EventMap, Event);
1920 if (Item != NULL) {
1921 NetMapRemoveItem (&Instance->DataItem[DataType].EventMap, Item, NULL);
1922 Status = EFI_SUCCESS;
1923 } else {
1924 Status = EFI_NOT_FOUND;
1925 }
1926
1927 gBS->RestoreTPL (OldTpl);
1928
1929 return Status;
1930}
1931
1932/**
1933 Initialize an IP4_CONFIG2_INSTANCE.
1934
1935 @param[out] Instance The buffer of IP4_CONFIG2_INSTANCE to be initialized.
1936
1937 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to complete the operation.
1938 @retval EFI_SUCCESS The IP4_CONFIG2_INSTANCE initialized successfully.
1939
1940**/
1941EFI_STATUS
1942Ip4Config2InitInstance (
1943 OUT IP4_CONFIG2_INSTANCE *Instance
1944 )
1945{
1946 IP4_SERVICE *IpSb;
1947 IP4_CONFIG2_INSTANCE *TmpInstance;
1948 LIST_ENTRY *Entry;
1949 EFI_STATUS Status;
1950 UINTN Index;
1951 UINT16 IfIndex;
1952 IP4_CONFIG2_DATA_ITEM *DataItem;
1953
1954 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1955
1956 Instance->Signature = IP4_CONFIG2_INSTANCE_SIGNATURE;
1957
1958 //
1959 // Determine the index of this interface.
1960 //
1961 IfIndex = 0;
1962 NET_LIST_FOR_EACH (Entry, &mIp4Config2InstanceList) {
1963 TmpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_CONFIG2_INSTANCE, Link, IP4_CONFIG2_INSTANCE_SIGNATURE);
1964
1965 if (TmpInstance->IfIndex > IfIndex) {
1966 //
1967 // There is a sequence hole because some interface is down.
1968 //
1969 break;
1970 }
1971
1972 IfIndex++;
1973 }
1974
1975 Instance->IfIndex = IfIndex;
1976 NetListInsertBefore (Entry, &Instance->Link);
1977
1978 for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
1979 //
1980 // Initialize the event map for each data item.
1981 //
1982 NetMapInit (&Instance->DataItem[Index].EventMap);
1983 }
1984
1985 //
1986 // Initialize each data type: associate storage and set data size for the
1987 // fixed size data types, hook the SetData function, set the data attribute.
1988 //
1989 DataItem = &Instance->DataItem[Ip4Config2DataTypeInterfaceInfo];
1990 DataItem->GetData = Ip4Config2GetIfInfo;
1991 DataItem->Data.Ptr = &Instance->InterfaceInfo;
1992 DataItem->DataSize = sizeof (Instance->InterfaceInfo);
1993 SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED | DATA_ATTRIB_VOLATILE);
1994 Ip4Config2InitIfInfo (IpSb, &Instance->InterfaceInfo);
1995
1996 DataItem = &Instance->DataItem[Ip4Config2DataTypePolicy];
1997 DataItem->SetData = Ip4Config2SetPolicy;
1998 DataItem->Data.Ptr = &Instance->Policy;
1999 DataItem->DataSize = sizeof (Instance->Policy);
2000 Instance->Policy = Ip4Config2PolicyStatic;
2001 SET_DATA_ATTRIB (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED);
2002
2003 DataItem = &Instance->DataItem[Ip4Config2DataTypeManualAddress];
2004 DataItem->SetData = Ip4Config2SetManualAddress;
2005 DataItem->Status = EFI_NOT_FOUND;
2006
2007 DataItem = &Instance->DataItem[Ip4Config2DataTypeGateway];
2008 DataItem->SetData = Ip4Config2SetGateway;
2009 DataItem->Status = EFI_NOT_FOUND;
2010
2011 DataItem = &Instance->DataItem[Ip4Config2DataTypeDnsServer];
2012 DataItem->SetData = Ip4Config2SetDnsServer;
2013 DataItem->Status = EFI_NOT_FOUND;
2014
2015 Instance->Configured = TRUE;
2016
2017 //
2018 // Try to read the config data from NV variable.
2019 // If not found, write initialized config data into NV variable
2020 // as a default config data.
2021 //
2022 Status = Ip4Config2ReadConfigData (IpSb->MacString, Instance);
2023 if (Status == EFI_NOT_FOUND) {
2024 Status = Ip4Config2WriteConfigData (IpSb->MacString, Instance);
2025 }
2026
2027 if (EFI_ERROR (Status)) {
2028 return Status;
2029 }
2030
2031 Instance->Ip4Config2.SetData = EfiIp4Config2SetData;
2032 Instance->Ip4Config2.GetData = EfiIp4Config2GetData;
2033 Instance->Ip4Config2.RegisterDataNotify = EfiIp4Config2RegisterDataNotify;
2034 Instance->Ip4Config2.UnregisterDataNotify = EfiIp4Config2UnregisterDataNotify;
2035
2036 //
2037 // Publish the IP4 configuration form
2038 //
2039 return Ip4Config2FormInit (Instance);
2040}
2041
2042/**
2043 Release an IP4_CONFIG2_INSTANCE.
2044
2045 @param[in, out] Instance The buffer of IP4_CONFIG2_INSTANCE to be freed.
2046
2047**/
2048VOID
2049Ip4Config2CleanInstance (
2050 IN OUT IP4_CONFIG2_INSTANCE *Instance
2051 )
2052{
2053 UINTN Index;
2054 IP4_CONFIG2_DATA_ITEM *DataItem;
2055
2056 if (Instance->DeclineAddress != NULL) {
2057 FreePool (Instance->DeclineAddress);
2058 }
2059
2060 if (!Instance->Configured) {
2061 return;
2062 }
2063
2064 if (Instance->Dhcp4Handle != NULL) {
2065 Ip4Config2DestroyDhcp4 (Instance);
2066 }
2067
2068 //
2069 // Close the event.
2070 //
2071 if (Instance->Dhcp4Event != NULL) {
2072 gBS->CloseEvent (Instance->Dhcp4Event);
2073 Instance->Dhcp4Event = NULL;
2074 }
2075
2076 for (Index = 0; Index < Ip4Config2DataTypeMaximum; Index++) {
2077 DataItem = &Instance->DataItem[Index];
2078
2079 if (!DATA_ATTRIB_SET (DataItem->Attribute, DATA_ATTRIB_SIZE_FIXED)) {
2080 if (DataItem->Data.Ptr != NULL) {
2081 FreePool (DataItem->Data.Ptr);
2082 }
2083
2084 DataItem->Data.Ptr = NULL;
2085 DataItem->DataSize = 0;
2086 }
2087
2088 NetMapClean (&Instance->DataItem[Index].EventMap);
2089 }
2090
2091 Ip4Config2FormUnload (Instance);
2092
2093 RemoveEntryList (&Instance->Link);
2094}
2095
2096/**
2097 The event handle for IP4 auto reconfiguration. The original default
2098 interface and route table will be removed as the default.
2099
2100 @param[in] Context The IP4 service binding instance.
2101
2102**/
2103VOID
2104EFIAPI
2105Ip4AutoReconfigCallBackDpc (
2106 IN VOID *Context
2107 )
2108{
2109 IP4_SERVICE *IpSb;
2110
2111 IpSb = (IP4_SERVICE *)Context;
2112 NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);
2113
2114 if (IpSb->State > IP4_SERVICE_UNSTARTED) {
2115 IpSb->State = IP4_SERVICE_UNSTARTED;
2116 }
2117
2118 IpSb->Reconfig = TRUE;
2119
2120 Ip4StartAutoConfig (&IpSb->Ip4Config2Instance);
2121
2122 return;
2123}
2124
2125/**
2126 Request Ip4AutoReconfigCallBackDpc as a DPC at TPL_CALLBACK.
2127
2128 @param Event The event that is signalled.
2129 @param Context The IP4 service binding instance.
2130
2131**/
2132VOID
2133EFIAPI
2134Ip4AutoReconfigCallBack (
2135 IN EFI_EVENT Event,
2136 IN VOID *Context
2137 )
2138{
2139 //
2140 // Request Ip4AutoReconfigCallBackDpc as a DPC at TPL_CALLBACK
2141 //
2142 QueueDpc (TPL_CALLBACK, Ip4AutoReconfigCallBackDpc, Context);
2143}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette