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