VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Ip4Dxe/Ip4Config2Nv.c@ 85716

Last change on this file since 85716 was 80721, checked in by vboxsync, 5 years ago

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • Property svn:eol-style set to native
File size: 42.8 KB
Line 
1/** @file
2 Helper functions for configuring or getting the parameters relating to Ip4.
3
4Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "Ip4Impl.h"
10
11CHAR16 mIp4Config2StorageName[] = L"IP4_CONFIG2_IFR_NVDATA";
12
13/**
14 Calculate the prefix length of the IPv4 subnet mask.
15
16 @param[in] SubnetMask The IPv4 subnet mask.
17
18 @return The prefix length of the subnet mask.
19 @retval 0 Other errors as indicated.
20
21**/
22UINT8
23GetSubnetMaskPrefixLength (
24 IN EFI_IPv4_ADDRESS *SubnetMask
25 )
26{
27 UINT8 Len;
28 UINT32 ReverseMask;
29
30 //
31 // The SubnetMask is in network byte order.
32 //
33 ReverseMask = SwapBytes32 (*(UINT32 *)&SubnetMask[0]);
34
35 //
36 // Reverse it.
37 //
38 ReverseMask = ~ReverseMask;
39
40 if ((ReverseMask & (ReverseMask + 1)) != 0) {
41 return 0;
42 }
43
44 Len = 0;
45
46 while (ReverseMask != 0) {
47 ReverseMask = ReverseMask >> 1;
48 Len++;
49 }
50
51 return (UINT8) (32 - Len);
52}
53
54/**
55 Convert the decimal dotted IPv4 address into the binary IPv4 address.
56
57 @param[in] Str The UNICODE string.
58 @param[out] Ip The storage to return the IPv4 address.
59
60 @retval EFI_SUCCESS The binary IP address is returned in Ip.
61 @retval EFI_INVALID_PARAMETER The IP string is malformatted.
62
63**/
64EFI_STATUS
65Ip4Config2StrToIp (
66 IN CHAR16 *Str,
67 OUT EFI_IPv4_ADDRESS *Ip
68 )
69{
70 UINTN Index;
71 UINTN Number;
72
73 Index = 0;
74
75 while (*Str != L'\0') {
76
77 if (Index > 3) {
78 return EFI_INVALID_PARAMETER;
79 }
80
81 Number = 0;
82 while ((*Str >= L'0') && (*Str <= L'9')) {
83 Number = Number * 10 + (*Str - L'0');
84 Str++;
85 }
86
87 if (Number > 0xFF) {
88 return EFI_INVALID_PARAMETER;
89 }
90
91 Ip->Addr[Index] = (UINT8) Number;
92
93 if ((*Str != L'\0') && (*Str != L'.')) {
94 //
95 // The current character should be either the NULL terminator or
96 // the dot delimiter.
97 //
98 return EFI_INVALID_PARAMETER;
99 }
100
101 if (*Str == L'.') {
102 //
103 // Skip the delimiter.
104 //
105 Str++;
106 }
107
108 Index++;
109 }
110
111 if (Index != 4) {
112 return EFI_INVALID_PARAMETER;
113 }
114
115 return EFI_SUCCESS;
116}
117
118/**
119 Convert the decimal dotted IPv4 addresses separated by space into the binary IPv4 address list.
120
121 @param[in] Str The UNICODE string contains IPv4 addresses.
122 @param[out] PtrIpList The storage to return the IPv4 address list.
123 @param[out] IpCount The size of the IPv4 address list.
124
125 @retval EFI_SUCCESS The binary IP address list is returned in PtrIpList.
126 @retval EFI_OUT_OF_RESOURCES Error occurs in allocating memory.
127 @retval EFI_INVALID_PARAMETER The IP string is malformatted.
128
129**/
130EFI_STATUS
131Ip4Config2StrToIpList (
132 IN CHAR16 *Str,
133 OUT EFI_IPv4_ADDRESS **PtrIpList,
134 OUT UINTN *IpCount
135 )
136{
137 UINTN BeginIndex;
138 UINTN EndIndex;
139 UINTN Index;
140 UINTN IpIndex;
141 CHAR16 *StrTemp;
142 BOOLEAN SpaceTag;
143
144 BeginIndex = 0;
145 EndIndex = BeginIndex;
146 Index = 0;
147 IpIndex = 0;
148 StrTemp = NULL;
149 SpaceTag = TRUE;
150
151 *PtrIpList = NULL;
152 *IpCount = 0;
153
154 if (Str == NULL) {
155 return EFI_SUCCESS;
156 }
157
158 //
159 // Get the number of Ip.
160 //
161 while (*(Str + Index) != L'\0') {
162 if (*(Str + Index) == L' ') {
163 SpaceTag = TRUE;
164 } else {
165 if (SpaceTag) {
166 (*IpCount)++;
167 SpaceTag = FALSE;
168 }
169 }
170
171 Index++;
172 }
173
174 if (*IpCount == 0) {
175 return EFI_SUCCESS;
176 }
177
178 //
179 // Allocate buffer for IpList.
180 //
181 *PtrIpList = AllocateZeroPool(*IpCount * sizeof(EFI_IPv4_ADDRESS));
182 if (*PtrIpList == NULL) {
183 return EFI_OUT_OF_RESOURCES;
184 }
185
186 //
187 // Get IpList from Str.
188 //
189 Index = 0;
190 while (*(Str + Index) != L'\0') {
191 if (*(Str + Index) == L' ') {
192 if(!SpaceTag) {
193 StrTemp = AllocateZeroPool((EndIndex - BeginIndex + 1) * sizeof(CHAR16));
194 if (StrTemp == NULL) {
195 FreePool(*PtrIpList);
196 *PtrIpList = NULL;
197 *IpCount = 0;
198 return EFI_OUT_OF_RESOURCES;
199 }
200
201 CopyMem (StrTemp, Str + BeginIndex, (EndIndex - BeginIndex) * sizeof(CHAR16));
202 *(StrTemp + (EndIndex - BeginIndex)) = L'\0';
203
204 if (Ip4Config2StrToIp (StrTemp, &((*PtrIpList)[IpIndex])) != EFI_SUCCESS) {
205 FreePool(StrTemp);
206 FreePool(*PtrIpList);
207 *PtrIpList = NULL;
208 *IpCount = 0;
209 return EFI_INVALID_PARAMETER;
210 }
211
212 BeginIndex = EndIndex;
213 IpIndex++;
214
215 FreePool(StrTemp);
216 }
217
218 BeginIndex++;
219 EndIndex++;
220 SpaceTag = TRUE;
221 } else {
222 EndIndex++;
223 SpaceTag = FALSE;
224 }
225
226 Index++;
227
228 if (*(Str + Index) == L'\0') {
229 if (!SpaceTag) {
230 StrTemp = AllocateZeroPool((EndIndex - BeginIndex + 1) * sizeof(CHAR16));
231 if (StrTemp == NULL) {
232 FreePool(*PtrIpList);
233 *PtrIpList = NULL;
234 *IpCount = 0;
235 return EFI_OUT_OF_RESOURCES;
236 }
237
238 CopyMem (StrTemp, Str + BeginIndex, (EndIndex - BeginIndex) * sizeof(CHAR16));
239 *(StrTemp + (EndIndex - BeginIndex)) = L'\0';
240
241 if (Ip4Config2StrToIp (StrTemp, &((*PtrIpList)[IpIndex])) != EFI_SUCCESS) {
242 FreePool(StrTemp);
243 FreePool(*PtrIpList);
244 *PtrIpList = NULL;
245 *IpCount = 0;
246 return EFI_INVALID_PARAMETER;
247 }
248
249 FreePool(StrTemp);
250 }
251 }
252 }
253
254 return EFI_SUCCESS;
255}
256
257/**
258 Convert the IPv4 address into a dotted string.
259
260 @param[in] Ip The IPv4 address.
261 @param[out] Str The dotted IP string.
262
263**/
264VOID
265Ip4Config2IpToStr (
266 IN EFI_IPv4_ADDRESS *Ip,
267 OUT CHAR16 *Str
268 )
269{
270 UnicodeSPrint (
271 Str,
272 2 * IP4_STR_MAX_SIZE,
273 L"%d.%d.%d.%d",
274 Ip->Addr[0],
275 Ip->Addr[1],
276 Ip->Addr[2],
277 Ip->Addr[3]
278 );
279}
280
281
282/**
283 Convert the IPv4 address list into string consists of several decimal
284 dotted IPv4 addresses separated by space.
285
286 @param[in] Ip The IPv4 address list.
287 @param[in] IpCount The size of IPv4 address list.
288 @param[out] Str The string contains several decimal dotted
289 IPv4 addresses separated by space.
290
291 @retval EFI_SUCCESS Operation is success.
292 @retval EFI_OUT_OF_RESOURCES Error occurs in allocating memory.
293
294**/
295EFI_STATUS
296Ip4Config2IpListToStr (
297 IN EFI_IPv4_ADDRESS *Ip,
298 IN UINTN IpCount,
299 OUT CHAR16 *Str
300 )
301{
302 UINTN Index;
303 UINTN TemIndex;
304 UINTN StrIndex;
305 CHAR16 *TempStr;
306 EFI_IPv4_ADDRESS *TempIp;
307
308 Index = 0;
309 TemIndex = 0;
310 StrIndex = 0;
311 TempStr = NULL;
312 TempIp = NULL;
313
314 for (Index = 0; Index < IpCount; Index ++) {
315 TempIp = Ip + Index;
316 if (TempStr == NULL) {
317 TempStr = AllocateZeroPool(2 * IP4_STR_MAX_SIZE);
318 if (TempStr == NULL) {
319 return EFI_OUT_OF_RESOURCES;
320 }
321 }
322
323 UnicodeSPrint (
324 TempStr,
325 2 * IP4_STR_MAX_SIZE,
326 L"%d.%d.%d.%d",
327 TempIp->Addr[0],
328 TempIp->Addr[1],
329 TempIp->Addr[2],
330 TempIp->Addr[3]
331 );
332
333 for (TemIndex = 0; TemIndex < IP4_STR_MAX_SIZE; TemIndex ++) {
334 if (*(TempStr + TemIndex) == L'\0') {
335 if (Index == IpCount - 1) {
336 Str[StrIndex++] = L'\0';
337 } else {
338 Str[StrIndex++] = L' ';
339 }
340 break;
341 } else {
342 Str[StrIndex++] = *(TempStr + TemIndex);
343 }
344 }
345 }
346
347 if (TempStr != NULL) {
348 FreePool(TempStr);
349 }
350
351 return EFI_SUCCESS;
352}
353
354/**
355 The notify function of create event when performing a manual configuration.
356
357 @param[in] Event The pointer of Event.
358 @param[in] Context The pointer of Context.
359
360**/
361VOID
362EFIAPI
363Ip4Config2ManualAddressNotify (
364 IN EFI_EVENT Event,
365 IN VOID *Context
366 )
367{
368 *((BOOLEAN *) Context) = TRUE;
369}
370
371/**
372 Convert the network configuration data into the IFR data.
373
374 @param[in] Instance The IP4 config2 instance.
375 @param[in, out] IfrNvData The IFR nv data.
376
377 @retval EFI_SUCCESS The configure parameter to IFR data was
378 set successfully.
379 @retval EFI_INVALID_PARAMETER Source instance or target IFR data is not available.
380 @retval Others Other errors as indicated.
381
382**/
383EFI_STATUS
384Ip4Config2ConvertConfigNvDataToIfrNvData (
385 IN IP4_CONFIG2_INSTANCE *Instance,
386 IN OUT IP4_CONFIG2_IFR_NVDATA *IfrNvData
387 )
388{
389 IP4_SERVICE *IpSb;
390 EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;
391 EFI_IP4_CONFIG2_INTERFACE_INFO *Ip4Info;
392 EFI_IP4_CONFIG2_POLICY Policy;
393 UINTN DataSize;
394 UINTN GatewaySize;
395 EFI_IPv4_ADDRESS GatewayAddress;
396 EFI_STATUS Status;
397 UINTN DnsSize;
398 UINTN DnsCount;
399 EFI_IPv4_ADDRESS *DnsAddress;
400
401 Status = EFI_SUCCESS;
402 Ip4Config2 = &Instance->Ip4Config2;
403 Ip4Info = NULL;
404 DnsAddress = NULL;
405 GatewaySize = sizeof (EFI_IPv4_ADDRESS);
406
407 if ((IfrNvData == NULL) || (Instance == NULL)) {
408 return EFI_INVALID_PARAMETER;
409 }
410
411 NET_CHECK_SIGNATURE (Instance, IP4_CONFIG2_INSTANCE_SIGNATURE);
412
413 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
414
415 if (IpSb->DefaultInterface->Configured) {
416 IfrNvData->Configure = 1;
417 } else {
418 IfrNvData->Configure = 0;
419 goto Exit;
420 }
421
422 //
423 // Get the Policy info.
424 //
425 DataSize = sizeof (EFI_IP4_CONFIG2_POLICY);
426 Status = Ip4Config2->GetData (
427 Ip4Config2,
428 Ip4Config2DataTypePolicy,
429 &DataSize,
430 &Policy
431 );
432 if (EFI_ERROR (Status)) {
433 goto Exit;
434 }
435
436 if (Policy == Ip4Config2PolicyStatic) {
437 IfrNvData->DhcpEnable = FALSE;
438 } else if (Policy == Ip4Config2PolicyDhcp) {
439 IfrNvData->DhcpEnable = TRUE;
440 goto Exit;
441 }
442
443 //
444 // Get the interface info.
445 //
446 DataSize = 0;
447 Status = Ip4Config2->GetData (
448 Ip4Config2,
449 Ip4Config2DataTypeInterfaceInfo,
450 &DataSize,
451 NULL
452 );
453 if (Status != EFI_BUFFER_TOO_SMALL) {
454 return Status;
455 }
456
457 Ip4Info = AllocateZeroPool (DataSize);
458 if (Ip4Info == NULL) {
459 Status = EFI_OUT_OF_RESOURCES;
460 return Status;
461 }
462
463 Status = Ip4Config2->GetData (
464 Ip4Config2,
465 Ip4Config2DataTypeInterfaceInfo,
466 &DataSize,
467 Ip4Info
468 );
469 if (EFI_ERROR (Status)) {
470 goto Exit;
471 }
472
473 //
474 // Get the Gateway info.
475 //
476 Status = Ip4Config2->GetData (
477 Ip4Config2,
478 Ip4Config2DataTypeGateway,
479 &GatewaySize,
480 &GatewayAddress
481 );
482 if (EFI_ERROR (Status)) {
483 goto Exit;
484 }
485
486 //
487 // Get the Dns info.
488 //
489 DnsSize = 0;
490 Status = Ip4Config2->GetData (
491 Ip4Config2,
492 Ip4Config2DataTypeDnsServer,
493 &DnsSize,
494 NULL
495 );
496 if ((Status != EFI_BUFFER_TOO_SMALL) && (Status != EFI_NOT_FOUND)) {
497 goto Exit;
498 }
499
500 DnsCount = (UINT32) (DnsSize / sizeof (EFI_IPv4_ADDRESS));
501
502 if (DnsSize > 0) {
503 DnsAddress = AllocateZeroPool(DnsSize);
504 if (DnsAddress == NULL) {
505 Status = EFI_OUT_OF_RESOURCES;
506 goto Exit;
507 }
508
509 Status = Ip4Config2->GetData (
510 Ip4Config2,
511 Ip4Config2DataTypeDnsServer,
512 &DnsSize,
513 DnsAddress
514 );
515 if (EFI_ERROR (Status)) {
516 goto Exit;
517 }
518 }
519
520 Ip4Config2IpToStr (&Ip4Info->StationAddress, IfrNvData->StationAddress);
521 Ip4Config2IpToStr (&Ip4Info->SubnetMask, IfrNvData->SubnetMask);
522 Ip4Config2IpToStr (&GatewayAddress, IfrNvData->GatewayAddress);
523 Status = Ip4Config2IpListToStr (DnsAddress, DnsCount, IfrNvData->DnsAddress);
524
525Exit:
526
527 if (DnsAddress != NULL) {
528 FreePool(DnsAddress);
529 }
530
531 if (Ip4Info != NULL) {
532 FreePool(Ip4Info);
533 }
534
535 return Status;
536}
537
538/**
539 Convert the IFR data into the network configuration data and set the IP
540 configure parameters for the NIC.
541
542 @param[in] IfrFormNvData The IFR NV data.
543 @param[in, out] Instance The IP4 config2 instance.
544
545 @retval EFI_SUCCESS The configure parameter for this NIC was
546 set successfully.
547 @retval EFI_INVALID_PARAMETER The address information for setting is invalid.
548 @retval Others Other errors as indicated.
549
550**/
551EFI_STATUS
552Ip4Config2ConvertIfrNvDataToConfigNvData (
553 IN IP4_CONFIG2_IFR_NVDATA *IfrFormNvData,
554 IN OUT IP4_CONFIG2_INSTANCE *Instance
555 )
556{
557 EFI_STATUS Status;
558 EFI_IP4_CONFIG2_PROTOCOL *Ip4Cfg2;
559 IP4_CONFIG2_NVDATA *Ip4NvData;
560
561 EFI_IP_ADDRESS StationAddress;
562 EFI_IP_ADDRESS SubnetMask;
563 EFI_IP_ADDRESS Gateway;
564 IP4_ADDR Ip;
565 EFI_IPv4_ADDRESS *DnsAddress;
566 UINTN DnsCount;
567 UINTN Index;
568
569 EFI_EVENT TimeoutEvent;
570 EFI_EVENT SetAddressEvent;
571 BOOLEAN IsAddressOk;
572 UINTN DataSize;
573 EFI_INPUT_KEY Key;
574
575 Status = EFI_SUCCESS;
576 Ip4Cfg2 = &Instance->Ip4Config2;
577 Ip4NvData = &Instance->Ip4NvData;
578
579 DnsCount = 0;
580 DnsAddress = NULL;
581
582 TimeoutEvent = NULL;
583 SetAddressEvent = NULL;
584
585
586
587 if (Instance == NULL || IfrFormNvData == NULL) {
588 return EFI_INVALID_PARAMETER;
589 }
590
591 if (IfrFormNvData->Configure != TRUE) {
592 return EFI_SUCCESS;
593 }
594
595 if (IfrFormNvData->DhcpEnable == TRUE) {
596 Ip4NvData->Policy = Ip4Config2PolicyDhcp;
597
598 Status = Ip4Cfg2->SetData (
599 Ip4Cfg2,
600 Ip4Config2DataTypePolicy,
601 sizeof (EFI_IP4_CONFIG2_POLICY),
602 &Ip4NvData->Policy
603 );
604 if (EFI_ERROR(Status)) {
605 return Status;
606 }
607 } else {
608 //
609 // Get Ip4NvData from IfrFormNvData if it is valid.
610 //
611 Ip4NvData->Policy = Ip4Config2PolicyStatic;
612
613 Status = Ip4Config2StrToIp (IfrFormNvData->SubnetMask, &SubnetMask.v4);
614 if (EFI_ERROR (Status) || ((SubnetMask.Addr[0] != 0) && (GetSubnetMaskPrefixLength (&SubnetMask.v4) == 0))) {
615 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Subnet Mask!", NULL);
616 return EFI_INVALID_PARAMETER;
617 }
618
619 Status = Ip4Config2StrToIp (IfrFormNvData->StationAddress, &StationAddress.v4);
620 if (EFI_ERROR (Status) ||
621 (SubnetMask.Addr[0] != 0 && !NetIp4IsUnicast (NTOHL (StationAddress.Addr[0]), NTOHL (SubnetMask.Addr[0]))) ||
622 !Ip4StationAddressValid (NTOHL (StationAddress.Addr[0]), NTOHL (SubnetMask.Addr[0]))) {
623 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid IP address!", NULL);
624 return EFI_INVALID_PARAMETER;
625 }
626
627 Status = Ip4Config2StrToIp (IfrFormNvData->GatewayAddress, &Gateway.v4);
628 if (EFI_ERROR (Status) ||
629 (Gateway.Addr[0] != 0 && SubnetMask.Addr[0] != 0 && !NetIp4IsUnicast (NTOHL (Gateway.Addr[0]), NTOHL (SubnetMask.Addr[0])))) {
630 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Gateway!", NULL);
631 return EFI_INVALID_PARAMETER;
632 }
633
634 Status = Ip4Config2StrToIpList (IfrFormNvData->DnsAddress, &DnsAddress, &DnsCount);
635 if (!EFI_ERROR (Status) && DnsCount > 0) {
636 for (Index = 0; Index < DnsCount; Index ++) {
637 CopyMem (&Ip, &DnsAddress[Index], sizeof (IP4_ADDR));
638 if (IP4_IS_UNSPECIFIED (NTOHL (Ip)) || IP4_IS_LOCAL_BROADCAST (NTOHL (Ip))) {
639 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Dns Server!", NULL);
640 FreePool(DnsAddress);
641 return EFI_INVALID_PARAMETER;
642 }
643 }
644 } else {
645 if (EFI_ERROR (Status)) {
646 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Dns Server!", NULL);
647 }
648 }
649
650 if (Ip4NvData->ManualAddress != NULL) {
651 FreePool(Ip4NvData->ManualAddress);
652 }
653 Ip4NvData->ManualAddressCount = 1;
654 Ip4NvData->ManualAddress = AllocateZeroPool(sizeof(EFI_IP4_CONFIG2_MANUAL_ADDRESS));
655 if (Ip4NvData->ManualAddress == NULL) {
656 if (DnsAddress != NULL) {
657 FreePool(DnsAddress);
658 }
659
660 return EFI_OUT_OF_RESOURCES;
661 }
662 CopyMem(&Ip4NvData->ManualAddress->Address, &StationAddress.v4, sizeof(EFI_IPv4_ADDRESS));
663 CopyMem(&Ip4NvData->ManualAddress->SubnetMask, &SubnetMask.v4, sizeof(EFI_IPv4_ADDRESS));
664
665 if (Ip4NvData->GatewayAddress != NULL) {
666 FreePool(Ip4NvData->GatewayAddress);
667 }
668 Ip4NvData->GatewayAddressCount = 1;
669 Ip4NvData->GatewayAddress = AllocateZeroPool(sizeof(EFI_IPv4_ADDRESS));
670 if (Ip4NvData->GatewayAddress == NULL) {
671 if (DnsAddress != NULL) {
672 FreePool(DnsAddress);
673 }
674 return EFI_OUT_OF_RESOURCES;
675 }
676 CopyMem(Ip4NvData->GatewayAddress, &Gateway.v4, sizeof(EFI_IPv4_ADDRESS));
677
678 if (Ip4NvData->DnsAddress != NULL) {
679 FreePool(Ip4NvData->DnsAddress);
680 }
681 Ip4NvData->DnsAddressCount = (UINT32) DnsCount;
682 Ip4NvData->DnsAddress = DnsAddress;
683
684 //
685 // Setting Ip4NvData.
686 //
687 Status = Ip4Cfg2->SetData (
688 Ip4Cfg2,
689 Ip4Config2DataTypePolicy,
690 sizeof (EFI_IP4_CONFIG2_POLICY),
691 &Ip4NvData->Policy
692 );
693 if (EFI_ERROR(Status)) {
694 return Status;
695 }
696
697 //
698 // Create events & timers for asynchronous settings.
699 //
700 Status = gBS->CreateEvent (
701 EVT_TIMER,
702 TPL_CALLBACK,
703 NULL,
704 NULL,
705 &TimeoutEvent
706 );
707 if (EFI_ERROR (Status)) {
708 return EFI_OUT_OF_RESOURCES;
709 }
710
711 Status = gBS->CreateEvent (
712 EVT_NOTIFY_SIGNAL,
713 TPL_NOTIFY,
714 Ip4Config2ManualAddressNotify,
715 &IsAddressOk,
716 &SetAddressEvent
717 );
718 if (EFI_ERROR (Status)) {
719 goto Exit;
720 }
721
722 IsAddressOk = FALSE;
723
724 Status = Ip4Cfg2->RegisterDataNotify (
725 Ip4Cfg2,
726 Ip4Config2DataTypeManualAddress,
727 SetAddressEvent
728 );
729 if (EFI_ERROR (Status)) {
730 goto Exit;
731 }
732
733 //
734 // Set ManualAddress.
735 //
736 DataSize = Ip4NvData->ManualAddressCount * sizeof (EFI_IP4_CONFIG2_MANUAL_ADDRESS);
737 Status = Ip4Cfg2->SetData (
738 Ip4Cfg2,
739 Ip4Config2DataTypeManualAddress,
740 DataSize,
741 (VOID *) Ip4NvData->ManualAddress
742 );
743
744 if (Status == EFI_NOT_READY) {
745 gBS->SetTimer (TimeoutEvent, TimerRelative, 50000000);
746 while (EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
747 if (IsAddressOk) {
748 Status = EFI_SUCCESS;
749 break;
750 }
751 }
752 }
753
754 Ip4Cfg2->UnregisterDataNotify (
755 Ip4Cfg2,
756 Ip4Config2DataTypeManualAddress,
757 SetAddressEvent
758 );
759 if (EFI_ERROR (Status)) {
760 goto Exit;
761 }
762
763 //
764 // Set gateway.
765 //
766 DataSize = Ip4NvData->GatewayAddressCount * sizeof (EFI_IPv4_ADDRESS);
767 Status = Ip4Cfg2->SetData (
768 Ip4Cfg2,
769 Ip4Config2DataTypeGateway,
770 DataSize,
771 Ip4NvData->GatewayAddress
772 );
773 if (EFI_ERROR (Status)) {
774 goto Exit;
775 }
776
777 //
778 // Set DNS addresses.
779 //
780 if (Ip4NvData->DnsAddressCount > 0 && Ip4NvData->DnsAddress != NULL) {
781 DataSize = Ip4NvData->DnsAddressCount * sizeof (EFI_IPv4_ADDRESS);
782 Status = Ip4Cfg2->SetData (
783 Ip4Cfg2,
784 Ip4Config2DataTypeDnsServer,
785 DataSize,
786 Ip4NvData->DnsAddress
787 );
788
789 if (EFI_ERROR (Status)) {
790 goto Exit;
791 }
792 }
793 }
794
795Exit:
796 if (SetAddressEvent != NULL) {
797 gBS->CloseEvent (SetAddressEvent);
798 }
799
800 if (TimeoutEvent != NULL) {
801 gBS->CloseEvent (TimeoutEvent);
802 }
803
804 return Status;
805}
806
807/**
808 This function allows the caller to request the current
809 configuration for one or more named elements. The resulting
810 string is in <ConfigAltResp> format. Any and all alternative
811 configuration strings shall also be appended to the end of the
812 current configuration string. If they are, they must appear
813 after the current configuration. They must contain the same
814 routing (GUID, NAME, PATH) as the current configuration string.
815 They must have an additional description indicating the type of
816 alternative configuration the string represents,
817 "ALTCFG=<StringToken>". That <StringToken> (when
818 converted from Hex UNICODE to binary) is a reference to a
819 string in the associated string pack.
820
821 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
822 @param[in] Request A null-terminated Unicode string in
823 <ConfigRequest> format. Note that this
824 includes the routing information as well as
825 the configurable name / value pairs. It is
826 invalid for this string to be in
827 <MultiConfigRequest> format.
828 @param[out] Progress On return, points to a character in the
829 Request string. Points to the string's null
830 terminator if request was successful. Points
831 to the most recent "&" before the first
832 failing name / value pair (or the beginning
833 of the string if the failure is in the first
834 name / value pair) if the request was not
835 successful.
836 @param[out] Results A null-terminated Unicode string in
837 <ConfigAltResp> format which has all values
838 filled in for the names in the Request string.
839 String to be allocated by the called function.
840
841 @retval EFI_SUCCESS The Results string is filled with the
842 values corresponding to all requested
843 names.
844 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the
845 parts of the results that must be
846 stored awaiting possible future
847 protocols.
848 @retval EFI_NOT_FOUND Routing data doesn't match any
849 known driver. Progress set to the
850 first character in the routing header.
851 Note: There is no requirement that the
852 driver validate the routing data. It
853 must skip the <ConfigHdr> in order to
854 process the names.
855 @retval EFI_INVALID_PARAMETER Illegal syntax. Progress set
856 to most recent & before the
857 error or the beginning of the
858 string.
859 @retval EFI_INVALID_PARAMETER Unknown name. Progress points
860 to the & before the name in
861 question.Currently not implemented.
862**/
863EFI_STATUS
864EFIAPI
865Ip4FormExtractConfig (
866 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
867 IN CONST EFI_STRING Request,
868 OUT EFI_STRING *Progress,
869 OUT EFI_STRING *Results
870 )
871{
872 EFI_STATUS Status;
873 IP4_CONFIG2_INSTANCE *Ip4Config2Instance;
874 IP4_FORM_CALLBACK_INFO *Private;
875 IP4_CONFIG2_IFR_NVDATA *IfrFormNvData;
876 EFI_STRING ConfigRequestHdr;
877 EFI_STRING ConfigRequest;
878 BOOLEAN AllocatedRequest;
879 EFI_STRING FormResult;
880 UINTN Size;
881 UINTN BufferSize;
882
883 if (Progress == NULL || Results == NULL) {
884 return EFI_INVALID_PARAMETER;
885 }
886
887 Status = EFI_SUCCESS;
888 IfrFormNvData = NULL;
889 ConfigRequest = NULL;
890 FormResult = NULL;
891 Size = 0;
892 AllocatedRequest = FALSE;
893 ConfigRequest = Request;
894 Private = IP4_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS(This);
895 Ip4Config2Instance = IP4_CONFIG2_INSTANCE_FROM_FORM_CALLBACK(Private);
896 BufferSize = sizeof (IP4_CONFIG2_IFR_NVDATA);
897 *Progress = Request;
898
899 //
900 // Check Request data in <ConfigHdr>.
901 //
902 if ((Request == NULL) || HiiIsConfigHdrMatch (Request, &gIp4Config2NvDataGuid, mIp4Config2StorageName)) {
903 IfrFormNvData = AllocateZeroPool (sizeof (IP4_CONFIG2_IFR_NVDATA));
904 if (IfrFormNvData == NULL) {
905 return EFI_OUT_OF_RESOURCES;
906 }
907
908 Ip4Config2ConvertConfigNvDataToIfrNvData (Ip4Config2Instance, IfrFormNvData);
909
910 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
911 //
912 // Request has no request element, construct full request string.
913 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
914 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
915 //
916 ConfigRequestHdr = HiiConstructConfigHdr (&gIp4Config2NvDataGuid, mIp4Config2StorageName, Private->ChildHandle);
917 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
918 ConfigRequest = AllocateZeroPool (Size);
919 if (ConfigRequest == NULL) {
920 Status = EFI_OUT_OF_RESOURCES;
921 goto Failure;
922 }
923 AllocatedRequest = TRUE;
924
925 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
926 FreePool (ConfigRequestHdr);
927 }
928
929 //
930 // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
931 //
932 Status = gHiiConfigRouting->BlockToConfig (
933 gHiiConfigRouting,
934 ConfigRequest,
935 (UINT8 *) IfrFormNvData,
936 BufferSize,
937 &FormResult,
938 Progress
939 );
940
941 FreePool (IfrFormNvData);
942
943 //
944 // Free the allocated config request string.
945 //
946 if (AllocatedRequest) {
947 FreePool (ConfigRequest);
948 ConfigRequest = NULL;
949 }
950
951 if (EFI_ERROR (Status)) {
952 goto Failure;
953 }
954 }
955
956 if (Request == NULL || HiiIsConfigHdrMatch (Request, &gIp4Config2NvDataGuid, mIp4Config2StorageName)) {
957 *Results = FormResult;
958 } else {
959 return EFI_NOT_FOUND;
960 }
961
962Failure:
963 //
964 // Set Progress string to the original request string.
965 //
966 if (Request == NULL) {
967 *Progress = NULL;
968 } else if (StrStr (Request, L"OFFSET") == NULL) {
969 *Progress = Request + StrLen (Request);
970 }
971
972 return Status;
973}
974
975/**
976 This function applies changes in a driver's configuration.
977 Input is a Configuration, which has the routing data for this
978 driver followed by name / value configuration pairs. The driver
979 must apply those pairs to its configurable storage. If the
980 driver's configuration is stored in a linear block of data
981 and the driver's name / value pairs are in <BlockConfig>
982 format, it may use the ConfigToBlock helper function (above) to
983 simplify the job. Currently not implemented.
984
985 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
986 @param[in] Configuration A null-terminated Unicode string in
987 <ConfigString> format.
988 @param[out] Progress A pointer to a string filled in with the
989 offset of the most recent '&' before the
990 first failing name / value pair (or the
991 beginn ing of the string if the failure
992 is in the first name / value pair) or
993 the terminating NULL if all was
994 successful.
995
996 @retval EFI_SUCCESS The results have been distributed or are
997 awaiting distribution.
998 @retval EFI_OUT_OF_MEMORY Not enough memory to store the
999 parts of the results that must be
1000 stored awaiting possible future
1001 protocols.
1002 @retval EFI_INVALID_PARAMETERS Passing in a NULL for the
1003 Results parameter would result
1004 in this type of error.
1005 @retval EFI_NOT_FOUND Target for the specified routing data
1006 was not found.
1007**/
1008EFI_STATUS
1009EFIAPI
1010Ip4FormRouteConfig (
1011 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1012 IN CONST EFI_STRING Configuration,
1013 OUT EFI_STRING *Progress
1014 )
1015{
1016 EFI_STATUS Status;
1017 UINTN BufferSize;
1018 IP4_CONFIG2_IFR_NVDATA *IfrFormNvData;
1019 IP4_CONFIG2_INSTANCE *Ip4Config2Instance;
1020 IP4_FORM_CALLBACK_INFO *Private;
1021
1022 Status = EFI_SUCCESS;
1023 IfrFormNvData = NULL;
1024
1025 if (Configuration == NULL || Progress == NULL) {
1026 return EFI_INVALID_PARAMETER;
1027 }
1028
1029 *Progress = Configuration;
1030
1031 Private = IP4_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS(This);
1032 Ip4Config2Instance = IP4_CONFIG2_INSTANCE_FROM_FORM_CALLBACK(Private);
1033
1034 //
1035 // Check Routing data in <ConfigHdr>.
1036 //
1037 if (HiiIsConfigHdrMatch (Configuration, &gIp4Config2NvDataGuid, mIp4Config2StorageName)) {
1038 //
1039 // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
1040 //
1041 IfrFormNvData = AllocateZeroPool (sizeof (IP4_CONFIG2_IFR_NVDATA));
1042 if (IfrFormNvData == NULL) {
1043 return EFI_OUT_OF_RESOURCES;
1044 }
1045
1046 BufferSize = 0;
1047
1048 Status = gHiiConfigRouting->ConfigToBlock (
1049 gHiiConfigRouting,
1050 Configuration,
1051 (UINT8 *) IfrFormNvData,
1052 &BufferSize,
1053 Progress
1054 );
1055 if (Status != EFI_BUFFER_TOO_SMALL) {
1056 return Status;
1057 }
1058
1059 Status = gHiiConfigRouting->ConfigToBlock (
1060 gHiiConfigRouting,
1061 Configuration,
1062 (UINT8 *) IfrFormNvData,
1063 &BufferSize,
1064 Progress
1065 );
1066 if (!EFI_ERROR (Status)) {
1067 Status = Ip4Config2ConvertIfrNvDataToConfigNvData (IfrFormNvData, Ip4Config2Instance);
1068 }
1069
1070 FreePool (IfrFormNvData);
1071 } else {
1072 return EFI_NOT_FOUND;
1073 }
1074
1075 return Status;
1076
1077}
1078
1079/**
1080 This function is called to provide results data to the driver.
1081 This data consists of a unique key that is used to identify
1082 which data is either being passed back or being asked for.
1083
1084 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1085 @param[in] Action Specifies the type of action taken by the browser.
1086 @param[in] QuestionId A unique value which is sent to the original
1087 exporting driver so that it can identify the type
1088 of data to expect. The format of the data tends to
1089 vary based on the opcode that enerated the callback.
1090 @param[in] Type The type of value for the question.
1091 @param[in] Value A pointer to the data being sent to the original
1092 exporting driver.
1093 @param[out] ActionRequest On return, points to the action requested by the
1094 callback function.
1095
1096 @retval EFI_SUCCESS The callback successfully handled the action.
1097 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the
1098 variable and its data.
1099 @retval EFI_DEVICE_ERROR The variable could not be saved.
1100 @retval EFI_UNSUPPORTED The specified Action is not supported by the
1101 callback.Currently not implemented.
1102 @retval EFI_INVALID_PARAMETERS Passing in wrong parameter.
1103 @retval Others Other errors as indicated.
1104
1105**/
1106EFI_STATUS
1107EFIAPI
1108Ip4FormCallback (
1109 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
1110 IN EFI_BROWSER_ACTION Action,
1111 IN EFI_QUESTION_ID QuestionId,
1112 IN UINT8 Type,
1113 IN EFI_IFR_TYPE_VALUE *Value,
1114 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
1115 )
1116{
1117 EFI_STATUS Status;
1118 IP4_CONFIG2_INSTANCE *Instance;
1119 IP4_CONFIG2_IFR_NVDATA *IfrFormNvData;
1120 IP4_FORM_CALLBACK_INFO *Private;
1121
1122 EFI_IP_ADDRESS StationAddress;
1123 EFI_IP_ADDRESS SubnetMask;
1124 EFI_IP_ADDRESS Gateway;
1125 IP4_ADDR Ip;
1126 EFI_IPv4_ADDRESS *DnsAddress;
1127 UINTN DnsCount;
1128 UINTN Index;
1129 EFI_INPUT_KEY Key;
1130
1131 IfrFormNvData = NULL;
1132 DnsCount = 0;
1133 DnsAddress = NULL;
1134
1135 if (Action == EFI_BROWSER_ACTION_CHANGED) {
1136 Private = IP4_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS(This);
1137 Instance = IP4_CONFIG2_INSTANCE_FROM_FORM_CALLBACK(Private);
1138
1139 IfrFormNvData = AllocateZeroPool (sizeof (IP4_CONFIG2_IFR_NVDATA));
1140 if (IfrFormNvData == NULL) {
1141 return EFI_OUT_OF_RESOURCES;
1142 }
1143
1144 //
1145 // Retrieve uncommitted data from Browser
1146 //
1147 if (!HiiGetBrowserData (&gIp4Config2NvDataGuid, mIp4Config2StorageName, sizeof (IP4_CONFIG2_IFR_NVDATA), (UINT8 *) IfrFormNvData)) {
1148 FreePool (IfrFormNvData);
1149 return EFI_NOT_FOUND;
1150 }
1151
1152 Status = EFI_SUCCESS;
1153
1154 switch (QuestionId) {
1155 case KEY_LOCAL_IP:
1156 Status = Ip4Config2StrToIp (IfrFormNvData->StationAddress, &StationAddress.v4);
1157 if (EFI_ERROR (Status) || IP4_IS_UNSPECIFIED (NTOHL (StationAddress.Addr[0])) || IP4_IS_LOCAL_BROADCAST (NTOHL (StationAddress.Addr[0]))) {
1158 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid IP address!", NULL);
1159 Status = EFI_INVALID_PARAMETER;
1160 }
1161 break;
1162
1163 case KEY_SUBNET_MASK:
1164 Status = Ip4Config2StrToIp (IfrFormNvData->SubnetMask, &SubnetMask.v4);
1165 if (EFI_ERROR (Status) || ((SubnetMask.Addr[0] != 0) && (GetSubnetMaskPrefixLength (&SubnetMask.v4) == 0))) {
1166 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Subnet Mask!", NULL);
1167 Status = EFI_INVALID_PARAMETER;
1168 }
1169 break;
1170
1171 case KEY_GATE_WAY:
1172 Status = Ip4Config2StrToIp (IfrFormNvData->GatewayAddress, &Gateway.v4);
1173 if (EFI_ERROR (Status) || IP4_IS_LOCAL_BROADCAST(NTOHL(Gateway.Addr[0]))) {
1174 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Gateway!", NULL);
1175 Status = EFI_INVALID_PARAMETER;
1176 }
1177 break;
1178
1179 case KEY_DNS:
1180 Status = Ip4Config2StrToIpList (IfrFormNvData->DnsAddress, &DnsAddress, &DnsCount);
1181 if (!EFI_ERROR (Status) && DnsCount > 0) {
1182 for (Index = 0; Index < DnsCount; Index ++) {
1183 CopyMem (&Ip, &DnsAddress[Index], sizeof (IP4_ADDR));
1184 if (IP4_IS_UNSPECIFIED (NTOHL (Ip)) || IP4_IS_LOCAL_BROADCAST (NTOHL (Ip))) {
1185 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Dns Server!", NULL);
1186 Status = EFI_INVALID_PARAMETER;
1187 break;
1188 }
1189 }
1190 } else {
1191 if (EFI_ERROR (Status)) {
1192 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Dns Server!", NULL);
1193 }
1194 }
1195
1196 if(DnsAddress != NULL) {
1197 FreePool(DnsAddress);
1198 }
1199 break;
1200
1201 case KEY_SAVE_CHANGES:
1202 Status = Ip4Config2ConvertIfrNvDataToConfigNvData (IfrFormNvData, Instance);
1203 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
1204 break;
1205
1206 default:
1207 break;
1208 }
1209
1210 FreePool (IfrFormNvData);
1211
1212 return Status;
1213 }
1214
1215 //
1216 // All other action return unsupported.
1217 //
1218 return EFI_UNSUPPORTED;
1219}
1220
1221/**
1222 Install HII Config Access protocol for network device and allocate resource.
1223
1224 @param[in, out] Instance The IP4 config2 Instance.
1225
1226 @retval EFI_SUCCESS The HII Config Access protocol is installed.
1227 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
1228 @retval Others Other errors as indicated.
1229
1230**/
1231EFI_STATUS
1232Ip4Config2FormInit (
1233 IN OUT IP4_CONFIG2_INSTANCE *Instance
1234 )
1235{
1236 EFI_STATUS Status;
1237 IP4_SERVICE *IpSb;
1238 IP4_FORM_CALLBACK_INFO *CallbackInfo;
1239 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;
1240 VENDOR_DEVICE_PATH VendorDeviceNode;
1241 EFI_SERVICE_BINDING_PROTOCOL *MnpSb;
1242 CHAR16 *MacString;
1243 CHAR16 MenuString[128];
1244 CHAR16 PortString[128];
1245 CHAR16 *OldMenuString;
1246 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
1247
1248 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1249 ASSERT (IpSb != NULL);
1250
1251 CallbackInfo = &Instance->CallbackInfo;
1252
1253 CallbackInfo->Signature = IP4_FORM_CALLBACK_INFO_SIGNATURE;
1254
1255 Status = gBS->HandleProtocol (
1256 IpSb->Controller,
1257 &gEfiDevicePathProtocolGuid,
1258 (VOID **) &ParentDevicePath
1259 );
1260 if (EFI_ERROR (Status)) {
1261 return Status;
1262 }
1263
1264 //
1265 // Construct device path node for EFI HII Config Access protocol,
1266 // which consists of controller physical device path and one hardware
1267 // vendor guid node.
1268 //
1269 ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH));
1270 VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH;
1271 VendorDeviceNode.Header.SubType = HW_VENDOR_DP;
1272
1273 CopyGuid (&VendorDeviceNode.Guid, &gEfiCallerIdGuid);
1274
1275 SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH));
1276 CallbackInfo->HiiVendorDevicePath = AppendDevicePathNode (
1277 ParentDevicePath,
1278 (EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode
1279 );
1280 if (CallbackInfo->HiiVendorDevicePath == NULL) {
1281 Status = EFI_OUT_OF_RESOURCES;
1282 goto Error;
1283 }
1284
1285 ConfigAccess = &CallbackInfo->HiiConfigAccessProtocol;
1286 ConfigAccess->ExtractConfig = Ip4FormExtractConfig;
1287 ConfigAccess->RouteConfig = Ip4FormRouteConfig;
1288 ConfigAccess->Callback = Ip4FormCallback;
1289
1290 //
1291 // Install Device Path Protocol and Config Access protocol on new handle
1292 //
1293 Status = gBS->InstallMultipleProtocolInterfaces (
1294 &CallbackInfo->ChildHandle,
1295 &gEfiDevicePathProtocolGuid,
1296 CallbackInfo->HiiVendorDevicePath,
1297 &gEfiHiiConfigAccessProtocolGuid,
1298 ConfigAccess,
1299 NULL
1300 );
1301
1302 if (!EFI_ERROR (Status)) {
1303 //
1304 // Open the Parent Handle for the child
1305 //
1306 Status = gBS->OpenProtocol (
1307 IpSb->Controller,
1308 &gEfiManagedNetworkServiceBindingProtocolGuid,
1309 (VOID **) &MnpSb,
1310 IpSb->Image,
1311 CallbackInfo->ChildHandle,
1312 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
1313 );
1314 }
1315
1316 if (EFI_ERROR (Status)) {
1317 goto Error;
1318 }
1319
1320 //
1321 // Publish our HII data
1322 //
1323 CallbackInfo->RegisteredHandle = HiiAddPackages (
1324 &gIp4Config2NvDataGuid,
1325 CallbackInfo->ChildHandle,
1326 Ip4DxeStrings,
1327 Ip4Config2Bin,
1328 NULL
1329 );
1330 if (CallbackInfo->RegisteredHandle == NULL) {
1331 Status = EFI_OUT_OF_RESOURCES;
1332 goto Error;
1333 }
1334
1335 //
1336 // Append MAC string in the menu help string and tile help string
1337 //
1338 Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &MacString);
1339 if (!EFI_ERROR (Status)) {
1340 OldMenuString = HiiGetString (
1341 CallbackInfo->RegisteredHandle,
1342 STRING_TOKEN (STR_IP4_CONFIG2_FORM_HELP),
1343 NULL
1344 );
1345 UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString);
1346 HiiSetString (
1347 CallbackInfo->RegisteredHandle,
1348 STRING_TOKEN (STR_IP4_CONFIG2_FORM_HELP),
1349 MenuString,
1350 NULL
1351 );
1352
1353 UnicodeSPrint (PortString, 128, L"MAC:%s", MacString);
1354 HiiSetString (
1355 CallbackInfo->RegisteredHandle,
1356 STRING_TOKEN (STR_IP4_DEVICE_FORM_HELP),
1357 PortString,
1358 NULL
1359 );
1360
1361 FreePool (MacString);
1362 FreePool (OldMenuString);
1363
1364 return EFI_SUCCESS;
1365 }
1366
1367Error:
1368 Ip4Config2FormUnload (Instance);
1369 return Status;
1370}
1371
1372/**
1373 Uninstall the HII Config Access protocol for network devices and free up the resources.
1374
1375 @param[in, out] Instance The IP4 config2 instance to unload a form.
1376
1377**/
1378VOID
1379Ip4Config2FormUnload (
1380 IN OUT IP4_CONFIG2_INSTANCE *Instance
1381 )
1382{
1383 IP4_SERVICE *IpSb;
1384 IP4_FORM_CALLBACK_INFO *CallbackInfo;
1385 IP4_CONFIG2_NVDATA *Ip4NvData;
1386
1387 IpSb = IP4_SERVICE_FROM_IP4_CONFIG2_INSTANCE (Instance);
1388 ASSERT (IpSb != NULL);
1389
1390 CallbackInfo = &Instance->CallbackInfo;
1391
1392 if (CallbackInfo->ChildHandle != NULL) {
1393 //
1394 // Close the child handle
1395 //
1396 gBS->CloseProtocol (
1397 IpSb->Controller,
1398 &gEfiManagedNetworkServiceBindingProtocolGuid,
1399 IpSb->Image,
1400 CallbackInfo->ChildHandle
1401 );
1402
1403 //
1404 // Uninstall EFI_HII_CONFIG_ACCESS_PROTOCOL
1405 //
1406 gBS->UninstallMultipleProtocolInterfaces (
1407 CallbackInfo->ChildHandle,
1408 &gEfiDevicePathProtocolGuid,
1409 CallbackInfo->HiiVendorDevicePath,
1410 &gEfiHiiConfigAccessProtocolGuid,
1411 &CallbackInfo->HiiConfigAccessProtocol,
1412 NULL
1413 );
1414 }
1415
1416 if (CallbackInfo->HiiVendorDevicePath != NULL) {
1417 FreePool (CallbackInfo->HiiVendorDevicePath);
1418 }
1419
1420 if (CallbackInfo->RegisteredHandle != NULL) {
1421 //
1422 // Remove HII package list
1423 //
1424 HiiRemovePackages (CallbackInfo->RegisteredHandle);
1425 }
1426
1427 Ip4NvData = &Instance->Ip4NvData;
1428
1429 if(Ip4NvData->ManualAddress != NULL) {
1430 FreePool(Ip4NvData->ManualAddress);
1431 }
1432
1433 if(Ip4NvData->GatewayAddress != NULL) {
1434 FreePool(Ip4NvData->GatewayAddress);
1435 }
1436
1437 if(Ip4NvData->DnsAddress != NULL) {
1438 FreePool(Ip4NvData->DnsAddress);
1439 }
1440
1441 Ip4NvData->ManualAddressCount = 0;
1442 Ip4NvData->GatewayAddressCount = 0;
1443 Ip4NvData->DnsAddressCount = 0;
1444}
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