]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/HiiDatabaseDxe/ConfigRouting.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg/RegularExpressionDxe:omit unused variable
[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / ConfigRouting.c
1 /** @file
2 Implementation of interfaces function for EFI_HII_CONFIG_ROUTING_PROTOCOL.
3
4 Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15
16 #include "HiiDatabase.h"
17 extern HII_DATABASE_PRIVATE_DATA mPrivate;
18
19 /**
20 Calculate the number of Unicode characters of the incoming Configuration string,
21 not including NULL terminator.
22
23 This is a internal function.
24
25 @param String String in <MultiConfigRequest> or
26 <MultiConfigResp> format.
27
28 @return The number of Unicode characters.
29
30 **/
31 UINTN
32 CalculateConfigStringLen (
33 IN EFI_STRING String
34 )
35 {
36 EFI_STRING TmpPtr;
37
38 //
39 // "GUID=" should be the first element of incoming string.
40 //
41 ASSERT (String != NULL);
42 ASSERT (StrnCmp (String, L"GUID=", StrLen (L"GUID=")) == 0);
43
44 //
45 // The beginning of next <ConfigRequest>/<ConfigResp> should be "&GUID=".
46 // Will meet '\0' if there is only one <ConfigRequest>/<ConfigResp>.
47 //
48 TmpPtr = StrStr (String, L"&GUID=");
49 if (TmpPtr == NULL) {
50 return StrLen (String);
51 }
52
53 return (TmpPtr - String);
54 }
55
56
57 /**
58 Convert the hex UNICODE %02x encoding of a UEFI device path to binary
59 from <PathHdr> of <ConfigHdr>.
60
61 This is a internal function.
62
63 @param String UEFI configuration string
64 @param DevicePathData Binary of a UEFI device path.
65
66 @retval EFI_NOT_FOUND The device path is not invalid.
67 @retval EFI_INVALID_PARAMETER Any incoming parameter is invalid.
68 @retval EFI_OUT_OF_RESOURCES Lake of resources to store necessary structures.
69 @retval EFI_SUCCESS The device path is retrieved and translated to
70 binary format.
71
72 **/
73 EFI_STATUS
74 GetDevicePath (
75 IN EFI_STRING String,
76 OUT UINT8 **DevicePathData
77 )
78 {
79 UINTN Length;
80 EFI_STRING PathHdr;
81 UINT8 *DevicePathBuffer;
82 CHAR16 TemStr[2];
83 UINTN Index;
84 UINT8 DigitUint8;
85 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
86
87
88 if (String == NULL || DevicePathData == NULL) {
89 return EFI_INVALID_PARAMETER;
90 }
91
92 //
93 // Find the 'PATH=' of <PathHdr> and skip it.
94 //
95 for (; (*String != 0 && StrnCmp (String, L"PATH=", StrLen (L"PATH=")) != 0); String++);
96 if (*String == 0) {
97 return EFI_INVALID_PARAMETER;
98 }
99 //
100 // Check whether path data does exist.
101 //
102 String += StrLen (L"PATH=");
103 if (*String == 0) {
104 return EFI_INVALID_PARAMETER;
105 }
106 PathHdr = String;
107
108 //
109 // The content between 'PATH=' of <ConfigHdr> and '&' of next element
110 // or '\0' (end of configuration string) is the UNICODE %02x bytes encoding
111 // of UEFI device path.
112 //
113 for (Length = 0; *String != 0 && *String != L'&'; String++, Length++);
114 //
115 // Check DevicePath Length
116 //
117 if (((Length + 1) / 2) < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
118 return EFI_NOT_FOUND;
119 }
120
121 //
122 // The data in <PathHdr> is encoded as hex UNICODE %02x bytes in the same order
123 // as the device path resides in RAM memory.
124 // Translate the data into binary.
125 //
126 DevicePathBuffer = (UINT8 *) AllocateZeroPool ((Length + 1) / 2);
127 if (DevicePathBuffer == NULL) {
128 return EFI_OUT_OF_RESOURCES;
129 }
130
131 //
132 // Convert DevicePath
133 //
134 ZeroMem (TemStr, sizeof (TemStr));
135 for (Index = 0; Index < Length; Index ++) {
136 TemStr[0] = PathHdr[Index];
137 DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
138 if ((Index & 1) == 0) {
139 DevicePathBuffer [Index/2] = DigitUint8;
140 } else {
141 DevicePathBuffer [Index/2] = (UINT8) ((DevicePathBuffer [Index/2] << 4) + DigitUint8);
142 }
143 }
144
145 //
146 // Validate DevicePath
147 //
148 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) DevicePathBuffer;
149 while (!IsDevicePathEnd (DevicePath)) {
150 if ((DevicePath->Type == 0) || (DevicePath->SubType == 0) || (DevicePathNodeLength (DevicePath) < sizeof (EFI_DEVICE_PATH_PROTOCOL))) {
151 //
152 // Invalid device path
153 //
154 FreePool (DevicePathBuffer);
155 return EFI_NOT_FOUND;
156 }
157 DevicePath = NextDevicePathNode (DevicePath);
158 }
159
160 //
161 // return the device path
162 //
163 *DevicePathData = DevicePathBuffer;
164 return EFI_SUCCESS;
165 }
166
167 /**
168 Converts the unicode character of the string from uppercase to lowercase.
169 This is a internal function.
170
171 @param ConfigString String to be converted
172
173 **/
174 VOID
175 EFIAPI
176 HiiToLower (
177 IN EFI_STRING ConfigString
178 )
179 {
180 EFI_STRING String;
181 BOOLEAN Lower;
182
183 ASSERT (ConfigString != NULL);
184
185 //
186 // Convert all hex digits in range [A-F] in the configuration header to [a-f]
187 //
188 for (String = ConfigString, Lower = FALSE; *String != L'\0'; String++) {
189 if (*String == L'=') {
190 Lower = TRUE;
191 } else if (*String == L'&') {
192 Lower = FALSE;
193 } else if (Lower && *String >= L'A' && *String <= L'F') {
194 *String = (CHAR16) (*String - L'A' + L'a');
195 }
196 }
197
198 return;
199 }
200
201 /**
202 Generate a sub string then output it.
203
204 This is a internal function.
205
206 @param String A constant string which is the prefix of the to be
207 generated string, e.g. GUID=
208
209 @param BufferLen The length of the Buffer in bytes.
210
211 @param Buffer Points to a buffer which will be converted to be the
212 content of the generated string.
213
214 @param Flag If 1, the buffer contains data for the value of GUID or PATH stored in
215 UINT8 *; if 2, the buffer contains unicode string for the value of NAME;
216 if 3, the buffer contains other data.
217
218 @param SubStr Points to the output string. It's caller's
219 responsibility to free this buffer.
220
221
222 **/
223 VOID
224 GenerateSubStr (
225 IN CONST EFI_STRING String,
226 IN UINTN BufferLen,
227 IN VOID *Buffer,
228 IN UINT8 Flag,
229 OUT EFI_STRING *SubStr
230 )
231 {
232 UINTN Length;
233 EFI_STRING Str;
234 EFI_STRING StringHeader;
235 CHAR16 *TemString;
236 CHAR16 *TemName;
237 UINT8 *TemBuffer;
238 UINTN Index;
239
240 ASSERT (String != NULL && SubStr != NULL);
241
242 if (Buffer == NULL) {
243 *SubStr = AllocateCopyPool (StrSize (String), String);
244 ASSERT (*SubStr != NULL);
245 return;
246 }
247
248 //
249 // Header + Data + '&' + '\0'
250 //
251 Length = StrLen (String) + BufferLen * 2 + 1 + 1;
252 Str = AllocateZeroPool (Length * sizeof (CHAR16));
253 ASSERT (Str != NULL);
254
255 StrCpyS (Str, Length, String);
256
257 StringHeader = Str + StrLen (String);
258 TemString = (CHAR16 *) StringHeader;
259
260 switch (Flag) {
261 case 1:
262 //
263 // Convert Buffer to Hex String in reverse order
264 //
265 TemBuffer = ((UINT8 *) Buffer);
266 for (Index = 0; Index < BufferLen; Index ++, TemBuffer ++) {
267 UnicodeValueToStringS (
268 TemString,
269 sizeof (CHAR16) * (Length - StrnLenS (Str, Length)),
270 PREFIX_ZERO | RADIX_HEX,
271 *TemBuffer,
272 2
273 );
274 TemString += StrnLenS (TemString, Length - StrnLenS (Str, Length));
275 }
276 break;
277 case 2:
278 //
279 // Check buffer is enough
280 //
281 TemName = (CHAR16 *) Buffer;
282 ASSERT ((BufferLen * 2 + 1) >= (StrLen (TemName) * 4 + 1));
283 //
284 // Convert Unicode String to Config String, e.g. "ABCD" => "0041004200430044"
285 //
286 for (; *TemName != L'\0'; TemName++) {
287 UnicodeValueToStringS (
288 TemString,
289 sizeof (CHAR16) * (Length - StrnLenS (Str, Length)),
290 PREFIX_ZERO | RADIX_HEX,
291 *TemName,
292 4
293 );
294 TemString += StrnLenS (TemString, Length - StrnLenS (Str, Length));
295 }
296 break;
297 case 3:
298 //
299 // Convert Buffer to Hex String
300 //
301 TemBuffer = ((UINT8 *) Buffer) + BufferLen - 1;
302 for (Index = 0; Index < BufferLen; Index ++, TemBuffer --) {
303 UnicodeValueToStringS (
304 TemString,
305 sizeof (CHAR16) * (Length - StrnLenS (Str, Length)),
306 PREFIX_ZERO | RADIX_HEX,
307 *TemBuffer,
308 2
309 );
310 TemString += StrnLenS (TemString, Length - StrnLenS (Str, Length));
311 }
312 break;
313 default:
314 break;
315 }
316
317 //
318 // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
319 //
320 StrCatS (Str, Length, L"&");
321 HiiToLower (Str);
322
323 *SubStr = Str;
324 }
325
326
327 /**
328 Retrieve the <ConfigBody> from String then output it.
329
330 This is a internal function.
331
332 @param String A sub string of a configuration string in
333 <MultiConfigAltResp> format.
334 @param ConfigBody Points to the output string. It's caller's
335 responsibility to free this buffer.
336
337 @retval EFI_INVALID_PARAMETER There is no form package in current hii database.
338 @retval EFI_OUT_OF_RESOURCES Not enough memory to finish this operation.
339 @retval EFI_SUCCESS All existing storage is exported.
340
341 **/
342 EFI_STATUS
343 OutputConfigBody (
344 IN EFI_STRING String,
345 OUT EFI_STRING *ConfigBody
346 )
347 {
348 EFI_STRING TmpPtr;
349 EFI_STRING Result;
350 UINTN Length;
351
352 if (String == NULL || ConfigBody == NULL) {
353 return EFI_INVALID_PARAMETER;
354 }
355
356 //
357 // The setting information should start OFFSET, not ALTCFG.
358 //
359 if (StrnCmp (String, L"&ALTCFG=", StrLen (L"&ALTCFG=")) == 0) {
360 return EFI_INVALID_PARAMETER;
361 }
362
363 TmpPtr = StrStr (String, L"GUID=");
364 if (TmpPtr == NULL) {
365 //
366 // It is the last <ConfigResp> of the incoming configuration string.
367 //
368 Result = AllocateCopyPool (StrSize (String), String);
369 if (Result == NULL) {
370 return EFI_OUT_OF_RESOURCES;
371 } else {
372 *ConfigBody = Result;
373 return EFI_SUCCESS;
374 }
375 }
376
377 Length = TmpPtr - String;
378 if (Length == 0) {
379 return EFI_NOT_FOUND;
380 }
381 Result = AllocateCopyPool (Length * sizeof (CHAR16), String);
382 if (Result == NULL) {
383 return EFI_OUT_OF_RESOURCES;
384 }
385
386 *(Result + Length - 1) = 0;
387 *ConfigBody = Result;
388 return EFI_SUCCESS;
389 }
390
391 /**
392 Append a string to a multi-string format.
393
394 This is a internal function.
395
396 @param MultiString String in <MultiConfigRequest>,
397 <MultiConfigAltResp>, or <MultiConfigResp>. On
398 input, the buffer length of this string is
399 MAX_STRING_LENGTH. On output, the buffer length
400 might be updated.
401 @param AppendString NULL-terminated Unicode string.
402
403 @retval EFI_INVALID_PARAMETER Any incoming parameter is invalid.
404 @retval EFI_SUCCESS AppendString is append to the end of MultiString
405
406 **/
407 EFI_STATUS
408 AppendToMultiString (
409 IN OUT EFI_STRING *MultiString,
410 IN EFI_STRING AppendString
411 )
412 {
413 UINTN AppendStringSize;
414 UINTN MultiStringSize;
415 UINTN MaxLen;
416
417 if (MultiString == NULL || *MultiString == NULL || AppendString == NULL) {
418 return EFI_INVALID_PARAMETER;
419 }
420
421 AppendStringSize = StrSize (AppendString);
422 MultiStringSize = StrSize (*MultiString);
423 MaxLen = MAX_STRING_LENGTH / sizeof (CHAR16);
424
425 //
426 // Enlarge the buffer each time when length exceeds MAX_STRING_LENGTH.
427 //
428 if (MultiStringSize + AppendStringSize > MAX_STRING_LENGTH ||
429 MultiStringSize > MAX_STRING_LENGTH) {
430 *MultiString = (EFI_STRING) ReallocatePool (
431 MultiStringSize,
432 MultiStringSize + AppendStringSize,
433 (VOID *) (*MultiString)
434 );
435 MaxLen = (MultiStringSize + AppendStringSize) / sizeof (CHAR16);
436 ASSERT (*MultiString != NULL);
437 }
438 //
439 // Append the incoming string
440 //
441 StrCatS (*MultiString, MaxLen, AppendString);
442
443 return EFI_SUCCESS;
444 }
445
446
447 /**
448 Get the value of <Number> in <BlockConfig> format, i.e. the value of OFFSET
449 or WIDTH or VALUE.
450 <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number>
451
452 This is a internal function.
453
454 @param StringPtr String in <BlockConfig> format and points to the
455 first character of <Number>.
456 @param Number The output value. Caller takes the responsibility
457 to free memory.
458 @param Len Length of the <Number>, in characters.
459
460 @retval EFI_OUT_OF_RESOURCES Insufficient resources to store necessary
461 structures.
462 @retval EFI_SUCCESS Value of <Number> is outputted in Number
463 successfully.
464
465 **/
466 EFI_STATUS
467 GetValueOfNumber (
468 IN EFI_STRING StringPtr,
469 OUT UINT8 **Number,
470 OUT UINTN *Len
471 )
472 {
473 EFI_STRING TmpPtr;
474 UINTN Length;
475 EFI_STRING Str;
476 UINT8 *Buf;
477 EFI_STATUS Status;
478 UINT8 DigitUint8;
479 UINTN Index;
480 CHAR16 TemStr[2];
481
482 if (StringPtr == NULL || *StringPtr == L'\0' || Number == NULL || Len == NULL) {
483 return EFI_INVALID_PARAMETER;
484 }
485
486 Buf = NULL;
487
488 TmpPtr = StringPtr;
489 while (*StringPtr != L'\0' && *StringPtr != L'&') {
490 StringPtr++;
491 }
492 *Len = StringPtr - TmpPtr;
493 Length = *Len + 1;
494
495 Str = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16));
496 if (Str == NULL) {
497 Status = EFI_OUT_OF_RESOURCES;
498 goto Exit;
499 }
500 CopyMem (Str, TmpPtr, *Len * sizeof (CHAR16));
501 *(Str + *Len) = L'\0';
502
503 Length = (Length + 1) / 2;
504 Buf = (UINT8 *) AllocateZeroPool (Length);
505 if (Buf == NULL) {
506 Status = EFI_OUT_OF_RESOURCES;
507 goto Exit;
508 }
509
510 Length = *Len;
511 ZeroMem (TemStr, sizeof (TemStr));
512 for (Index = 0; Index < Length; Index ++) {
513 TemStr[0] = Str[Length - Index - 1];
514 DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
515 if ((Index & 1) == 0) {
516 Buf [Index/2] = DigitUint8;
517 } else {
518 Buf [Index/2] = (UINT8) ((DigitUint8 << 4) + Buf [Index/2]);
519 }
520 }
521
522 *Number = Buf;
523 Status = EFI_SUCCESS;
524
525 Exit:
526 if (Str != NULL) {
527 FreePool (Str);
528 }
529
530 return Status;
531 }
532
533 /**
534 To find the BlockName in the string with same value.
535
536 @param String Pointer to a Null-terminated Unicode string.
537 @param BlockName Pointer to a Null-terminated Unicode string to search for.
538 @param Buffer Pointer to the value correspond to the BlockName.
539 @param Found The Block whether has been found.
540 @param BufferLen The length of the buffer.
541
542 @retval EFI_OUT_OF_RESOURCES Insufficient resources to store necessary structures.
543 @retval EFI_SUCCESS The function finishes successfully.
544
545 **/
546 EFI_STATUS
547 FindSameBlockElement(
548 IN EFI_STRING String,
549 IN EFI_STRING BlockName,
550 IN UINT8 *Buffer,
551 OUT BOOLEAN *Found,
552 IN UINTN BufferLen
553 )
554 {
555 EFI_STRING BlockPtr;
556 UINTN Length;
557 UINT8 *TempBuffer;
558 EFI_STATUS Status;
559
560 TempBuffer = NULL;
561 *Found = FALSE;
562 BlockPtr = StrStr (String, BlockName);
563
564 while (BlockPtr != NULL) {
565 BlockPtr += StrLen (BlockName);
566 Status = GetValueOfNumber (BlockPtr, &TempBuffer, &Length);
567 if (EFI_ERROR (Status)) {
568 return Status;
569 }
570 ASSERT (TempBuffer != NULL);
571 if ((BufferLen == Length) && (0 == CompareMem (Buffer, TempBuffer, Length))) {
572 *Found = TRUE;
573 FreePool (TempBuffer);
574 TempBuffer = NULL;
575 return EFI_SUCCESS;
576 } else {
577 FreePool (TempBuffer);
578 TempBuffer = NULL;
579 BlockPtr = StrStr (BlockPtr + 1, BlockName);
580 }
581 }
582 return EFI_SUCCESS;
583 }
584
585 /**
586 Compare the <AltResp> in ConfigAltResp and DefaultAltCfgResp, if the <AltResp>
587 in DefaultAltCfgResp but not in ConfigAltResp,add it to the ConfigAltResp.
588
589 @param DefaultAltCfgResp Pointer to a null-terminated Unicode string in
590 <MultiConfigAltResp> format. The default value
591 string may contain more than one ConfigAltResp
592 string for the different varstore buffer.
593 @param ConfigAltResp Pointer to a null-terminated Unicode string in
594 <ConfigAltResp> format.
595 @param AltConfigHdr Pointer to a Unicode string in <AltConfigHdr> format.
596 @param ConfigAltRespChanged Whether the ConfigAltResp has been changed.
597
598 @retval EFI_OUT_OF_RESOURCES Insufficient resources to store necessary structures.
599 @retval EFI_SUCCESS The function finishes successfully.
600
601 **/
602 EFI_STATUS
603 CompareBlockElementDefault (
604 IN EFI_STRING DefaultAltCfgResp,
605 IN OUT EFI_STRING *ConfigAltResp,
606 IN EFI_STRING AltConfigHdr,
607 IN OUT BOOLEAN *ConfigAltRespChanged
608 )
609 {
610 EFI_STATUS Status;
611 EFI_STRING BlockPtr;
612 EFI_STRING BlockPtrStart;
613 EFI_STRING StringPtr;
614 EFI_STRING AppendString;
615 EFI_STRING AltConfigHdrPtr;
616 UINT8 *TempBuffer;
617 UINTN OffsetLength;
618 UINTN AppendSize;
619 UINTN TotalSize;
620 BOOLEAN FoundOffset;
621
622 AppendString = NULL;
623 TempBuffer = NULL;
624 //
625 // Make BlockPtr point to the first <BlockConfig> with AltConfigHdr in DefaultAltCfgResp.
626 //
627 AltConfigHdrPtr = StrStr (DefaultAltCfgResp, AltConfigHdr);
628 ASSERT (AltConfigHdrPtr != NULL);
629 BlockPtr = StrStr (AltConfigHdrPtr, L"&OFFSET=");
630 //
631 // Make StringPtr point to the AltConfigHdr in ConfigAltResp.
632 //
633 StringPtr = StrStr (*ConfigAltResp, AltConfigHdr);
634 ASSERT (StringPtr != NULL);
635
636 while (BlockPtr != NULL) {
637 //
638 // Find the "&OFFSET=<Number>" block and get the value of the Number with AltConfigHdr in DefaultAltCfgResp.
639 //
640 BlockPtrStart = BlockPtr;
641 BlockPtr += StrLen (L"&OFFSET=");
642 Status = GetValueOfNumber (BlockPtr, &TempBuffer, &OffsetLength);
643 if (EFI_ERROR (Status)) {
644 Status = EFI_OUT_OF_RESOURCES;
645 goto Exit;
646 }
647 //
648 // To find the same "&OFFSET=<Number>" block in ConfigAltResp.
649 //
650 Status = FindSameBlockElement (StringPtr, L"&OFFSET=", TempBuffer, &FoundOffset, OffsetLength);
651 if (TempBuffer != NULL) {
652 FreePool (TempBuffer);
653 TempBuffer = NULL;
654 }
655 if (EFI_ERROR (Status)) {
656 Status = EFI_OUT_OF_RESOURCES;
657 goto Exit;
658 }
659 if (!FoundOffset) {
660 //
661 // Don't find the same "&OFFSET=<Number>" block in ConfigAltResp.
662 // Calculate the size of <BlockConfig>.
663 // <BlockConfig>::='OFFSET='<Number>'&WIDTH='<Number>'&VALUE='<Number>.
664 //
665 BlockPtr = StrStr (BlockPtr + 1, L"&OFFSET=");
666 if (BlockPtr != NULL) {
667 AppendSize = (BlockPtr - BlockPtrStart) * sizeof (CHAR16);
668 } else {
669 AppendSize = StrSize (BlockPtrStart);
670 }
671 //
672 // Copy the <BlockConfig> to AppendString.
673 //
674 if (AppendString == NULL) {
675 AppendString = (EFI_STRING) AllocateZeroPool (AppendSize + sizeof (CHAR16));
676 StrnCatS (AppendString, AppendSize / sizeof (CHAR16) + 1, BlockPtrStart, AppendSize / sizeof (CHAR16));
677 } else {
678 TotalSize = StrSize (AppendString) + AppendSize + sizeof (CHAR16);
679 AppendString = (EFI_STRING) ReallocatePool (
680 StrSize (AppendString),
681 TotalSize,
682 AppendString
683 );
684 if (AppendString == NULL) {
685 Status = EFI_OUT_OF_RESOURCES;
686 goto Exit;
687 }
688 StrnCatS (AppendString, TotalSize / sizeof (CHAR16), BlockPtrStart, AppendSize / sizeof (CHAR16));
689 }
690 } else {
691 //
692 // To find next "&OFFSET=<Number>" block with AltConfigHdr in DefaultAltCfgResp.
693 //
694 BlockPtr = StrStr (BlockPtr + 1, L"&OFFSET=");
695 }
696 }
697
698 if (AppendString != NULL) {
699 //
700 // Reallocate ConfigAltResp to copy the AppendString.
701 //
702 TotalSize = StrSize (*ConfigAltResp) + StrSize (AppendString) + sizeof (CHAR16);
703 *ConfigAltResp = (EFI_STRING) ReallocatePool (
704 StrSize (*ConfigAltResp),
705 TotalSize,
706 *ConfigAltResp
707 );
708 if (*ConfigAltResp == NULL) {
709 Status = EFI_OUT_OF_RESOURCES;
710 goto Exit;
711 }
712 StrCatS (*ConfigAltResp, TotalSize / sizeof (CHAR16), AppendString);
713 *ConfigAltRespChanged = TRUE;
714 }
715
716 Status = EFI_SUCCESS;
717
718 Exit:
719 if (AppendString != NULL) {
720 FreePool (AppendString);
721 }
722
723 return Status;
724 }
725
726 /**
727 Compare the <AltResp> in ConfigAltResp and DefaultAltCfgResp, if the <AltResp>
728 in DefaultAltCfgResp but not in ConfigAltResp,add it to the ConfigAltResp.
729
730 @param DefaultAltCfgResp Pointer to a null-terminated Unicode string in
731 <MultiConfigAltResp> format. The default value
732 string may contain more than one ConfigAltResp
733 string for the different varstore buffer.
734 @param ConfigAltResp Pointer to a null-terminated Unicode string in
735 <ConfigAltResp> format.
736 @param AltConfigHdr Pointer to a Unicode string in <AltConfigHdr> format.
737 @param ConfigAltRespChanged Whether the ConfigAltResp has been changed.
738
739 @retval EFI_OUT_OF_RESOURCES Insufficient resources to store necessary structures.
740 @retval EFI_SUCCESS The function finishes successfully.
741
742 **/
743 EFI_STATUS
744 CompareNameElementDefault (
745 IN EFI_STRING DefaultAltCfgResp,
746 IN OUT EFI_STRING *ConfigAltResp,
747 IN EFI_STRING AltConfigHdr,
748 IN OUT BOOLEAN *ConfigAltRespChanged
749 )
750 {
751 EFI_STATUS Status;
752 EFI_STRING NvConfigPtr;
753 EFI_STRING NvConfigStart;
754 EFI_STRING NvConfigValuePtr;
755 EFI_STRING StringPtr;
756 EFI_STRING NvConfigExist;
757 EFI_STRING AppendString;
758 CHAR16 TempChar;
759 UINTN AppendSize;
760 UINTN TotalSize;
761
762 AppendString = NULL;
763 NvConfigExist = NULL;
764 //
765 // Make NvConfigPtr point to the first <NvConfig> with AltConfigHdr in DefaultAltCfgResp.
766 //
767 NvConfigPtr = StrStr (DefaultAltCfgResp, AltConfigHdr);
768 ASSERT (NvConfigPtr != NULL);
769 NvConfigPtr = StrStr (NvConfigPtr + StrLen(AltConfigHdr),L"&");
770 //
771 // Make StringPtr point to the first <NvConfig> with AltConfigHdr in ConfigAltResp.
772 //
773 StringPtr = StrStr (*ConfigAltResp, AltConfigHdr);
774 ASSERT (StringPtr != NULL);
775 StringPtr = StrStr (StringPtr + StrLen (AltConfigHdr), L"&");
776 ASSERT (StringPtr != NULL);
777
778 while (NvConfigPtr != NULL) {
779 //
780 // <NvConfig> ::= <Label>'='<String> | <Label>'='<Number>.
781 // Get the <Label> with AltConfigHdr in DefaultAltCfgResp.
782 //
783 NvConfigStart = NvConfigPtr;
784 NvConfigValuePtr = StrStr (NvConfigPtr + 1, L"=");
785 ASSERT (NvConfigValuePtr != NULL);
786 TempChar = *NvConfigValuePtr;
787 *NvConfigValuePtr = L'\0';
788 //
789 // Get the <Label> with AltConfigHdr in ConfigAltResp.
790 //
791 NvConfigExist = StrStr (StringPtr, NvConfigPtr);
792 if (NvConfigExist == NULL) {
793 //
794 // Don't find same <Label> in ConfigAltResp.
795 // Calculate the size of <NvConfig>.
796 //
797 *NvConfigValuePtr = TempChar;
798 NvConfigPtr = StrStr (NvConfigPtr + 1, L"&");
799 if (NvConfigPtr != NULL) {
800 AppendSize = (NvConfigPtr - NvConfigStart) * sizeof (CHAR16);
801 } else {
802 AppendSize = StrSize (NvConfigStart);
803 }
804 //
805 // Copy the <NvConfig> to AppendString.
806 //
807 if (AppendString == NULL) {
808 AppendString = (EFI_STRING) AllocateZeroPool (AppendSize + sizeof (CHAR16));
809 StrnCatS (AppendString, AppendSize / sizeof (CHAR16) + 1, NvConfigStart, AppendSize / sizeof (CHAR16));
810 } else {
811 TotalSize = StrSize (AppendString) + AppendSize + sizeof (CHAR16);
812 AppendString = (EFI_STRING) ReallocatePool (
813 StrSize (AppendString),
814 TotalSize,
815 AppendString
816 );
817 if (AppendString == NULL) {
818 Status = EFI_OUT_OF_RESOURCES;
819 goto Exit;
820 }
821 StrnCatS (AppendString, TotalSize / sizeof (CHAR16), NvConfigStart, AppendSize / sizeof (CHAR16));
822 }
823 } else {
824 //
825 // To find next <Label> in DefaultAltCfgResp.
826 //
827 *NvConfigValuePtr = TempChar;
828 NvConfigPtr = StrStr (NvConfigPtr + 1, L"&");
829 }
830 }
831 if (AppendString != NULL) {
832 //
833 // Reallocate ConfigAltResp to copy the AppendString.
834 //
835 TotalSize = StrSize (*ConfigAltResp) + StrSize (AppendString) + sizeof (CHAR16);
836 *ConfigAltResp = (EFI_STRING) ReallocatePool (
837 StrSize (*ConfigAltResp),
838 StrSize (*ConfigAltResp) + StrSize (AppendString) + sizeof (CHAR16),
839 *ConfigAltResp
840 );
841 if (*ConfigAltResp == NULL) {
842 Status = EFI_OUT_OF_RESOURCES;
843 goto Exit;
844 }
845 StrCatS (*ConfigAltResp, TotalSize / sizeof (CHAR16), AppendString);
846 *ConfigAltRespChanged = TRUE;
847 }
848 Status = EFI_SUCCESS;
849
850 Exit:
851 if (AppendString != NULL) {
852 FreePool (AppendString);
853 }
854 return Status;
855 }
856
857 /**
858 Compare the <AltResp> in AltCfgResp and DefaultAltCfgResp, if the <AltResp>
859 in DefaultAltCfgResp but not in AltCfgResp,add it to the AltCfgResp.
860
861 @param AltCfgResp Pointer to a null-terminated Unicode string in
862 <ConfigAltResp> format.
863 @param DefaultAltCfgResp Pointer to a null-terminated Unicode string in
864 <MultiConfigAltResp> format. The default value
865 string may contain more than one ConfigAltResp
866 string for the different varstore buffer.
867 @param AltConfigHdr Pointer to a Unicode string in <AltConfigHdr> format.
868
869 @retval EFI_OUT_OF_RESOURCES Insufficient resources to store necessary
870 structures.
871 @retval EFI_SUCCESS The function finishes successfully.
872
873 **/
874 EFI_STATUS
875 CompareAndMergeDefaultString (
876 IN OUT EFI_STRING *AltCfgResp,
877 IN EFI_STRING DefaultAltCfgResp,
878 IN EFI_STRING AltConfigHdr
879 )
880 {
881 EFI_STATUS Status;
882 EFI_STRING AltCfgRespBackup;
883 EFI_STRING AltConfigHdrPtr;
884 EFI_STRING AltConfigHdrPtrNext;
885 EFI_STRING ConfigAltResp;
886 EFI_STRING StringPtr;
887 EFI_STRING StringPtrNext;
888 EFI_STRING BlockPtr;
889 UINTN ReallocateSize;
890 CHAR16 TempChar;
891 CHAR16 TempCharA;
892 BOOLEAN ConfigAltRespChanged;
893
894 Status = EFI_OUT_OF_RESOURCES;
895 BlockPtr = NULL;
896 AltConfigHdrPtrNext = NULL;
897 StringPtrNext = NULL;
898 ConfigAltResp = NULL;
899 AltCfgRespBackup = NULL;
900 TempChar = L'\0';
901 TempCharA = L'\0';
902 ConfigAltRespChanged = FALSE;
903
904 //
905 //To find the <AltResp> with AltConfigHdr in DefaultAltCfgResp, ignore other <AltResp> which follow it.
906 //
907 AltConfigHdrPtr = StrStr (DefaultAltCfgResp, AltConfigHdr);
908 ASSERT (AltConfigHdrPtr != NULL);
909 AltConfigHdrPtrNext = StrStr (AltConfigHdrPtr + 1, L"&GUID");
910 if (AltConfigHdrPtrNext != NULL) {
911 TempChar = *AltConfigHdrPtrNext;
912 *AltConfigHdrPtrNext = L'\0';
913 }
914 //
915 // To find the <AltResp> with AltConfigHdr in AltCfgResp, ignore other <AltResp> which follow it.
916 //
917 StringPtr = StrStr (*AltCfgResp, AltConfigHdr);
918 StringPtrNext = StrStr (StringPtr + 1, L"&GUID");
919 if (StringPtrNext != NULL) {
920 TempCharA = *StringPtrNext;
921 *StringPtrNext = L'\0';
922 }
923 //
924 // Copy the content of <ConfigAltResp> which contain current AltConfigHdr in AltCfgResp.
925 //
926 ConfigAltResp = AllocateCopyPool (StrSize (*AltCfgResp), *AltCfgResp);
927 if (ConfigAltResp == NULL) {
928 goto Exit;
929 }
930 //
931 // To find the <ConfigBody> with AltConfigHdr in DefaultAltCfgResp.
932 //
933 BlockPtr = StrStr (AltConfigHdrPtr, L"&OFFSET=");
934 if (BlockPtr != NULL) {
935 //
936 // <BlockConfig>::='OFFSET='<Number>'&WIDTH='<Number>'&VALUE='<Number> style.
937 // Call function CompareBlockElementDefault to compare the <BlockConfig> in DefaultAltCfgResp and ConfigAltResp.
938 // The ConfigAltResp which may contain the new <BlockConfig> get from DefaultAltCfgResp.
939 //
940 Status = CompareBlockElementDefault (DefaultAltCfgResp, &ConfigAltResp, AltConfigHdr, &ConfigAltRespChanged);
941 if (EFI_ERROR(Status)) {
942 goto Exit;
943 }
944 } else {
945 //
946 // <NvConfig> ::= <Label>'='<String> | <Label>'='<Number> style.
947 // Call function CompareNameElementDefault to compare the <NvConfig> in DefaultAltCfgResp and ConfigAltResp.
948 // The ConfigAltResp which may contain the new <NvConfig> get from DefaultAltCfgResp.
949 //
950 Status = CompareNameElementDefault (DefaultAltCfgResp, &ConfigAltResp, AltConfigHdr, &ConfigAltRespChanged);
951 if (EFI_ERROR(Status)) {
952 goto Exit;
953 }
954 }
955 //
956 // Restore the AltCfgResp.
957 //
958 if (StringPtrNext != NULL) {
959 *StringPtrNext = TempCharA;
960 }
961
962 //
963 // If the ConfigAltResp has no change,no need to update the content in AltCfgResp.
964 //
965 if (!ConfigAltRespChanged) {
966 Status = EFI_SUCCESS;
967 goto Exit;
968 }
969 //
970 // ConfigAltResp has been changed, need to update the content in AltCfgResp.
971 //
972 if (StringPtrNext != NULL) {
973 ReallocateSize = StrSize (ConfigAltResp) + StrSize (StringPtrNext) + sizeof (CHAR16);
974 } else {
975 ReallocateSize = StrSize (ConfigAltResp) + sizeof (CHAR16);
976 }
977
978 AltCfgRespBackup = (EFI_STRING) AllocateZeroPool (ReallocateSize);
979 if (AltCfgRespBackup == NULL) {
980 goto Exit;
981 }
982
983 StrCatS (AltCfgRespBackup, ReallocateSize / sizeof (CHAR16), ConfigAltResp);
984 if (StringPtrNext != NULL) {
985 StrCatS (AltCfgRespBackup, ReallocateSize / sizeof (CHAR16), StringPtrNext);
986 }
987
988 FreePool (*AltCfgResp);
989 *AltCfgResp = AltCfgRespBackup;
990
991 Status = EFI_SUCCESS;
992
993 Exit:
994 if (ConfigAltResp != NULL) {
995 FreePool(ConfigAltResp);
996 }
997 //
998 // Restore the DefaultAltCfgResp.
999 //
1000 if ( AltConfigHdrPtrNext != NULL) {
1001 *AltConfigHdrPtrNext = TempChar;
1002 AltConfigHdrPtrNext = NULL;
1003 }
1004
1005 return Status;
1006 }
1007
1008 /**
1009 This function merges DefaultAltCfgResp string into AltCfgResp string for
1010 the missing AltCfgId in AltCfgResq.
1011
1012 @param AltCfgResp Pointer to a null-terminated Unicode string in
1013 <ConfigAltResp> format. The default value string
1014 will be merged into it.
1015 @param DefaultAltCfgResp Pointer to a null-terminated Unicode string in
1016 <MultiConfigAltResp> format. The default value
1017 string may contain more than one ConfigAltResp
1018 string for the different varstore buffer.
1019
1020 @retval EFI_SUCCESS The merged string returns.
1021 @retval EFI_INVALID_PARAMETER *AltCfgResp is to NULL.
1022 **/
1023 EFI_STATUS
1024 EFIAPI
1025 MergeDefaultString (
1026 IN OUT EFI_STRING *AltCfgResp,
1027 IN EFI_STRING DefaultAltCfgResp
1028 )
1029 {
1030 EFI_STRING StringPtrDefault;
1031 EFI_STRING StringPtrEnd;
1032 CHAR16 TempChar;
1033 EFI_STRING StringPtr;
1034 EFI_STRING AltConfigHdr;
1035 UINTN HeaderLength;
1036 UINTN SizeAltCfgResp;
1037 UINTN MaxLen;
1038 UINTN TotalSize;
1039
1040 if (*AltCfgResp == NULL) {
1041 return EFI_INVALID_PARAMETER;
1042 }
1043
1044 //
1045 // Get the request ConfigHdr
1046 //
1047 SizeAltCfgResp = 0;
1048 StringPtr = *AltCfgResp;
1049
1050 //
1051 // Find <ConfigHdr> GUID=...&NAME=...&PATH=...
1052 //
1053 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
1054 return EFI_INVALID_PARAMETER;
1055 }
1056 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&NAME=", StrLen (L"&NAME=")) != 0) {
1057 StringPtr++;
1058 }
1059 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&PATH=", StrLen (L"&PATH=")) != 0) {
1060 StringPtr++;
1061 }
1062 if (*StringPtr == L'\0') {
1063 return EFI_INVALID_PARAMETER;
1064 }
1065 StringPtr += StrLen (L"&PATH=");
1066 while (*StringPtr != L'\0' && *StringPtr != L'&') {
1067 StringPtr ++;
1068 }
1069 HeaderLength = StringPtr - *AltCfgResp;
1070
1071 //
1072 // Construct AltConfigHdr string "&<ConfigHdr>&ALTCFG=XXXX\0"
1073 // |1| StrLen (ConfigHdr) | 8 | 4 | 1 |
1074 //
1075 MaxLen = 1 + HeaderLength + 8 + 4 + 1;
1076 AltConfigHdr = AllocateZeroPool (MaxLen * sizeof (CHAR16));
1077 if (AltConfigHdr == NULL) {
1078 return EFI_OUT_OF_RESOURCES;
1079 }
1080 StrCpyS (AltConfigHdr, MaxLen, L"&");
1081 StrnCatS (AltConfigHdr, MaxLen, *AltCfgResp, HeaderLength);
1082 StrCatS (AltConfigHdr, MaxLen, L"&ALTCFG=");
1083 HeaderLength = StrLen (AltConfigHdr);
1084
1085 StringPtrDefault = StrStr (DefaultAltCfgResp, AltConfigHdr);
1086 while (StringPtrDefault != NULL) {
1087 //
1088 // Get AltCfg Name
1089 //
1090 StrnCatS (AltConfigHdr, MaxLen, StringPtrDefault + HeaderLength, 4);
1091 StringPtr = StrStr (*AltCfgResp, AltConfigHdr);
1092
1093 //
1094 // Append the found default value string to the input AltCfgResp
1095 //
1096 if (StringPtr == NULL) {
1097 StringPtrEnd = StrStr (StringPtrDefault + 1, L"&GUID");
1098 SizeAltCfgResp = StrSize (*AltCfgResp);
1099 if (StringPtrEnd == NULL) {
1100 //
1101 // No more default string is found.
1102 //
1103 TotalSize = SizeAltCfgResp + StrSize (StringPtrDefault);
1104 *AltCfgResp = (EFI_STRING) ReallocatePool (
1105 SizeAltCfgResp,
1106 TotalSize,
1107 (VOID *) (*AltCfgResp)
1108 );
1109 if (*AltCfgResp == NULL) {
1110 FreePool (AltConfigHdr);
1111 return EFI_OUT_OF_RESOURCES;
1112 }
1113 StrCatS (*AltCfgResp, TotalSize / sizeof (CHAR16), StringPtrDefault);
1114 break;
1115 } else {
1116 TempChar = *StringPtrEnd;
1117 *StringPtrEnd = L'\0';
1118 TotalSize = SizeAltCfgResp + StrSize (StringPtrDefault);
1119 *AltCfgResp = (EFI_STRING) ReallocatePool (
1120 SizeAltCfgResp,
1121 TotalSize,
1122 (VOID *) (*AltCfgResp)
1123 );
1124 if (*AltCfgResp == NULL) {
1125 FreePool (AltConfigHdr);
1126 return EFI_OUT_OF_RESOURCES;
1127 }
1128 StrCatS (*AltCfgResp, TotalSize / sizeof (CHAR16), StringPtrDefault);
1129 *StringPtrEnd = TempChar;
1130 }
1131 } else {
1132 //
1133 // The AltCfgResp contains <AltCfgResp>.
1134 // If the <ConfigElement> in <AltCfgResp> in the DefaultAltCfgResp but not in the
1135 // related <AltCfgResp> in AltCfgResp, merge it to AltCfgResp. else no need to merge.
1136 //
1137 CompareAndMergeDefaultString (AltCfgResp, DefaultAltCfgResp, AltConfigHdr);
1138 }
1139
1140 //
1141 // Find next AltCfg String
1142 //
1143 *(AltConfigHdr + HeaderLength) = L'\0';
1144 StringPtrDefault = StrStr (StringPtrDefault + 1, AltConfigHdr);
1145 }
1146
1147 FreePool (AltConfigHdr);
1148 return EFI_SUCCESS;
1149 }
1150
1151 /**
1152 This function inserts new DefaultValueData into the BlockData DefaultValue array.
1153
1154 @param BlockData The BlockData is updated to add new default value.
1155 @param DefaultValueData The DefaultValue is added.
1156
1157 **/
1158 VOID
1159 InsertDefaultValue (
1160 IN IFR_BLOCK_DATA *BlockData,
1161 IN IFR_DEFAULT_DATA *DefaultValueData
1162 )
1163 {
1164 LIST_ENTRY *Link;
1165 IFR_DEFAULT_DATA *DefaultValueArray;
1166 LIST_ENTRY *DefaultLink;
1167
1168 DefaultLink = &BlockData->DefaultValueEntry;
1169
1170 for (Link = DefaultLink->ForwardLink; Link != DefaultLink; Link = Link->ForwardLink) {
1171 DefaultValueArray = BASE_CR (Link, IFR_DEFAULT_DATA, Entry);
1172 if (DefaultValueArray->DefaultId == DefaultValueData->DefaultId) {
1173 //
1174 // DEFAULT_VALUE_FROM_OPCODE has high priority, DEFAULT_VALUE_FROM_DEFAULT has low priority.
1175 // When default types are DEFAULT_VALUE_FROM_OTHER_DEFAULT, the default value can be overrode.
1176 //
1177 if ((DefaultValueData->Type > DefaultValueArray->Type) || (DefaultValueData->Type == DefaultValueArray->Type && DefaultValueData->Type == DefaultValueFromOtherDefault)) {
1178 //
1179 // Update the default value array in BlockData.
1180 //
1181 CopyMem (&DefaultValueArray->Value, &DefaultValueData->Value, sizeof (EFI_IFR_TYPE_VALUE));
1182 DefaultValueArray->Type = DefaultValueData->Type;
1183 DefaultValueArray->Cleaned = DefaultValueData->Cleaned;
1184 }
1185 return;
1186 }
1187 }
1188
1189 //
1190 // Insert new default value data in tail.
1191 //
1192 DefaultValueArray = AllocateZeroPool (sizeof (IFR_DEFAULT_DATA));
1193 ASSERT (DefaultValueArray != NULL);
1194 CopyMem (DefaultValueArray, DefaultValueData, sizeof (IFR_DEFAULT_DATA));
1195 InsertTailList (Link, &DefaultValueArray->Entry);
1196 }
1197
1198 /**
1199 This function inserts new BlockData into the block link
1200
1201 @param BlockLink The list entry points to block array.
1202 @param BlockData The point to BlockData is added.
1203
1204 **/
1205 VOID
1206 InsertBlockData (
1207 IN LIST_ENTRY *BlockLink,
1208 IN IFR_BLOCK_DATA **BlockData
1209 )
1210 {
1211 LIST_ENTRY *Link;
1212 IFR_BLOCK_DATA *BlockArray;
1213 IFR_BLOCK_DATA *BlockSingleData;
1214
1215 BlockSingleData = *BlockData;
1216
1217 if (BlockSingleData->Name != NULL) {
1218 InsertTailList (BlockLink, &BlockSingleData->Entry);
1219 return;
1220 }
1221
1222 //
1223 // Insert block data in its Offset and Width order.
1224 //
1225 for (Link = BlockLink->ForwardLink; Link != BlockLink; Link = Link->ForwardLink) {
1226 BlockArray = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
1227 if (BlockArray->Offset == BlockSingleData->Offset) {
1228 if ((BlockArray->Width > BlockSingleData->Width) || (BlockSingleData->IsBitVar && BlockArray->Width == BlockSingleData->Width)) {
1229 //
1230 // Insert this block data in the front of block array
1231 //
1232 InsertTailList (Link, &BlockSingleData->Entry);
1233 return;
1234 }
1235
1236 if ((!BlockSingleData->IsBitVar) && BlockArray->Width == BlockSingleData->Width) {
1237 //
1238 // The same block array has been added.
1239 //
1240 if (BlockSingleData != BlockArray) {
1241 FreePool (BlockSingleData);
1242 *BlockData = BlockArray;
1243 }
1244 return;
1245 }
1246 } else if (BlockArray->Offset > BlockSingleData->Offset) {
1247 //
1248 // Insert new block data in the front of block array
1249 //
1250 InsertTailList (Link, &BlockSingleData->Entry);
1251 return;
1252 }
1253 }
1254
1255 //
1256 // Add new block data into the tail.
1257 //
1258 InsertTailList (Link, &BlockSingleData->Entry);
1259 }
1260
1261 /**
1262 Retrieves a pointer to the a Null-terminated ASCII string containing the list
1263 of languages that an HII handle in the HII Database supports. The returned
1264 string is allocated using AllocatePool(). The caller is responsible for freeing
1265 the returned string using FreePool(). The format of the returned string follows
1266 the language format assumed the HII Database.
1267
1268 If HiiHandle is NULL, then ASSERT().
1269
1270 @param[in] HiiHandle A handle that was previously registered in the HII Database.
1271
1272 @retval NULL HiiHandle is not registered in the HII database
1273 @retval NULL There are not enough resources available to retrieve the supported
1274 languages.
1275 @retval NULL The list of supported languages could not be retrieved.
1276 @retval Other A pointer to the Null-terminated ASCII string of supported languages.
1277
1278 **/
1279 CHAR8 *
1280 GetSupportedLanguages (
1281 IN EFI_HII_HANDLE HiiHandle
1282 )
1283 {
1284 EFI_STATUS Status;
1285 UINTN LanguageSize;
1286 CHAR8 TempSupportedLanguages;
1287 CHAR8 *SupportedLanguages;
1288
1289 ASSERT (HiiHandle != NULL);
1290
1291 //
1292 // Retrieve the size required for the supported languages buffer.
1293 //
1294 LanguageSize = 0;
1295 Status = mPrivate.HiiString.GetLanguages (&mPrivate.HiiString, HiiHandle, &TempSupportedLanguages, &LanguageSize);
1296
1297 //
1298 // If GetLanguages() returns EFI_SUCCESS for a zero size,
1299 // then there are no supported languages registered for HiiHandle. If GetLanguages()
1300 // returns an error other than EFI_BUFFER_TOO_SMALL, then HiiHandle is not present
1301 // in the HII Database
1302 //
1303 if (Status != EFI_BUFFER_TOO_SMALL) {
1304 //
1305 // Return NULL if the size can not be retrieved, or if HiiHandle is not in the HII Database
1306 //
1307 return NULL;
1308 }
1309
1310 //
1311 // Allocate the supported languages buffer.
1312 //
1313 SupportedLanguages = AllocateZeroPool (LanguageSize);
1314 if (SupportedLanguages == NULL) {
1315 //
1316 // Return NULL if allocation fails.
1317 //
1318 return NULL;
1319 }
1320
1321 //
1322 // Retrieve the supported languages string
1323 //
1324 Status = mPrivate.HiiString.GetLanguages (&mPrivate.HiiString, HiiHandle, SupportedLanguages, &LanguageSize);
1325 if (EFI_ERROR (Status)) {
1326 //
1327 // Free the buffer and return NULL if the supported languages can not be retrieved.
1328 //
1329 FreePool (SupportedLanguages);
1330 return NULL;
1331 }
1332
1333 //
1334 // Return the Null-terminated ASCII string of supported languages
1335 //
1336 return SupportedLanguages;
1337 }
1338
1339 /**
1340 Retrieves a string from a string package.
1341
1342 If HiiHandle is NULL, then ASSERT().
1343 If StringId is 0, then ASSET.
1344
1345 @param[in] HiiHandle A handle that was previously registered in the HII Database.
1346 @param[in] StringId The identifier of the string to retrieved from the string
1347 package associated with HiiHandle.
1348
1349 @retval NULL The string specified by StringId is not present in the string package.
1350 @retval Other The string was returned.
1351
1352 **/
1353 EFI_STRING
1354 InternalGetString (
1355 IN EFI_HII_HANDLE HiiHandle,
1356 IN EFI_STRING_ID StringId
1357 )
1358 {
1359 EFI_STATUS Status;
1360 UINTN StringSize;
1361 CHAR16 TempString;
1362 EFI_STRING String;
1363 CHAR8 *SupportedLanguages;
1364 CHAR8 *PlatformLanguage;
1365 CHAR8 *BestLanguage;
1366 CHAR8 *Language;
1367
1368 ASSERT (HiiHandle != NULL);
1369 ASSERT (StringId != 0);
1370
1371 //
1372 // Initialize all allocated buffers to NULL
1373 //
1374 SupportedLanguages = NULL;
1375 PlatformLanguage = NULL;
1376 BestLanguage = NULL;
1377 String = NULL;
1378 Language = "";
1379
1380 //
1381 // Get the languages that the package specified by HiiHandle supports
1382 //
1383 SupportedLanguages = GetSupportedLanguages (HiiHandle);
1384 if (SupportedLanguages == NULL) {
1385 goto Error;
1386 }
1387
1388 //
1389 // Get the current platform language setting
1390 //
1391 GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatformLanguage, NULL);
1392
1393 //
1394 // Get the best matching language from SupportedLanguages
1395 //
1396 BestLanguage = GetBestLanguage (
1397 SupportedLanguages,
1398 FALSE, // RFC 4646 mode
1399 Language, // Highest priority
1400 PlatformLanguage != NULL ? PlatformLanguage : "", // Next highest priority
1401 SupportedLanguages, // Lowest priority
1402 NULL
1403 );
1404 if (BestLanguage == NULL) {
1405 goto Error;
1406 }
1407
1408 //
1409 // Retrieve the size of the string in the string package for the BestLanguage
1410 //
1411 StringSize = 0;
1412 Status = mPrivate.HiiString.GetString (
1413 &mPrivate.HiiString,
1414 BestLanguage,
1415 HiiHandle,
1416 StringId,
1417 &TempString,
1418 &StringSize,
1419 NULL
1420 );
1421 //
1422 // If GetString() returns EFI_SUCCESS for a zero size,
1423 // then there are no supported languages registered for HiiHandle. If GetString()
1424 // returns an error other than EFI_BUFFER_TOO_SMALL, then HiiHandle is not present
1425 // in the HII Database
1426 //
1427 if (Status != EFI_BUFFER_TOO_SMALL) {
1428 goto Error;
1429 }
1430
1431 //
1432 // Allocate a buffer for the return string
1433 //
1434 String = AllocateZeroPool (StringSize);
1435 if (String == NULL) {
1436 goto Error;
1437 }
1438
1439 //
1440 // Retrieve the string from the string package
1441 //
1442 Status = mPrivate.HiiString.GetString (
1443 &mPrivate.HiiString,
1444 BestLanguage,
1445 HiiHandle,
1446 StringId,
1447 String,
1448 &StringSize,
1449 NULL
1450 );
1451 if (EFI_ERROR (Status)) {
1452 //
1453 // Free the buffer and return NULL if the supported languages can not be retrieved.
1454 //
1455 FreePool (String);
1456 String = NULL;
1457 }
1458
1459 Error:
1460 //
1461 // Free allocated buffers
1462 //
1463 if (SupportedLanguages != NULL) {
1464 FreePool (SupportedLanguages);
1465 }
1466 if (PlatformLanguage != NULL) {
1467 FreePool (PlatformLanguage);
1468 }
1469 if (BestLanguage != NULL) {
1470 FreePool (BestLanguage);
1471 }
1472
1473 //
1474 // Return the Null-terminated Unicode string
1475 //
1476 return String;
1477 }
1478
1479 /**
1480 This function checks VarOffset and VarWidth is in the block range.
1481
1482 @param RequestBlockArray The block array is to be checked.
1483 @param VarOffset Offset of var to the structure
1484 @param VarWidth Width of var.
1485 @param IsNameValueType Whether this varstore is name/value varstore or not.
1486 @param HiiHandle Hii handle for this hii package.
1487
1488 @retval TRUE This Var is in the block range.
1489 @retval FALSE This Var is not in the block range.
1490 **/
1491 BOOLEAN
1492 BlockArrayCheck (
1493 IN IFR_BLOCK_DATA *RequestBlockArray,
1494 IN UINT16 VarOffset,
1495 IN UINT16 VarWidth,
1496 IN BOOLEAN IsNameValueType,
1497 IN EFI_HII_HANDLE HiiHandle
1498 )
1499 {
1500 LIST_ENTRY *Link;
1501 IFR_BLOCK_DATA *BlockData;
1502 EFI_STRING Name;
1503
1504 //
1505 // No Request Block array, all vars are got.
1506 //
1507 if (RequestBlockArray == NULL) {
1508 return TRUE;
1509 }
1510
1511 //
1512 // Check the input var is in the request block range.
1513 //
1514 for (Link = RequestBlockArray->Entry.ForwardLink; Link != &RequestBlockArray->Entry; Link = Link->ForwardLink) {
1515 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
1516
1517 if (IsNameValueType) {
1518 Name = InternalGetString (HiiHandle, VarOffset);
1519 ASSERT (Name != NULL);
1520
1521 if (StrnCmp (BlockData->Name, Name, StrLen (Name)) == 0) {
1522 FreePool (Name);
1523 return TRUE;
1524 }
1525 FreePool (Name);
1526 } else {
1527 if ((VarOffset >= BlockData->Offset) && ((VarOffset + VarWidth) <= (BlockData->Offset + BlockData->Width))) {
1528 return TRUE;
1529 }
1530 }
1531 }
1532
1533 return FALSE;
1534 }
1535
1536 /**
1537 Get form package data from data base.
1538
1539 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package.
1540 @param HiiFormPackage The buffer saves the package data.
1541 @param PackageSize The buffer size of the package data.
1542
1543 **/
1544 EFI_STATUS
1545 GetFormPackageData (
1546 IN HII_DATABASE_RECORD *DataBaseRecord,
1547 IN OUT UINT8 **HiiFormPackage,
1548 OUT UINTN *PackageSize
1549 )
1550 {
1551 EFI_STATUS Status;
1552 UINTN Size;
1553 UINTN ResultSize;
1554
1555 if (DataBaseRecord == NULL || HiiFormPackage == NULL || PackageSize == NULL) {
1556 return EFI_INVALID_PARAMETER;
1557 }
1558
1559 Size = 0;
1560 ResultSize = 0;
1561 //
1562 // 0. Get Hii Form Package by HiiHandle
1563 //
1564 Status = ExportFormPackages (
1565 &mPrivate,
1566 DataBaseRecord->Handle,
1567 DataBaseRecord->PackageList,
1568 0,
1569 Size,
1570 HiiFormPackage,
1571 &ResultSize
1572 );
1573 if (EFI_ERROR (Status)) {
1574 return Status;
1575 }
1576
1577 (*HiiFormPackage) = AllocatePool (ResultSize);
1578 if (*HiiFormPackage == NULL) {
1579 Status = EFI_OUT_OF_RESOURCES;
1580 return Status;
1581 }
1582
1583 //
1584 // Get HiiFormPackage by HiiHandle
1585 //
1586 Size = ResultSize;
1587 ResultSize = 0;
1588 Status = ExportFormPackages (
1589 &mPrivate,
1590 DataBaseRecord->Handle,
1591 DataBaseRecord->PackageList,
1592 0,
1593 Size,
1594 *HiiFormPackage,
1595 &ResultSize
1596 );
1597 if (EFI_ERROR (Status)) {
1598 FreePool (*HiiFormPackage);
1599 }
1600
1601 *PackageSize = Size;
1602
1603 return Status;
1604 }
1605
1606
1607 /**
1608 This function parses Form Package to get the efi varstore info according to the request ConfigHdr.
1609
1610 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package.
1611 @param ConfigHdr Request string ConfigHdr. If it is NULL,
1612 the first found varstore will be as ConfigHdr.
1613 @param IsEfiVarstore Whether the request storage type is efi varstore type.
1614 @param EfiVarStore The efi varstore info which will return.
1615 **/
1616 EFI_STATUS
1617 GetVarStoreType (
1618 IN HII_DATABASE_RECORD *DataBaseRecord,
1619 IN EFI_STRING ConfigHdr,
1620 OUT BOOLEAN *IsEfiVarstore,
1621 OUT EFI_IFR_VARSTORE_EFI **EfiVarStore
1622 )
1623 {
1624 EFI_STATUS Status;
1625 UINTN IfrOffset;
1626 UINTN PackageOffset;
1627 EFI_IFR_OP_HEADER *IfrOpHdr;
1628 CHAR16 *VarStoreName;
1629 UINTN NameSize;
1630 EFI_STRING GuidStr;
1631 EFI_STRING NameStr;
1632 EFI_STRING TempStr;
1633 UINTN LengthString;
1634 UINT8 *HiiFormPackage;
1635 UINTN PackageSize;
1636 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore;
1637 EFI_HII_PACKAGE_HEADER *PackageHeader;
1638
1639 HiiFormPackage = NULL;
1640 LengthString = 0;
1641 Status = EFI_SUCCESS;
1642 GuidStr = NULL;
1643 NameStr = NULL;
1644 TempStr = NULL;
1645 *IsEfiVarstore = FALSE;
1646
1647 Status = GetFormPackageData(DataBaseRecord, &HiiFormPackage, &PackageSize);
1648 if (EFI_ERROR (Status)) {
1649 return Status;
1650 }
1651
1652 IfrOffset = sizeof (EFI_HII_PACKAGE_HEADER);
1653 PackageOffset = IfrOffset;
1654 PackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiFormPackage;
1655
1656 while (IfrOffset < PackageSize) {
1657 //
1658 // More than one form packages exist.
1659 //
1660 if (PackageOffset >= PackageHeader->Length) {
1661 //
1662 // Process the new form package.
1663 //
1664 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER);
1665 IfrOffset += PackageOffset;
1666 PackageHeader = (EFI_HII_PACKAGE_HEADER *) (HiiFormPackage + IfrOffset);
1667 }
1668
1669 IfrOpHdr = (EFI_IFR_OP_HEADER *) (HiiFormPackage + IfrOffset);
1670 IfrOffset += IfrOpHdr->Length;
1671 PackageOffset += IfrOpHdr->Length;
1672
1673 if (IfrOpHdr->OpCode == EFI_IFR_VARSTORE_EFI_OP ) {
1674 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpHdr;
1675 //
1676 // If the length is small than the structure, this is from old efi
1677 // varstore definition. Old efi varstore get config directly from
1678 // GetVariable function.
1679 //
1680 if (IfrOpHdr->Length < sizeof (EFI_IFR_VARSTORE_EFI)) {
1681 continue;
1682 }
1683
1684 NameSize = AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name);
1685 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
1686 if (VarStoreName == NULL) {
1687 Status = EFI_OUT_OF_RESOURCES;
1688 goto Done;
1689 }
1690 AsciiStrToUnicodeStrS ((CHAR8 *) IfrEfiVarStore->Name, VarStoreName, NameSize);
1691
1692 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) &IfrEfiVarStore->Guid, 1, &GuidStr);
1693 GenerateSubStr (L"NAME=", StrLen (VarStoreName) * sizeof (CHAR16), (VOID *) VarStoreName, 2, &NameStr);
1694 LengthString = StrLen (GuidStr);
1695 LengthString = LengthString + StrLen (NameStr) + 1;
1696 TempStr = AllocateZeroPool (LengthString * sizeof (CHAR16));
1697 if (TempStr == NULL) {
1698 FreePool (GuidStr);
1699 FreePool (NameStr);
1700 FreePool (VarStoreName);
1701 Status = EFI_OUT_OF_RESOURCES;
1702 goto Done;
1703 }
1704 StrCpyS (TempStr, LengthString, GuidStr);
1705 StrCatS (TempStr, LengthString, NameStr);
1706 if (ConfigHdr == NULL || StrnCmp (ConfigHdr, TempStr, StrLen (TempStr)) == 0) {
1707 *EfiVarStore = (EFI_IFR_VARSTORE_EFI *) AllocateZeroPool (IfrOpHdr->Length);
1708 if (*EfiVarStore == NULL) {
1709 FreePool (VarStoreName);
1710 FreePool (GuidStr);
1711 FreePool (NameStr);
1712 FreePool (TempStr);
1713 Status = EFI_OUT_OF_RESOURCES;
1714 goto Done;
1715 }
1716 *IsEfiVarstore = TRUE;
1717 CopyMem (*EfiVarStore, IfrEfiVarStore, IfrOpHdr->Length);
1718 }
1719
1720 //
1721 // Free allocated temp string.
1722 //
1723 FreePool (VarStoreName);
1724 FreePool (GuidStr);
1725 FreePool (NameStr);
1726 FreePool (TempStr);
1727
1728 //
1729 // Already found the varstore, break;
1730 //
1731 if (*IsEfiVarstore) {
1732 break;
1733 }
1734 }
1735 }
1736 Done:
1737 if (HiiFormPackage != NULL) {
1738 FreePool (HiiFormPackage);
1739 }
1740
1741 return Status;
1742 }
1743
1744 /**
1745 Check whether the ConfigRequest string has the request elements.
1746 For EFI_HII_VARSTORE_BUFFER type, the request has "&OFFSET=****&WIDTH=****..." format.
1747 For EFI_HII_VARSTORE_NAME_VALUE type, the request has "&NAME1**&NAME2..." format.
1748
1749 @param ConfigRequest The input config request string.
1750
1751 @retval TRUE The input include config request elements.
1752 @retval FALSE The input string not includes.
1753
1754 **/
1755 BOOLEAN
1756 GetElementsFromRequest (
1757 IN EFI_STRING ConfigRequest
1758 )
1759 {
1760 EFI_STRING TmpRequest;
1761
1762 TmpRequest = StrStr (ConfigRequest, L"PATH=");
1763 ASSERT (TmpRequest != NULL);
1764
1765 if ((StrStr (TmpRequest, L"&OFFSET=") != NULL) || (StrStr (TmpRequest, L"&") != NULL)) {
1766 return TRUE;
1767 }
1768
1769 return FALSE;
1770 }
1771
1772 /**
1773 Check whether the this varstore is the request varstore.
1774
1775 @param VarstoreGuid Varstore guid.
1776 @param Name Varstore name.
1777 @param ConfigHdr Current configRequest info.
1778
1779 @retval TRUE This varstore is the request one.
1780 @retval FALSE This varstore is not the request one.
1781
1782 **/
1783 BOOLEAN
1784 IsThisVarstore (
1785 IN EFI_GUID *VarstoreGuid,
1786 IN CHAR16 *Name,
1787 IN CHAR16 *ConfigHdr
1788 )
1789 {
1790 EFI_STRING GuidStr;
1791 EFI_STRING NameStr;
1792 EFI_STRING TempStr;
1793 UINTN LengthString;
1794 BOOLEAN RetVal;
1795
1796 RetVal = FALSE;
1797 GuidStr = NULL;
1798 TempStr = NULL;
1799
1800 //
1801 // If ConfigHdr has name field and varstore not has name, return FALSE.
1802 //
1803 if (Name == NULL && ConfigHdr != NULL && StrStr (ConfigHdr, L"NAME=&") == NULL) {
1804 return FALSE;
1805 }
1806
1807 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *)VarstoreGuid, 1, &GuidStr);
1808 if (Name != NULL) {
1809 GenerateSubStr (L"NAME=", StrLen (Name) * sizeof (CHAR16), (VOID *) Name, 2, &NameStr);
1810 } else {
1811 GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr);
1812 }
1813 LengthString = StrLen (GuidStr);
1814 LengthString = LengthString + StrLen (NameStr) + 1;
1815 TempStr = AllocateZeroPool (LengthString * sizeof (CHAR16));
1816 if (TempStr == NULL) {
1817 goto Done;
1818 }
1819
1820 StrCpyS (TempStr, LengthString, GuidStr);
1821 StrCatS (TempStr, LengthString, NameStr);
1822
1823 if (ConfigHdr == NULL || StrnCmp (ConfigHdr, TempStr, StrLen (TempStr)) == 0) {
1824 RetVal = TRUE;
1825 }
1826
1827 Done:
1828 if (GuidStr != NULL) {
1829 FreePool (GuidStr);
1830 }
1831
1832 if (NameStr != NULL) {
1833 FreePool (NameStr);
1834 }
1835
1836 if (TempStr != NULL) {
1837 FreePool (TempStr);
1838 }
1839
1840 return RetVal;
1841 }
1842
1843 /**
1844 This function parses Form Package to get the efi varstore info according to the request ConfigHdr.
1845
1846 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package.
1847 @param ConfigHdr Request string ConfigHdr. If it is NULL,
1848 the first found varstore will be as ConfigHdr.
1849 @retval TRUE This hii package is the request one.
1850 @retval FALSE This hii package is not the request one.
1851 **/
1852 BOOLEAN
1853 IsThisPackageList (
1854 IN HII_DATABASE_RECORD *DataBaseRecord,
1855 IN EFI_STRING ConfigHdr
1856 )
1857 {
1858 EFI_STATUS Status;
1859 UINTN IfrOffset;
1860 UINTN PackageOffset;
1861 EFI_IFR_OP_HEADER *IfrOpHdr;
1862 CHAR16 *VarStoreName;
1863 UINTN NameSize;
1864 UINT8 *HiiFormPackage;
1865 UINTN PackageSize;
1866 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore;
1867 EFI_HII_PACKAGE_HEADER *PackageHeader;
1868 EFI_IFR_VARSTORE *IfrVarStore;
1869 EFI_IFR_VARSTORE_NAME_VALUE *IfrNameValueVarStore;
1870 BOOLEAN FindVarstore;
1871
1872 HiiFormPackage = NULL;
1873 VarStoreName = NULL;
1874 Status = EFI_SUCCESS;
1875 FindVarstore = FALSE;
1876
1877 Status = GetFormPackageData(DataBaseRecord, &HiiFormPackage, &PackageSize);
1878 if (EFI_ERROR (Status)) {
1879 return FALSE;
1880 }
1881
1882 IfrOffset = sizeof (EFI_HII_PACKAGE_HEADER);
1883 PackageOffset = IfrOffset;
1884 PackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiFormPackage;
1885
1886 while (IfrOffset < PackageSize) {
1887 //
1888 // More than one form packages exist.
1889 //
1890 if (PackageOffset >= PackageHeader->Length) {
1891 //
1892 // Process the new form package.
1893 //
1894 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER);
1895 IfrOffset += PackageOffset;
1896 PackageHeader = (EFI_HII_PACKAGE_HEADER *) (HiiFormPackage + IfrOffset);
1897 }
1898
1899 IfrOpHdr = (EFI_IFR_OP_HEADER *) (HiiFormPackage + IfrOffset);
1900 IfrOffset += IfrOpHdr->Length;
1901 PackageOffset += IfrOpHdr->Length;
1902
1903 switch (IfrOpHdr->OpCode) {
1904
1905 case EFI_IFR_VARSTORE_OP:
1906 IfrVarStore = (EFI_IFR_VARSTORE *) IfrOpHdr;
1907
1908 NameSize = AsciiStrSize ((CHAR8 *)IfrVarStore->Name);
1909 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
1910 if (VarStoreName == NULL) {
1911 goto Done;
1912 }
1913 AsciiStrToUnicodeStrS ((CHAR8 *)IfrVarStore->Name, VarStoreName, NameSize);
1914
1915 if (IsThisVarstore((VOID *)&IfrVarStore->Guid, VarStoreName, ConfigHdr)) {
1916 FindVarstore = TRUE;
1917 goto Done;
1918 } else {
1919 FreePool (VarStoreName);
1920 VarStoreName = NULL;
1921 }
1922 break;
1923
1924 case EFI_IFR_VARSTORE_EFI_OP:
1925 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpHdr;
1926 NameSize = AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name);
1927 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
1928 if (VarStoreName == NULL) {
1929 goto Done;
1930 }
1931 AsciiStrToUnicodeStrS ((CHAR8 *)IfrEfiVarStore->Name, VarStoreName, NameSize);
1932
1933 if (IsThisVarstore (&IfrEfiVarStore->Guid, VarStoreName, ConfigHdr)) {
1934 FindVarstore = TRUE;
1935 goto Done;
1936 } else {
1937 FreePool (VarStoreName);
1938 VarStoreName = NULL;
1939 }
1940 break;
1941
1942 case EFI_IFR_VARSTORE_NAME_VALUE_OP:
1943 IfrNameValueVarStore = (EFI_IFR_VARSTORE_NAME_VALUE *) IfrOpHdr;
1944
1945 if (IsThisVarstore (&IfrNameValueVarStore->Guid, NULL, ConfigHdr)) {
1946 FindVarstore = TRUE;
1947 goto Done;
1948 }
1949 break;
1950
1951 case EFI_IFR_FORM_OP:
1952 case EFI_IFR_FORM_MAP_OP:
1953 //
1954 // No matched varstore is found and directly return.
1955 //
1956 goto Done;
1957
1958 default:
1959 break;
1960 }
1961 }
1962 Done:
1963 if (HiiFormPackage != NULL) {
1964 FreePool (HiiFormPackage);
1965 }
1966
1967 if (VarStoreName != NULL) {
1968 FreePool (VarStoreName);
1969 }
1970
1971 return FindVarstore;
1972 }
1973
1974 /**
1975 Check whether the this op code is required.
1976
1977 @param RequestBlockArray The array includes all the request info or NULL.
1978 @param HiiHandle The hii handle for this form package.
1979 @param VarStorageData The varstore data structure.
1980 @param IfrOpHdr Ifr opcode header for this opcode.
1981 @param VarWidth The buffer width for this opcode.
1982 @param ReturnData The data block added for this opcode.
1983 @param IsBitVar Whether the the opcode refers to bit storage.
1984
1985 @retval EFI_SUCCESS This opcode is required.
1986 @retval EFI_NOT_FOUND This opcode is not required.
1987 @retval Others Contain some error.
1988
1989 **/
1990 EFI_STATUS
1991 IsThisOpcodeRequired (
1992 IN IFR_BLOCK_DATA *RequestBlockArray,
1993 IN EFI_HII_HANDLE HiiHandle,
1994 IN OUT IFR_VARSTORAGE_DATA *VarStorageData,
1995 IN EFI_IFR_OP_HEADER *IfrOpHdr,
1996 IN UINT16 VarWidth,
1997 OUT IFR_BLOCK_DATA **ReturnData,
1998 IN BOOLEAN IsBitVar
1999 )
2000 {
2001 IFR_BLOCK_DATA *BlockData;
2002 UINT16 VarOffset;
2003 EFI_STRING_ID NameId;
2004 EFI_IFR_QUESTION_HEADER *IfrQuestionHdr;
2005 UINT16 BitOffset;
2006 UINT16 BitWidth;
2007 UINT16 TotalBits;
2008
2009 NameId = 0;
2010 VarOffset = 0;
2011 BitOffset = 0;
2012 BitWidth = 0;
2013 IfrQuestionHdr = (EFI_IFR_QUESTION_HEADER *)((CHAR8 *) IfrOpHdr + sizeof (EFI_IFR_OP_HEADER));
2014
2015 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) {
2016 NameId = IfrQuestionHdr->VarStoreInfo.VarName;
2017
2018 //
2019 // Check whether this question is in requested block array.
2020 //
2021 if (!BlockArrayCheck (RequestBlockArray, NameId, 0, TRUE, HiiHandle)) {
2022 //
2023 // This question is not in the requested string. Skip it.
2024 //
2025 return EFI_NOT_FOUND;
2026 }
2027 } else {
2028 //
2029 // Get the byte offset/with and bit offset/width
2030 //
2031 if (IsBitVar) {
2032 BitOffset = IfrQuestionHdr->VarStoreInfo.VarOffset;
2033 BitWidth = VarWidth;
2034 VarOffset = BitOffset / 8;
2035 //
2036 // Use current bit width and the bit width before current bit (with same byte offset) to calculate the byte width.
2037 //
2038 TotalBits = BitOffset % 8 + BitWidth;
2039 VarWidth = (TotalBits % 8 == 0 ? TotalBits / 8: TotalBits / 8 + 1);
2040 } else {
2041 VarOffset = IfrQuestionHdr->VarStoreInfo.VarOffset;
2042 BitWidth = VarWidth;
2043 BitOffset = VarOffset * 8;
2044 }
2045
2046 //
2047 // Check whether this question is in requested block array.
2048 //
2049 if (!BlockArrayCheck (RequestBlockArray, VarOffset, VarWidth, FALSE, HiiHandle)) {
2050 //
2051 // This question is not in the requested string. Skip it.
2052 //
2053 return EFI_NOT_FOUND;
2054 }
2055
2056 //
2057 // Check this var question is in the var storage
2058 //
2059 if (((VarOffset + VarWidth) > VarStorageData->Size)) {
2060 return EFI_INVALID_PARAMETER;
2061 }
2062 }
2063
2064 BlockData = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA));
2065 if (BlockData == NULL) {
2066 return EFI_OUT_OF_RESOURCES;
2067 }
2068
2069 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) {
2070 BlockData->Name = InternalGetString(HiiHandle, NameId);
2071 } else {
2072 BlockData->Offset = VarOffset;
2073 }
2074
2075 BlockData->Width = VarWidth;
2076 BlockData->QuestionId = IfrQuestionHdr->QuestionId;
2077 BlockData->OpCode = IfrOpHdr->OpCode;
2078 BlockData->Scope = IfrOpHdr->Scope;
2079 BlockData->IsBitVar = IsBitVar;
2080 BlockData->BitOffset = BitOffset;
2081 BlockData->BitWidth = BitWidth;
2082 InitializeListHead (&BlockData->DefaultValueEntry);
2083 //
2084 // Add Block Data into VarStorageData BlockEntry
2085 //
2086 InsertBlockData (&VarStorageData->BlockEntry, &BlockData);
2087 *ReturnData = BlockData;
2088
2089 return EFI_SUCCESS;
2090 }
2091
2092 /**
2093 This function parses Form Package to get the block array and the default
2094 value array according to the request ConfigHdr.
2095
2096 @param HiiHandle Hii Handle for this hii package.
2097 @param Package Pointer to the form package data.
2098 @param PackageLength Length of the package.
2099 @param ConfigHdr Request string ConfigHdr. If it is NULL,
2100 the first found varstore will be as ConfigHdr.
2101 @param RequestBlockArray The block array is retrieved from the request string.
2102 @param VarStorageData VarStorage structure contains the got block and default value.
2103 @param DefaultIdArray Point to the got default id and default name array.
2104
2105 @retval EFI_SUCCESS The block array and the default value array are got.
2106 @retval EFI_INVALID_PARAMETER The varstore definition in the different form packages
2107 are conflicted.
2108 @retval EFI_OUT_OF_RESOURCES No enough memory.
2109 **/
2110 EFI_STATUS
2111 EFIAPI
2112 ParseIfrData (
2113 IN EFI_HII_HANDLE HiiHandle,
2114 IN UINT8 *Package,
2115 IN UINT32 PackageLength,
2116 IN EFI_STRING ConfigHdr,
2117 IN IFR_BLOCK_DATA *RequestBlockArray,
2118 IN OUT IFR_VARSTORAGE_DATA *VarStorageData,
2119 OUT IFR_DEFAULT_DATA *DefaultIdArray
2120 )
2121 {
2122 EFI_STATUS Status;
2123 UINTN IfrOffset;
2124 UINTN PackageOffset;
2125 EFI_IFR_VARSTORE *IfrVarStore;
2126 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore;
2127 EFI_IFR_OP_HEADER *IfrOpHdr;
2128 EFI_IFR_ONE_OF *IfrOneOf;
2129 EFI_IFR_REF4 *IfrRef;
2130 EFI_IFR_ONE_OF_OPTION *IfrOneOfOption;
2131 EFI_IFR_DEFAULT *IfrDefault;
2132 EFI_IFR_ORDERED_LIST *IfrOrderedList;
2133 EFI_IFR_CHECKBOX *IfrCheckBox;
2134 EFI_IFR_PASSWORD *IfrPassword;
2135 EFI_IFR_STRING *IfrString;
2136 EFI_IFR_DATE *IfrDate;
2137 EFI_IFR_TIME *IfrTime;
2138 IFR_DEFAULT_DATA DefaultData;
2139 IFR_DEFAULT_DATA *DefaultDataPtr;
2140 IFR_BLOCK_DATA *BlockData;
2141 CHAR16 *VarStoreName;
2142 UINTN NameSize;
2143 UINT16 VarWidth;
2144 UINT16 VarDefaultId;
2145 BOOLEAN FirstOneOfOption;
2146 BOOLEAN FirstOrderedList;
2147 LIST_ENTRY *LinkData;
2148 LIST_ENTRY *LinkDefault;
2149 EFI_IFR_VARSTORE_NAME_VALUE *IfrNameValueVarStore;
2150 EFI_HII_PACKAGE_HEADER *PackageHeader;
2151 EFI_VARSTORE_ID VarStoreId;
2152 UINT16 SmallestDefaultId;
2153 BOOLEAN SmallestIdFromFlag;
2154 BOOLEAN FromOtherDefaultOpcode;
2155 BOOLEAN QuestionReferBitField;
2156
2157 Status = EFI_SUCCESS;
2158 BlockData = NULL;
2159 DefaultDataPtr = NULL;
2160 FirstOneOfOption = FALSE;
2161 VarStoreId = 0;
2162 FirstOrderedList = FALSE;
2163 VarStoreName = NULL;
2164 ZeroMem (&DefaultData, sizeof (IFR_DEFAULT_DATA));
2165 SmallestDefaultId = 0xFFFF;
2166 FromOtherDefaultOpcode = FALSE;
2167 QuestionReferBitField = FALSE;
2168
2169 //
2170 // Go through the form package to parse OpCode one by one.
2171 //
2172 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER);
2173 PackageHeader = (EFI_HII_PACKAGE_HEADER *) Package;
2174 IfrOffset = PackageOffset;
2175 while (IfrOffset < PackageLength) {
2176
2177 //
2178 // More than one form package found.
2179 //
2180 if (PackageOffset >= PackageHeader->Length) {
2181 //
2182 // Already found varstore for this request, break;
2183 //
2184 if (VarStoreId != 0) {
2185 VarStoreId = 0;
2186 }
2187
2188 //
2189 // Get next package header info.
2190 //
2191 IfrOffset += sizeof (EFI_HII_PACKAGE_HEADER);
2192 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER);
2193 PackageHeader = (EFI_HII_PACKAGE_HEADER *) (Package + IfrOffset);
2194 }
2195
2196 IfrOpHdr = (EFI_IFR_OP_HEADER *) (Package + IfrOffset);
2197 switch (IfrOpHdr->OpCode) {
2198 case EFI_IFR_VARSTORE_OP:
2199 //
2200 // VarStore is found. Don't need to search any more.
2201 //
2202 if (VarStoreId != 0) {
2203 break;
2204 }
2205
2206 IfrVarStore = (EFI_IFR_VARSTORE *) IfrOpHdr;
2207
2208 NameSize = AsciiStrSize ((CHAR8 *)IfrVarStore->Name);
2209 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
2210 if (VarStoreName == NULL) {
2211 Status = EFI_OUT_OF_RESOURCES;
2212 goto Done;
2213 }
2214 AsciiStrToUnicodeStrS ((CHAR8 *)IfrVarStore->Name, VarStoreName, NameSize);
2215
2216 if (IsThisVarstore((VOID *)&IfrVarStore->Guid, VarStoreName, ConfigHdr)) {
2217 //
2218 // Find the matched VarStore
2219 //
2220 CopyGuid (&VarStorageData->Guid, (EFI_GUID *) (VOID *) &IfrVarStore->Guid);
2221 VarStorageData->Size = IfrVarStore->Size;
2222 VarStorageData->Name = VarStoreName;
2223 VarStorageData->Type = EFI_HII_VARSTORE_BUFFER;
2224 VarStoreId = IfrVarStore->VarStoreId;
2225 } else {
2226 FreePool (VarStoreName);
2227 VarStoreName = NULL;
2228 }
2229 break;
2230
2231 case EFI_IFR_VARSTORE_EFI_OP:
2232 //
2233 // VarStore is found. Don't need to search any more.
2234 //
2235 if (VarStoreId != 0) {
2236 break;
2237 }
2238
2239 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpHdr;
2240
2241 //
2242 // If the length is small than the structure, this is from old efi
2243 // varstore definition. Old efi varstore get config directly from
2244 // GetVariable function.
2245 //
2246 if (IfrOpHdr->Length < sizeof (EFI_IFR_VARSTORE_EFI)) {
2247 break;
2248 }
2249
2250 NameSize = AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name);
2251 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
2252 if (VarStoreName == NULL) {
2253 Status = EFI_OUT_OF_RESOURCES;
2254 goto Done;
2255 }
2256 AsciiStrToUnicodeStrS ((CHAR8 *)IfrEfiVarStore->Name, VarStoreName, NameSize);
2257
2258 if (IsThisVarstore (&IfrEfiVarStore->Guid, VarStoreName, ConfigHdr)) {
2259 //
2260 // Find the matched VarStore
2261 //
2262 CopyGuid (&VarStorageData->Guid, (EFI_GUID *) (VOID *) &IfrEfiVarStore->Guid);
2263 VarStorageData->Size = IfrEfiVarStore->Size;
2264 VarStorageData->Name = VarStoreName;
2265 VarStorageData->Type = EFI_HII_VARSTORE_EFI_VARIABLE_BUFFER;
2266 VarStoreId = IfrEfiVarStore->VarStoreId;
2267 } else {
2268 FreePool (VarStoreName);
2269 VarStoreName = NULL;
2270 }
2271 break;
2272
2273 case EFI_IFR_VARSTORE_NAME_VALUE_OP:
2274 //
2275 // VarStore is found. Don't need to search any more.
2276 //
2277 if (VarStoreId != 0) {
2278 break;
2279 }
2280
2281 IfrNameValueVarStore = (EFI_IFR_VARSTORE_NAME_VALUE *) IfrOpHdr;
2282
2283 if (IsThisVarstore (&IfrNameValueVarStore->Guid, NULL, ConfigHdr)) {
2284 //
2285 // Find the matched VarStore
2286 //
2287 CopyGuid (&VarStorageData->Guid, (EFI_GUID *) (VOID *) &IfrNameValueVarStore->Guid);
2288 VarStorageData->Type = EFI_HII_VARSTORE_NAME_VALUE;
2289 VarStoreId = IfrNameValueVarStore->VarStoreId;
2290 }
2291 break;
2292
2293 case EFI_IFR_DEFAULTSTORE_OP:
2294 //
2295 // Add new the map between default id and default name.
2296 //
2297 DefaultDataPtr = (IFR_DEFAULT_DATA *) AllocateZeroPool (sizeof (IFR_DEFAULT_DATA));
2298 if (DefaultDataPtr == NULL) {
2299 Status = EFI_OUT_OF_RESOURCES;
2300 goto Done;
2301 }
2302 DefaultDataPtr->DefaultId = ((EFI_IFR_DEFAULTSTORE *) IfrOpHdr)->DefaultId;
2303 InsertTailList (&DefaultIdArray->Entry, &DefaultDataPtr->Entry);
2304 DefaultDataPtr = NULL;
2305 break;
2306
2307 case EFI_IFR_FORM_OP:
2308 case EFI_IFR_FORM_MAP_OP:
2309 //
2310 // No matched varstore is found and directly return.
2311 //
2312 if ( VarStoreId == 0) {
2313 Status = EFI_SUCCESS;
2314 goto Done;
2315 }
2316 break;
2317
2318 case EFI_IFR_REF_OP:
2319 //
2320 // Ref question is not in IFR Form. This IFR form is not valid.
2321 //
2322 if ( VarStoreId == 0) {
2323 Status = EFI_INVALID_PARAMETER;
2324 goto Done;
2325 }
2326 //
2327 // Check whether this question is for the requested varstore.
2328 //
2329 IfrRef = (EFI_IFR_REF4 *) IfrOpHdr;
2330 if (IfrRef->Question.VarStoreId != VarStoreId) {
2331 break;
2332 }
2333 VarWidth = (UINT16) (sizeof (EFI_HII_REF));
2334
2335 //
2336 // The BlockData may allocate by other opcode,need to clean.
2337 //
2338 if (BlockData != NULL){
2339 BlockData = NULL;
2340 }
2341
2342 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, FALSE);
2343 if (EFI_ERROR (Status)) {
2344 if (Status == EFI_NOT_FOUND){
2345 //
2346 //The opcode is not required,exit and parse other opcode.
2347 //
2348 break;
2349 }
2350 goto Done;
2351 }
2352 break;
2353
2354 case EFI_IFR_ONE_OF_OP:
2355 case EFI_IFR_NUMERIC_OP:
2356 //
2357 // Numeric and OneOf has the same opcode structure.
2358 //
2359
2360 //
2361 // Numeric and OneOf question is not in IFR Form. This IFR form is not valid.
2362 //
2363 if (VarStoreId == 0) {
2364 Status = EFI_INVALID_PARAMETER;
2365 goto Done;
2366 }
2367 //
2368 // Check whether this question is for the requested varstore.
2369 //
2370 IfrOneOf = (EFI_IFR_ONE_OF *) IfrOpHdr;
2371 if (IfrOneOf->Question.VarStoreId != VarStoreId) {
2372 break;
2373 }
2374
2375 if (QuestionReferBitField) {
2376 VarWidth = IfrOneOf->Flags & EDKII_IFR_NUMERIC_SIZE_BIT;
2377 } else {
2378 VarWidth = (UINT16) (1 << (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE));
2379 }
2380
2381 //
2382 // The BlockData may allocate by other opcode,need to clean.
2383 //
2384 if (BlockData != NULL){
2385 BlockData = NULL;
2386 }
2387
2388 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, QuestionReferBitField);
2389 if (EFI_ERROR (Status)) {
2390 if (Status == EFI_NOT_FOUND){
2391 //
2392 //The opcode is not required,exit and parse other opcode.
2393 //
2394 break;
2395 }
2396 goto Done;
2397 }
2398
2399 //
2400 //when go to there,BlockData can't be NULLL.
2401 //
2402 ASSERT (BlockData != NULL);
2403
2404 if (IfrOpHdr->OpCode == EFI_IFR_ONE_OF_OP) {
2405 //
2406 // Set this flag to TRUE for the first oneof option.
2407 //
2408 FirstOneOfOption = TRUE;
2409 } else if (IfrOpHdr->OpCode == EFI_IFR_NUMERIC_OP) {
2410 //
2411 // Numeric minimum value will be used as default value when no default is specified.
2412 //
2413 DefaultData.Type = DefaultValueFromDefault;
2414 if (QuestionReferBitField) {
2415 //
2416 // Since default value in bit field was stored as UINT32 type.
2417 //
2418 CopyMem (&DefaultData.Value.u32, &IfrOneOf->data.u32.MinValue, sizeof (UINT32));
2419 } else {
2420 switch (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE) {
2421 case EFI_IFR_NUMERIC_SIZE_1:
2422 DefaultData.Value.u8 = IfrOneOf->data.u8.MinValue;
2423 break;
2424
2425 case EFI_IFR_NUMERIC_SIZE_2:
2426 CopyMem (&DefaultData.Value.u16, &IfrOneOf->data.u16.MinValue, sizeof (UINT16));
2427 break;
2428
2429 case EFI_IFR_NUMERIC_SIZE_4:
2430 CopyMem (&DefaultData.Value.u32, &IfrOneOf->data.u32.MinValue, sizeof (UINT32));
2431 break;
2432
2433 case EFI_IFR_NUMERIC_SIZE_8:
2434 CopyMem (&DefaultData.Value.u64, &IfrOneOf->data.u64.MinValue, sizeof (UINT64));
2435 break;
2436
2437 default:
2438 Status = EFI_INVALID_PARAMETER;
2439 goto Done;
2440 }
2441 }
2442 //
2443 // Set default value base on the DefaultId list get from IFR data.
2444 //
2445 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) {
2446 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry);
2447 DefaultData.DefaultId = DefaultDataPtr->DefaultId;
2448 InsertDefaultValue (BlockData, &DefaultData);
2449 }
2450 }
2451 break;
2452
2453 case EFI_IFR_ORDERED_LIST_OP:
2454 //
2455 // offset by question header
2456 // width by EFI_IFR_ORDERED_LIST MaxContainers * OneofOption Type
2457 //
2458
2459 FirstOrderedList = TRUE;
2460 //
2461 // OrderedList question is not in IFR Form. This IFR form is not valid.
2462 //
2463 if (VarStoreId == 0) {
2464 Status = EFI_INVALID_PARAMETER;
2465 goto Done;
2466 }
2467 //
2468 // Check whether this question is for the requested varstore.
2469 //
2470 IfrOrderedList = (EFI_IFR_ORDERED_LIST *) IfrOpHdr;
2471 if (IfrOrderedList->Question.VarStoreId != VarStoreId) {
2472 BlockData = NULL;
2473 break;
2474 }
2475 VarWidth = IfrOrderedList->MaxContainers;
2476
2477 //
2478 // The BlockData may allocate by other opcode,need to clean.
2479 //
2480 if (BlockData != NULL){
2481 BlockData = NULL;
2482 }
2483
2484 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, FALSE);
2485 if (EFI_ERROR (Status)) {
2486 if (Status == EFI_NOT_FOUND){
2487 //
2488 //The opcode is not required,exit and parse other opcode.
2489 //
2490 break;
2491 }
2492 goto Done;
2493 }
2494 break;
2495
2496 case EFI_IFR_CHECKBOX_OP:
2497 //
2498 // EFI_IFR_DEFAULT_OP
2499 // offset by question header
2500 // width is 1 sizeof (BOOLEAN)
2501 // default id by CheckBox Flags if CheckBox flags (Default or Mau) is set, the default value is 1 to be set.
2502 // value by DefaultOption
2503 // default id by DeaultOption DefaultId can override CheckBox Flags and Default value.
2504 //
2505
2506 //
2507 // CheckBox question is not in IFR Form. This IFR form is not valid.
2508 //
2509 if (VarStoreId == 0) {
2510 Status = EFI_INVALID_PARAMETER;
2511 goto Done;
2512 }
2513 //
2514 // Check whether this question is for the requested varstore.
2515 //
2516 IfrCheckBox = (EFI_IFR_CHECKBOX *) IfrOpHdr;
2517 if (IfrCheckBox->Question.VarStoreId != VarStoreId) {
2518 break;
2519 }
2520 VarWidth = (UINT16) sizeof (BOOLEAN);
2521
2522 //
2523 // The BlockData may allocate by other opcode,need to clean.
2524 //
2525 if (BlockData != NULL){
2526 BlockData = NULL;
2527 }
2528
2529 if (QuestionReferBitField) {
2530 VarWidth = 1;
2531 }
2532 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, QuestionReferBitField);
2533 if (EFI_ERROR (Status)) {
2534 if (Status == EFI_NOT_FOUND){
2535 //
2536 //The opcode is not required,exit and parse other opcode.
2537 //
2538 break;
2539 }
2540 goto Done;
2541 }
2542
2543 //
2544 //when go to there,BlockData can't be NULLL.
2545 //
2546 ASSERT (BlockData != NULL);
2547
2548 SmallestIdFromFlag = FALSE;
2549
2550 //
2551 // Add default value for standard ID by CheckBox Flag
2552 //
2553 VarDefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
2554 //
2555 // Prepare new DefaultValue
2556 //
2557 DefaultData.DefaultId = VarDefaultId;
2558 if ((IfrCheckBox->Flags & EFI_IFR_CHECKBOX_DEFAULT) == EFI_IFR_CHECKBOX_DEFAULT) {
2559 //
2560 // When flag is set, default value is TRUE.
2561 //
2562 DefaultData.Type = DefaultValueFromFlag;
2563 if (QuestionReferBitField) {
2564 DefaultData.Value.u32 = TRUE;
2565 } else {
2566 DefaultData.Value.b = TRUE;
2567 }
2568 InsertDefaultValue (BlockData, &DefaultData);
2569
2570 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_STANDARD) {
2571 //
2572 // Record the SmallestDefaultId and update the SmallestIdFromFlag.
2573 //
2574 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
2575 SmallestIdFromFlag = TRUE;
2576 }
2577 }
2578
2579 //
2580 // Add default value for Manufacture ID by CheckBox Flag
2581 //
2582 VarDefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
2583 //
2584 // Prepare new DefaultValue
2585 //
2586 DefaultData.DefaultId = VarDefaultId;
2587 if ((IfrCheckBox->Flags & EFI_IFR_CHECKBOX_DEFAULT_MFG) == EFI_IFR_CHECKBOX_DEFAULT_MFG) {
2588 //
2589 // When flag is set, default value is TRUE.
2590 //
2591 DefaultData.Type = DefaultValueFromFlag;
2592 if (QuestionReferBitField) {
2593 DefaultData.Value.u32 = TRUE;
2594 } else {
2595 DefaultData.Value.b = TRUE;
2596 }
2597 InsertDefaultValue (BlockData, &DefaultData);
2598
2599 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
2600 //
2601 // Record the SmallestDefaultId and update the SmallestIdFromFlag.
2602 //
2603 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
2604 SmallestIdFromFlag = TRUE;
2605 }
2606 }
2607 if (SmallestIdFromFlag) {
2608 //
2609 // When smallest default Id is given by the flag of CheckBox, set default value with TRUE for other default Id in the DefaultId list.
2610 //
2611 DefaultData.Type = DefaultValueFromOtherDefault;
2612 if (QuestionReferBitField) {
2613 DefaultData.Value.u32 = TRUE;
2614 } else {
2615 DefaultData.Value.b = TRUE;
2616 }
2617 //
2618 // Set default value for all the default id in the DefaultId list.
2619 //
2620 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) {
2621 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry);
2622 DefaultData.DefaultId = DefaultDataPtr->DefaultId;
2623 InsertDefaultValue (BlockData, &DefaultData);
2624 }
2625 } else {
2626 //
2627 // When flag is not set, default value is FASLE.
2628 //
2629 DefaultData.Type = DefaultValueFromDefault;
2630 if (QuestionReferBitField) {
2631 DefaultData.Value.u32 = FALSE;
2632 } else {
2633 DefaultData.Value.b = FALSE;
2634 }
2635 //
2636 // Set default value for all the default id in the DefaultId list.
2637 //
2638 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) {
2639 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry);
2640 DefaultData.DefaultId = DefaultDataPtr->DefaultId;
2641 InsertDefaultValue (BlockData, &DefaultData);
2642 }
2643 }
2644 break;
2645
2646 case EFI_IFR_DATE_OP:
2647 //
2648 // offset by question header
2649 // width MaxSize * sizeof (CHAR16)
2650 // no default value, only block array
2651 //
2652
2653 //
2654 // Date question is not in IFR Form. This IFR form is not valid.
2655 //
2656 if (VarStoreId == 0) {
2657 Status = EFI_INVALID_PARAMETER;
2658 goto Done;
2659 }
2660 //
2661 // Check whether this question is for the requested varstore.
2662 //
2663 IfrDate = (EFI_IFR_DATE *) IfrOpHdr;
2664 if (IfrDate->Question.VarStoreId != VarStoreId) {
2665 break;
2666 }
2667
2668 //
2669 // The BlockData may allocate by other opcode,need to clean.
2670 //
2671 if (BlockData != NULL){
2672 BlockData = NULL;
2673 }
2674
2675 VarWidth = (UINT16) sizeof (EFI_HII_DATE);
2676 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, FALSE);
2677 if (EFI_ERROR (Status)) {
2678 if (Status == EFI_NOT_FOUND){
2679 //
2680 //The opcode is not required,exit and parse other opcode.
2681 //
2682 break;
2683 }
2684 goto Done;
2685 }
2686 break;
2687
2688 case EFI_IFR_TIME_OP:
2689 //
2690 // offset by question header
2691 // width MaxSize * sizeof (CHAR16)
2692 // no default value, only block array
2693 //
2694
2695 //
2696 // Time question is not in IFR Form. This IFR form is not valid.
2697 //
2698 if (VarStoreId == 0) {
2699 Status = EFI_INVALID_PARAMETER;
2700 goto Done;
2701 }
2702 //
2703 // Check whether this question is for the requested varstore.
2704 //
2705 IfrTime = (EFI_IFR_TIME *) IfrOpHdr;
2706 if (IfrTime->Question.VarStoreId != VarStoreId) {
2707 break;
2708 }
2709
2710 //
2711 // The BlockData may allocate by other opcode,need to clean.
2712 //
2713 if (BlockData != NULL){
2714 BlockData = NULL;
2715 }
2716
2717 VarWidth = (UINT16) sizeof (EFI_HII_TIME);
2718 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, FALSE);
2719 if (EFI_ERROR (Status)) {
2720 if (Status == EFI_NOT_FOUND){
2721 //
2722 //The opcode is not required,exit and parse other opcode.
2723 //
2724 break;
2725 }
2726 goto Done;
2727 }
2728 break;
2729
2730 case EFI_IFR_STRING_OP:
2731 //
2732 // offset by question header
2733 // width MaxSize * sizeof (CHAR16)
2734 // no default value, only block array
2735 //
2736
2737 //
2738 // String question is not in IFR Form. This IFR form is not valid.
2739 //
2740 if (VarStoreId == 0) {
2741 Status = EFI_INVALID_PARAMETER;
2742 goto Done;
2743 }
2744 //
2745 // Check whether this question is for the requested varstore.
2746 //
2747 IfrString = (EFI_IFR_STRING *) IfrOpHdr;
2748 if (IfrString->Question.VarStoreId != VarStoreId) {
2749 break;
2750 }
2751
2752 //
2753 // The BlockData may allocate by other opcode,need to clean.
2754 //
2755 if (BlockData != NULL){
2756 BlockData = NULL;
2757 }
2758
2759 VarWidth = (UINT16) (IfrString->MaxSize * sizeof (UINT16));
2760 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, FALSE);
2761 if (EFI_ERROR (Status)) {
2762 if (Status == EFI_NOT_FOUND){
2763 //
2764 //The opcode is not required,exit and parse other opcode.
2765 //
2766 break;
2767 }
2768 goto Done;
2769 }
2770 break;
2771
2772 case EFI_IFR_PASSWORD_OP:
2773 //
2774 // offset by question header
2775 // width MaxSize * sizeof (CHAR16)
2776 // no default value, only block array
2777 //
2778
2779 //
2780 // Password question is not in IFR Form. This IFR form is not valid.
2781 //
2782 if (VarStoreId == 0) {
2783 Status = EFI_INVALID_PARAMETER;
2784 goto Done;
2785 }
2786 //
2787 // Check whether this question is for the requested varstore.
2788 //
2789 IfrPassword = (EFI_IFR_PASSWORD *) IfrOpHdr;
2790 if (IfrPassword->Question.VarStoreId != VarStoreId) {
2791 break;
2792 }
2793
2794 //
2795 // The BlockData may allocate by other opcode,need to clean.
2796 //
2797 if (BlockData != NULL){
2798 BlockData = NULL;
2799 }
2800
2801 VarWidth = (UINT16) (IfrPassword->MaxSize * sizeof (UINT16));
2802 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData, FALSE);
2803 if (EFI_ERROR (Status)) {
2804 if (Status == EFI_NOT_FOUND){
2805 //
2806 //The opcode is not required,exit and parse other opcode.
2807 //
2808 break;
2809 }
2810 goto Done;
2811 }
2812
2813 //
2814 // No default value for string.
2815 //
2816 BlockData = NULL;
2817 break;
2818
2819 case EFI_IFR_ONE_OF_OPTION_OP:
2820 //
2821 // No matched block data is ignored.
2822 //
2823 if (BlockData == NULL || BlockData->Scope == 0) {
2824 break;
2825 }
2826
2827 IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *) IfrOpHdr;
2828 if (BlockData->OpCode == EFI_IFR_ORDERED_LIST_OP) {
2829
2830 if (!FirstOrderedList){
2831 break;
2832 }
2833 //
2834 // Get ordered list option data type.
2835 //
2836 if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_8 || IfrOneOfOption->Type == EFI_IFR_TYPE_BOOLEAN) {
2837 VarWidth = 1;
2838 } else if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_16) {
2839 VarWidth = 2;
2840 } else if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_32) {
2841 VarWidth = 4;
2842 } else if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_64) {
2843 VarWidth = 8;
2844 } else {
2845 //
2846 // Invalid ordered list option data type.
2847 //
2848 Status = EFI_INVALID_PARAMETER;
2849 if (BlockData->Name != NULL) {
2850 FreePool (BlockData->Name);
2851 }
2852 FreePool (BlockData);
2853 goto Done;
2854 }
2855
2856 //
2857 // Calculate Ordered list QuestionId width.
2858 //
2859 BlockData->Width = (UINT16) (BlockData->Width * VarWidth);
2860 //
2861 // Check whether this question is in requested block array.
2862 //
2863 if (!BlockArrayCheck (RequestBlockArray, BlockData->Offset, BlockData->Width, (BOOLEAN)(BlockData->Name != NULL), HiiHandle)) {
2864 //
2865 // This question is not in the requested string. Skip it.
2866 //
2867 if (BlockData->Name != NULL) {
2868 FreePool (BlockData->Name);
2869 }
2870 FreePool (BlockData);
2871 BlockData = NULL;
2872 break;
2873 }
2874 //
2875 // Check this var question is in the var storage
2876 //
2877 if ((BlockData->Name == NULL) && ((BlockData->Offset + BlockData->Width) > VarStorageData->Size)) {
2878 Status = EFI_INVALID_PARAMETER;
2879 if (BlockData->Name != NULL) {
2880 FreePool (BlockData->Name);
2881 }
2882 FreePool (BlockData);
2883 goto Done;
2884 }
2885 //
2886 // Add Block Data into VarStorageData BlockEntry
2887 //
2888 InsertBlockData (&VarStorageData->BlockEntry, &BlockData);
2889
2890 FirstOrderedList = FALSE;
2891
2892 break;
2893 }
2894
2895 //
2896 // 1. Set default value for OneOf option when flag field has default attribute.
2897 // And set the default value with the smallest default id for other default id in the DefaultId list.
2898 //
2899 if (((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT) == EFI_IFR_OPTION_DEFAULT) ||
2900 ((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT_MFG) == EFI_IFR_OPTION_DEFAULT_MFG)) {
2901 //
2902 // This flag is used to specify whether this option is the first. Set it to FALSE for the following options.
2903 // The first oneof option value will be used as default value when no default value is specified.
2904 //
2905 FirstOneOfOption = FALSE;
2906
2907 SmallestIdFromFlag = FALSE;
2908
2909 // Prepare new DefaultValue
2910 //
2911 DefaultData.Type = DefaultValueFromFlag;
2912 CopyMem (&DefaultData.Value, &IfrOneOfOption->Value, IfrOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));
2913 if ((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT) == EFI_IFR_OPTION_DEFAULT) {
2914 DefaultData.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
2915 InsertDefaultValue (BlockData, &DefaultData);
2916 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_STANDARD) {
2917 //
2918 // Record the SmallestDefaultId and update the SmallestIdFromFlag.
2919 //
2920 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
2921 SmallestIdFromFlag = TRUE;
2922 }
2923 }
2924 if ((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT_MFG) == EFI_IFR_OPTION_DEFAULT_MFG) {
2925 DefaultData.DefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
2926 InsertDefaultValue (BlockData, &DefaultData);
2927 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
2928 //
2929 // Record the SmallestDefaultId and update the SmallestIdFromFlag.
2930 //
2931 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
2932 SmallestIdFromFlag = TRUE;
2933 }
2934 }
2935
2936 if (SmallestIdFromFlag) {
2937 //
2938 // When smallest default Id is given by the flag of oneofOption, set this option value for other default Id in the DefaultId list.
2939 //
2940 DefaultData.Type = DefaultValueFromOtherDefault;
2941 //
2942 // Set default value for other default id in the DefaultId list.
2943 //
2944 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) {
2945 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry);
2946 DefaultData.DefaultId = DefaultDataPtr->DefaultId;
2947 InsertDefaultValue (BlockData, &DefaultData);
2948 }
2949 }
2950 }
2951
2952 //
2953 // 2. Set as the default value when this is the first option.
2954 // The first oneof option value will be used as default value when no default value is specified.
2955 //
2956 if (FirstOneOfOption) {
2957 // This flag is used to specify whether this option is the first. Set it to FALSE for the following options.
2958 FirstOneOfOption = FALSE;
2959
2960 //
2961 // Prepare new DefaultValue
2962 //
2963 DefaultData.Type = DefaultValueFromDefault;
2964 CopyMem (&DefaultData.Value, &IfrOneOfOption->Value, IfrOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));
2965 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) {
2966 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry);
2967 DefaultData.DefaultId = DefaultDataPtr->DefaultId;
2968 InsertDefaultValue (BlockData, &DefaultData);
2969 }
2970 }
2971 break;
2972
2973 case EFI_IFR_DEFAULT_OP:
2974 //
2975 // Update Current BlockData to the default value.
2976 //
2977 if (BlockData == NULL || BlockData->Scope == 0) {
2978 //
2979 // No matched block data is ignored.
2980 //
2981 break;
2982 }
2983
2984 //
2985 // Get the DefaultId
2986 //
2987 IfrDefault = (EFI_IFR_DEFAULT *) IfrOpHdr;
2988 VarDefaultId = IfrDefault->DefaultId;
2989 //
2990 // Prepare new DefaultValue
2991 //
2992 DefaultData.Type = DefaultValueFromOpcode;
2993 DefaultData.DefaultId = VarDefaultId;
2994 if (QuestionReferBitField) {
2995 CopyMem (&DefaultData.Value.u32, &IfrDefault->Value.u32, sizeof (UINT32));
2996 } else {
2997 CopyMem (&DefaultData.Value, &IfrDefault->Value, IfrDefault->Header.Length - OFFSET_OF (EFI_IFR_DEFAULT, Value));
2998 }
2999
3000 // If the value field is expression, set the cleaned flag.
3001 if (IfrDefault->Type == EFI_IFR_TYPE_OTHER) {
3002 DefaultData.Cleaned = TRUE;
3003 }
3004 //
3005 // Add DefaultValue into current BlockData
3006 //
3007 InsertDefaultValue (BlockData, &DefaultData);
3008
3009 //
3010 // Set default value for other default id in the DefaultId list.
3011 // when SmallestDefaultId == VarDefaultId means there are two defaults with same default Id.
3012 // If the two defaults are both from default opcode, use the first default as the default value of other default Id.
3013 // If one from flag and the other form default opcode, use the default opcode value as the default value of other default Id.
3014 //
3015 if ((SmallestDefaultId > VarDefaultId) || (SmallestDefaultId == VarDefaultId && !FromOtherDefaultOpcode)) {
3016 FromOtherDefaultOpcode = TRUE;
3017 SmallestDefaultId = VarDefaultId;
3018 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) {
3019 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry);
3020 if (DefaultDataPtr->DefaultId != DefaultData.DefaultId){
3021 DefaultData.Type = DefaultValueFromOtherDefault;
3022 DefaultData.DefaultId = DefaultDataPtr->DefaultId;
3023 InsertDefaultValue (BlockData, &DefaultData);
3024 }
3025 }
3026 }
3027
3028 //
3029 // After insert the default value, reset the cleaned value for next
3030 // time used. If not set here, need to set the value before every time.
3031 // use it.
3032 //
3033 DefaultData.Cleaned = FALSE;
3034 break;
3035
3036 case EFI_IFR_END_OP:
3037 //
3038 // End Opcode is for Var question.
3039 //
3040 QuestionReferBitField = FALSE;
3041 if (BlockData != NULL) {
3042 if (BlockData->Scope > 0) {
3043 BlockData->Scope--;
3044 }
3045 if (BlockData->Scope == 0) {
3046 BlockData = NULL;
3047 //
3048 // when finishing parsing a question, clean the SmallestDefaultId and GetDefaultFromDefaultOpcode.
3049 //
3050 SmallestDefaultId = 0xFFFF;
3051 FromOtherDefaultOpcode = FALSE;
3052 }
3053 }
3054
3055 break;
3056
3057 case EFI_IFR_GUID_OP:
3058 if (CompareGuid ((EFI_GUID *)((UINT8 *)IfrOpHdr + sizeof (EFI_IFR_OP_HEADER)), &gEdkiiIfrBitVarstoreGuid)) {
3059 QuestionReferBitField = TRUE;
3060 }
3061 break;
3062
3063 default:
3064 if (BlockData != NULL) {
3065 if (BlockData->Scope > 0) {
3066 BlockData->Scope = (UINT8) (BlockData->Scope + IfrOpHdr->Scope);
3067 }
3068
3069 if (BlockData->Scope == 0) {
3070 BlockData = NULL;
3071 }
3072 }
3073 break;
3074 }
3075
3076 IfrOffset += IfrOpHdr->Length;
3077 PackageOffset += IfrOpHdr->Length;
3078 }
3079
3080 //
3081 //if Status == EFI_NOT_FOUND, just means the opcode is not required,not contain any error,
3082 //so set the Status to EFI_SUCCESS.
3083 //
3084 if (Status == EFI_NOT_FOUND){
3085 Status = EFI_SUCCESS;
3086 }
3087
3088 Done:
3089 for (LinkData = VarStorageData->BlockEntry.ForwardLink; LinkData != &VarStorageData->BlockEntry; LinkData = LinkData->ForwardLink) {
3090 BlockData = BASE_CR (LinkData, IFR_BLOCK_DATA, Entry);
3091 for (LinkDefault = BlockData->DefaultValueEntry.ForwardLink; LinkDefault != &BlockData->DefaultValueEntry; ) {
3092 DefaultDataPtr = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry);
3093 LinkDefault = LinkDefault->ForwardLink;
3094 if (DefaultDataPtr->Cleaned == TRUE) {
3095 RemoveEntryList (&DefaultDataPtr->Entry);
3096 FreePool (DefaultDataPtr);
3097 }
3098 }
3099 }
3100
3101 return Status;
3102 }
3103
3104 /**
3105 parse the configrequest string, get the elements.
3106
3107 @param ConfigRequest The input configrequest string.
3108 @param Progress Return the progress data.
3109
3110 @retval Block data pointer.
3111 **/
3112 IFR_BLOCK_DATA *
3113 GetBlockElement (
3114 IN EFI_STRING ConfigRequest,
3115 OUT EFI_STRING *Progress
3116 )
3117 {
3118 EFI_STRING StringPtr;
3119 IFR_BLOCK_DATA *BlockData;
3120 IFR_BLOCK_DATA *RequestBlockArray;
3121 EFI_STATUS Status;
3122 UINT8 *TmpBuffer;
3123 UINT16 Offset;
3124 UINT16 Width;
3125 LIST_ENTRY *Link;
3126 IFR_BLOCK_DATA *NextBlockData;
3127 UINTN Length;
3128
3129 TmpBuffer = NULL;
3130
3131 //
3132 // Init RequestBlockArray
3133 //
3134 RequestBlockArray = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA));
3135 if (RequestBlockArray == NULL) {
3136 goto Done;
3137 }
3138 InitializeListHead (&RequestBlockArray->Entry);
3139
3140 //
3141 // Get the request Block array from the request string
3142 // Offset and Width
3143 //
3144
3145 //
3146 // Parse each <RequestElement> if exists
3147 // Only <BlockName> format is supported by this help function.
3148 // <BlockName> ::= &'OFFSET='<Number>&'WIDTH='<Number>
3149 //
3150 StringPtr = ConfigRequest;
3151 while (*StringPtr != 0 && StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) == 0) {
3152 //
3153 // Skip the OFFSET string
3154 //
3155 *Progress = StringPtr;
3156 StringPtr += StrLen (L"&OFFSET=");
3157 //
3158 // Get Offset
3159 //
3160 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
3161 if (EFI_ERROR (Status)) {
3162 goto Done;
3163 }
3164 Offset = 0;
3165 CopyMem (
3166 &Offset,
3167 TmpBuffer,
3168 (((Length + 1) / 2) < sizeof (UINT16)) ? ((Length + 1) / 2) : sizeof (UINT16)
3169 );
3170 FreePool (TmpBuffer);
3171
3172 StringPtr += Length;
3173 if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {
3174 goto Done;
3175 }
3176 StringPtr += StrLen (L"&WIDTH=");
3177
3178 //
3179 // Get Width
3180 //
3181 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
3182 if (EFI_ERROR (Status)) {
3183 goto Done;
3184 }
3185 Width = 0;
3186 CopyMem (
3187 &Width,
3188 TmpBuffer,
3189 (((Length + 1) / 2) < sizeof (UINT16)) ? ((Length + 1) / 2) : sizeof (UINT16)
3190 );
3191 FreePool (TmpBuffer);
3192
3193 StringPtr += Length;
3194 if (*StringPtr != 0 && *StringPtr != L'&') {
3195 goto Done;
3196 }
3197
3198 //
3199 // Set Block Data
3200 //
3201 BlockData = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA));
3202 if (BlockData == NULL) {
3203 goto Done;
3204 }
3205 BlockData->Offset = Offset;
3206 BlockData->Width = Width;
3207 InsertBlockData (&RequestBlockArray->Entry, &BlockData);
3208
3209 //
3210 // Skip &VALUE string if &VALUE does exists.
3211 //
3212 if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) == 0) {
3213 StringPtr += StrLen (L"&VALUE=");
3214
3215 //
3216 // Get Value
3217 //
3218 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
3219 if (EFI_ERROR (Status)) {
3220 goto Done;
3221 }
3222 FreePool (TmpBuffer);
3223 StringPtr += Length;
3224 if (*StringPtr != 0 && *StringPtr != L'&') {
3225 goto Done;
3226 }
3227 }
3228 //
3229 // If '\0', parsing is finished.
3230 //
3231 if (*StringPtr == 0) {
3232 break;
3233 }
3234 }
3235
3236 //
3237 // Merge the requested block data.
3238 //
3239 Link = RequestBlockArray->Entry.ForwardLink;
3240 while ((Link != &RequestBlockArray->Entry) && (Link->ForwardLink != &RequestBlockArray->Entry)) {
3241 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
3242 NextBlockData = BASE_CR (Link->ForwardLink, IFR_BLOCK_DATA, Entry);
3243 if ((NextBlockData->Offset >= BlockData->Offset) && (NextBlockData->Offset <= (BlockData->Offset + BlockData->Width))) {
3244 if ((NextBlockData->Offset + NextBlockData->Width) > (BlockData->Offset + BlockData->Width)) {
3245 BlockData->Width = (UINT16) (NextBlockData->Offset + NextBlockData->Width - BlockData->Offset);
3246 }
3247 RemoveEntryList (Link->ForwardLink);
3248 FreePool (NextBlockData);
3249 continue;
3250 }
3251 Link = Link->ForwardLink;
3252 }
3253
3254 return RequestBlockArray;
3255
3256 Done:
3257 if (RequestBlockArray != NULL) {
3258 //
3259 // Free Link Array RequestBlockArray
3260 //
3261 while (!IsListEmpty (&RequestBlockArray->Entry)) {
3262 BlockData = BASE_CR (RequestBlockArray->Entry.ForwardLink, IFR_BLOCK_DATA, Entry);
3263 RemoveEntryList (&BlockData->Entry);
3264 FreePool (BlockData);
3265 }
3266
3267 FreePool (RequestBlockArray);
3268 }
3269
3270 return NULL;
3271 }
3272
3273 /**
3274 parse the configrequest string, get the elements.
3275
3276 @param ConfigRequest The input config request string.
3277 @param Progress Return the progress data.
3278
3279 @retval return data block array.
3280 **/
3281 IFR_BLOCK_DATA *
3282 GetNameElement (
3283 IN EFI_STRING ConfigRequest,
3284 OUT EFI_STRING *Progress
3285 )
3286 {
3287 EFI_STRING StringPtr;
3288 EFI_STRING NextTag;
3289 IFR_BLOCK_DATA *BlockData;
3290 IFR_BLOCK_DATA *RequestBlockArray;
3291 BOOLEAN HasValue;
3292
3293 StringPtr = ConfigRequest;
3294
3295 //
3296 // Init RequestBlockArray
3297 //
3298 RequestBlockArray = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA));
3299 if (RequestBlockArray == NULL) {
3300 goto Done;
3301 }
3302 InitializeListHead (&RequestBlockArray->Entry);
3303
3304 //
3305 // Get the request Block array from the request string
3306 //
3307
3308 //
3309 // Parse each <RequestElement> if exists
3310 // Only <BlockName> format is supported by this help function.
3311 // <BlockName> ::= &'Name***=***
3312 //
3313 while (StringPtr != NULL && *StringPtr == L'&') {
3314
3315 *Progress = StringPtr;
3316 //
3317 // Skip the L"&" string
3318 //
3319 StringPtr += 1;
3320
3321 HasValue = FALSE;
3322 if ((NextTag = StrStr (StringPtr, L"=")) != NULL) {
3323 *NextTag = L'\0';
3324 HasValue = TRUE;
3325 } else if ((NextTag = StrStr (StringPtr, L"&")) != NULL) {
3326 *NextTag = L'\0';
3327 }
3328
3329 //
3330 // Set Block Data
3331 //
3332 BlockData = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA));
3333 if (BlockData == NULL) {
3334 goto Done;
3335 }
3336
3337 //
3338 // Get Name
3339 //
3340 BlockData->Name = AllocateCopyPool(StrSize (StringPtr), StringPtr);
3341 InsertBlockData (&RequestBlockArray->Entry, &BlockData);
3342
3343 if (HasValue) {
3344 //
3345 // If has value, skip the value.
3346 //
3347 StringPtr = NextTag + 1;
3348 *NextTag = L'=';
3349 StringPtr = StrStr (StringPtr, L"&");
3350 } else if (NextTag != NULL) {
3351 //
3352 // restore the '&' text.
3353 //
3354 StringPtr = NextTag;
3355 *NextTag = L'&';
3356 }
3357 }
3358
3359 return RequestBlockArray;
3360
3361 Done:
3362 if (RequestBlockArray != NULL) {
3363 //
3364 // Free Link Array RequestBlockArray
3365 //
3366 while (!IsListEmpty (&RequestBlockArray->Entry)) {
3367 BlockData = BASE_CR (RequestBlockArray->Entry.ForwardLink, IFR_BLOCK_DATA, Entry);
3368 RemoveEntryList (&BlockData->Entry);
3369 if (BlockData->Name != NULL) {
3370 FreePool (BlockData->Name);
3371 }
3372 FreePool (BlockData);
3373 }
3374
3375 FreePool (RequestBlockArray);
3376 }
3377
3378 return NULL;
3379 }
3380
3381 /**
3382 Generate ConfigRequest string base on the varstore info.
3383
3384 @param ConfigHdr The config header for this varstore.
3385 @param VarStorageData The varstore info.
3386 @param Status Return Status.
3387 @param ConfigRequest The ConfigRequest info may be return.
3388
3389 @retval TRUE Need to continue
3390 @retval Others NO need to continue or error occur.
3391 **/
3392 BOOLEAN
3393 GenerateConfigRequest (
3394 IN CHAR16 *ConfigHdr,
3395 IN IFR_VARSTORAGE_DATA *VarStorageData,
3396 OUT EFI_STATUS *Status,
3397 IN OUT EFI_STRING *ConfigRequest
3398 )
3399 {
3400 BOOLEAN DataExist;
3401 UINTN Length;
3402 LIST_ENTRY *Link;
3403 CHAR16 *FullConfigRequest;
3404 CHAR16 *StringPtr;
3405 IFR_BLOCK_DATA *BlockData;
3406
3407 //
3408 // Append VarStorageData BlockEntry into *Request string
3409 // Now support only one varstore in a form package.
3410 //
3411
3412 //
3413 // Go through all VarStorageData Entry and get BlockEntry for each one for the multiple varstore in a single form package
3414 // Then construct them all to return MultiRequest string : ConfigHdr BlockConfig
3415 //
3416
3417 //
3418 // Compute the length of the entire request starting with <ConfigHdr> and a
3419 // Null-terminator
3420 //
3421 DataExist = FALSE;
3422 Length = StrLen (ConfigHdr) + 1;
3423
3424 for (Link = VarStorageData->BlockEntry.ForwardLink; Link != &VarStorageData->BlockEntry; Link = Link->ForwardLink) {
3425 DataExist = TRUE;
3426 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
3427 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) {
3428 //
3429 // Add <BlockName> length for each Name
3430 //
3431 // <BlockName> ::= &Name1&Name2&...
3432 // |1| StrLen(Name1)
3433 //
3434 Length = Length + (1 + StrLen (BlockData->Name));
3435 } else {
3436 //
3437 // Add <BlockName> length for each Offset/Width pair
3438 //
3439 // <BlockName> ::= &OFFSET=1234&WIDTH=1234
3440 // | 8 | 4 | 7 | 4 |
3441 //
3442 Length = Length + (8 + 4 + 7 + 4);
3443 }
3444 }
3445 //
3446 // No any request block data is found. The request string can't be constructed.
3447 //
3448 if (!DataExist) {
3449 *Status = EFI_SUCCESS;
3450 return FALSE;
3451 }
3452
3453 //
3454 // Allocate buffer for the entire <ConfigRequest>
3455 //
3456 FullConfigRequest = AllocateZeroPool (Length * sizeof (CHAR16));
3457 if (FullConfigRequest == NULL) {
3458 *Status = EFI_OUT_OF_RESOURCES;
3459 return FALSE;
3460 }
3461 StringPtr = FullConfigRequest;
3462
3463 //
3464 // Start with <ConfigHdr>
3465 //
3466 StrCpyS (StringPtr, Length, ConfigHdr);
3467 StringPtr += StrLen (StringPtr);
3468
3469 //
3470 // Loop through all the Offset/Width pairs and append them to ConfigRequest
3471 //
3472 for (Link = VarStorageData->BlockEntry.ForwardLink; Link != &VarStorageData->BlockEntry; Link = Link->ForwardLink) {
3473 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
3474 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) {
3475 //
3476 // Append &Name1\0
3477 //
3478 UnicodeSPrint (
3479 StringPtr,
3480 (1 + StrLen (BlockData->Name) + 1) * sizeof (CHAR16),
3481 L"&%s",
3482 BlockData->Name
3483 );
3484 } else {
3485 //
3486 // Append &OFFSET=XXXX&WIDTH=YYYY\0
3487 //
3488 UnicodeSPrint (
3489 StringPtr,
3490 (8 + 4 + 7 + 4 + 1) * sizeof (CHAR16),
3491 L"&OFFSET=%04X&WIDTH=%04X",
3492 BlockData->Offset,
3493 BlockData->Width
3494 );
3495 }
3496 StringPtr += StrLen (StringPtr);
3497 }
3498 //
3499 // Set to the got full request string.
3500 //
3501 HiiToLower (FullConfigRequest);
3502
3503 if (*ConfigRequest != NULL) {
3504 FreePool (*ConfigRequest);
3505 }
3506 *ConfigRequest = FullConfigRequest;
3507
3508 return TRUE;
3509 }
3510
3511 /**
3512 Generate ConfigRequest Header base on the varstore info.
3513
3514 @param VarStorageData The varstore info.
3515 @param DevicePath Device path for this varstore.
3516 @param ConfigHdr The config header for this varstore.
3517
3518 @retval EFI_SUCCESS Generate the header success.
3519 @retval EFI_OUT_OF_RESOURCES Allocate buffer fail.
3520 **/
3521 EFI_STATUS
3522 GenerateHdr (
3523 IN IFR_VARSTORAGE_DATA *VarStorageData,
3524 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
3525 OUT EFI_STRING *ConfigHdr
3526 )
3527 {
3528 EFI_STRING GuidStr;
3529 EFI_STRING NameStr;
3530 EFI_STRING PathStr;
3531 UINTN Length;
3532 EFI_STATUS Status;
3533
3534 Status = EFI_SUCCESS;
3535 NameStr = NULL;
3536 GuidStr = NULL;
3537 PathStr = NULL;
3538
3539 //
3540 // Construct <ConfigHdr> : "GUID=...&NAME=...&PATH=..." by VarStorageData Guid, Name and DriverHandle
3541 //
3542 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) &VarStorageData->Guid, 1, &GuidStr);
3543 if (VarStorageData->Name != NULL) {
3544 GenerateSubStr (L"NAME=", StrLen (VarStorageData->Name) * sizeof (CHAR16), (VOID *) VarStorageData->Name, 2, &NameStr);
3545 } else {
3546 GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr);
3547 }
3548 GenerateSubStr (
3549 L"PATH=",
3550 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) DevicePath),
3551 (VOID *) DevicePath,
3552 1,
3553 &PathStr
3554 );
3555 Length = StrLen (GuidStr) + StrLen (NameStr) + StrLen (PathStr) + 1;
3556 if (VarStorageData->Name == NULL) {
3557 Length += 1;
3558 }
3559
3560 *ConfigHdr = AllocateZeroPool (Length * sizeof (CHAR16));
3561 if (*ConfigHdr == NULL) {
3562 Status = EFI_OUT_OF_RESOURCES;
3563 goto Done;
3564 }
3565 StrCpyS (*ConfigHdr, Length, GuidStr);
3566 StrCatS (*ConfigHdr, Length, NameStr);
3567 if (VarStorageData->Name == NULL) {
3568 StrCatS (*ConfigHdr, Length, L"&");
3569 }
3570 StrCatS (*ConfigHdr, Length, PathStr);
3571
3572 //
3573 // Remove the last character L'&'
3574 //
3575 *(*ConfigHdr + StrLen (*ConfigHdr) - 1) = L'\0';
3576
3577 Done:
3578 if (GuidStr != NULL) {
3579 FreePool (GuidStr);
3580 }
3581
3582 if (NameStr != NULL) {
3583 FreePool (NameStr);
3584 }
3585
3586 if (PathStr != NULL) {
3587 FreePool (PathStr);
3588 }
3589
3590 return Status;
3591 }
3592
3593
3594 /**
3595 Update the default value in the block data which is used as bit var store.
3596
3597 For example:
3598 A question value saved in a bit fied: bitoffset = 1; bitwidth = 2;default value = 1.
3599 And corresponding block data info: offset==0; width==1;currently the default value
3600 is saved as 1.Actually the default value 1 need to be set to bit field 1, so the
3601 default value of this block data shuold be:2.
3602
3603 typedef struct {
3604 UINT8 Bit1 : 1; //
3605 UINT8 Bit2 : 2; // Question saved in Bit2,so originalBlock info: offset = 0; width = 1;(byte level) defaul = 1.
3606 // (default value record for the bit field)
3607 ......
3608 }ExampleData;
3609
3610 After function UpdateDefaultValue,the Block info is: offset = 0; width = 1;(byte level) default = 2.
3611 (default value record for the Block)
3612
3613 UpdateDefaultValue function update default value of bit var block based on the bit field info in the block.
3614
3615 @param BlockLink The Link of the block data.
3616
3617 **/
3618 VOID
3619 UpdateDefaultValue (
3620 IN LIST_ENTRY *BlockLink
3621 )
3622 {
3623 LIST_ENTRY *Link;
3624 LIST_ENTRY *ListEntry;
3625 LIST_ENTRY *LinkDefault;
3626 IFR_BLOCK_DATA *BlockData;
3627 IFR_DEFAULT_DATA *DefaultValueData;
3628 UINTN StartBit;
3629 UINTN EndBit;
3630 UINT32 BitFieldDefaultValue;
3631
3632 for ( Link = BlockLink->ForwardLink; Link != BlockLink; Link = Link->ForwardLink) {
3633 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
3634 if (!BlockData ->IsBitVar) {
3635 continue;
3636 }
3637 ListEntry = &BlockData->DefaultValueEntry;
3638 //
3639 // Update the default value in the block data with all existing default id.
3640 //
3641 for (LinkDefault = ListEntry->ForwardLink; LinkDefault != ListEntry; LinkDefault = LinkDefault->ForwardLink) {
3642 //
3643 // Get the default data, and the value of the default data is for some field in the block.
3644 // Note: Default value for bit field question is stored as UINT32.
3645 //
3646 DefaultValueData = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry);
3647 BitFieldDefaultValue = DefaultValueData->Value.u32;
3648
3649 StartBit = BlockData->BitOffset % 8;
3650 EndBit = StartBit + BlockData->BitWidth - 1;
3651
3652 //
3653 // Set the bit field default value to related bit filed, then we will got the new default vaule for the block data.
3654 //
3655 DefaultValueData->Value.u32 = BitFieldWrite32 (0, StartBit, EndBit, BitFieldDefaultValue);
3656 }
3657 }
3658 }
3659
3660 /**
3661 Merge the default value in two block datas which have overlap region.
3662
3663 For bit fields, their related block data may have overlap region, such as:
3664
3665 typedef struct {
3666 UINT16 Bit1 : 6; // Question1 refer Bit1, Block1: offset = 0; width = 1;(byte level) default = 1
3667 UINT16 Bit2 : 5; // Question2 refer Bit2, Block2: offset = 0; width = 2;(byte level) default = 5
3668 // (default value record for the bit field)
3669 ......
3670 }ExampleData;
3671
3672 After function UpdateDefaultValue:
3673 Block1: offset = 0; width = 1;(byte level) default = 1
3674 Block2: offset = 0; width = 2;(byte level) default = 320 (5 * (2 << 6))
3675 (default value record for block)
3676
3677 After function MergeBlockDefaultValue:
3678 Block1: offset = 0; width = 1;(byte level) default = 65
3679 Block2: offset = 0; width = 2;(byte level) default = 321
3680 (Block1 and Block2 has overlap region, merge the overlap value to Block1 and Blcok2)
3681
3682 Block1 and Block2 have overlap byte region, but currntly the default value of Block1 only contains
3683 value of Bit1 (low 6 bits),the default value of Block2 only contains the value of Bit2 (middle 5 bits).
3684
3685 This fuction merge the default value of these two blocks, and make the default value of block1
3686 also contain the value of lower 2 bits of the Bit2. And make the default value of Block2 also
3687 contain the default value of Bit1.
3688
3689 We can get the total value of the whole block that just cover these two blocks(in this case is:
3690 block: offset =0; width =2;) then the value of block2 is same as block, the value of block1 is
3691 the first byte value of block.
3692
3693 @param FirstBlock Point to the block date whose default value need to be merged.
3694 @param SecondBlock Point to the block date whose default value need to be merged.
3695
3696 **/
3697 VOID
3698 MergeBlockDefaultValue (
3699 IN OUT IFR_BLOCK_DATA *FirstBlock,
3700 IN OUT IFR_BLOCK_DATA *SecondBlock
3701 )
3702 {
3703 LIST_ENTRY *FirstListEntry;
3704 LIST_ENTRY *SecondListEntry;
3705 LIST_ENTRY *FirstDefaultLink;
3706 LIST_ENTRY *SecondDefaultLink;
3707 IFR_DEFAULT_DATA *FirstDefaultValueData;
3708 IFR_DEFAULT_DATA *SecondDefaultValueData;
3709 UINT32 *FirstDefaultValue;
3710 UINT32 *SecondDefaultValue;
3711 UINT64 TotalValue;
3712 UINT64 ShiftedValue;
3713 UINT16 OffsetShift;
3714
3715 FirstListEntry = &FirstBlock->DefaultValueEntry;
3716 for (FirstDefaultLink = FirstListEntry->ForwardLink; FirstDefaultLink != FirstListEntry; FirstDefaultLink = FirstDefaultLink->ForwardLink) {
3717 FirstDefaultValueData = BASE_CR (FirstDefaultLink, IFR_DEFAULT_DATA, Entry);
3718 SecondListEntry = &SecondBlock->DefaultValueEntry;
3719 for (SecondDefaultLink = SecondListEntry->ForwardLink; SecondDefaultLink != SecondListEntry; SecondDefaultLink = SecondDefaultLink->ForwardLink) {
3720 SecondDefaultValueData = BASE_CR (SecondDefaultLink, IFR_DEFAULT_DATA, Entry);
3721 if (FirstDefaultValueData->DefaultId != SecondDefaultValueData->DefaultId) {
3722 continue;
3723 }
3724 //
3725 // Find default value with same default id in the two blocks.
3726 // Note: Default value for bit field question is stored as UINT32 type.
3727 //
3728 FirstDefaultValue = &FirstDefaultValueData->Value.u32;
3729 SecondDefaultValue = &SecondDefaultValueData->Value.u32;
3730 //
3731 // 1. Get the default value of the whole blcok that can just cover FirstBlock and SecondBlock.
3732 // 2. Get the default value of FirstBlock and SecondBlock form the value of whole block based
3733 // on the offset and width of FirstBlock and SecondBlock.
3734 //
3735 if (FirstBlock->Offset > SecondBlock->Offset) {
3736 OffsetShift = FirstBlock->Offset - SecondBlock->Offset;
3737 ShiftedValue = LShiftU64 ((UINT64) (*FirstDefaultValue), OffsetShift * 8);
3738 TotalValue = ShiftedValue | (UINT64) (*SecondDefaultValue);
3739 *SecondDefaultValue = (UINT32) BitFieldRead64 (TotalValue, 0, SecondBlock->Width * 8 -1);
3740 *FirstDefaultValue = (UINT32) BitFieldRead64 (TotalValue, OffsetShift * 8, OffsetShift * 8 + FirstBlock->Width *8 -1);
3741 } else {
3742 OffsetShift = SecondBlock->Offset -FirstBlock->Offset;
3743 ShiftedValue = LShiftU64 ((UINT64) (*SecondDefaultValue), OffsetShift * 8);
3744 TotalValue = ShiftedValue | (UINT64) (*FirstDefaultValue);
3745 *FirstDefaultValue = (UINT32) BitFieldRead64 (TotalValue, 0, FirstBlock->Width * 8 -1);
3746 *SecondDefaultValue = (UINT32) BitFieldRead64 (TotalValue, OffsetShift * 8, OffsetShift * 8 + SecondBlock->Width *8 -1);
3747 }
3748 }
3749 }
3750 }
3751
3752 /**
3753
3754 Update the default value in the block data which used as Bit VarStore
3755
3756 @param BlockLink The Link of the block data.
3757
3758 **/
3759 VOID
3760 UpdateBlockDataArray (
3761 IN LIST_ENTRY *BlockLink
3762 )
3763 {
3764 LIST_ENTRY *Link;
3765 LIST_ENTRY *TempLink;
3766 IFR_BLOCK_DATA *BlockData;
3767 IFR_BLOCK_DATA *NextBlockData;
3768
3769 //
3770 // 1. Update default value in BitVar block data.
3771 // Sine some block datas are used as BitVarStore, then the default value recored in the block
3772 // is for related bit field in the block. so we need to set the default value to the related bit
3773 // fields in the block data if the block data is used as bit varstore, then the default value of
3774 // the block will be updated.
3775 //
3776 UpdateDefaultValue (BlockLink);
3777
3778 //
3779 // 2.Update default value for overlap BitVar blcok datas.
3780 // For block datas have overlap region, we need to merge the default value in different blocks.
3781 //
3782 for (Link = BlockLink->ForwardLink; Link != BlockLink; Link = Link->ForwardLink) {
3783 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry);
3784 if (!BlockData ->IsBitVar) {
3785 continue;
3786 }
3787 for (TempLink = Link->ForwardLink; TempLink != BlockLink; TempLink = TempLink->ForwardLink) {
3788 NextBlockData = BASE_CR (TempLink, IFR_BLOCK_DATA, Entry);
3789 if (!NextBlockData->IsBitVar || NextBlockData->Offset >= BlockData->Offset + BlockData->Width || BlockData->Offset >= NextBlockData->Offset + NextBlockData->Width) {
3790 continue;
3791 }
3792 //
3793 // Find two blocks are used as bit VarStore and have overlap region, so need to merge default value of these two blocks.
3794 //
3795 MergeBlockDefaultValue (BlockData, NextBlockData);
3796 }
3797 }
3798 }
3799
3800 /**
3801 Generate ConfigAltResp string base on the varstore info.
3802
3803 @param HiiHandle Hii Handle for this hii package.
3804 @param ConfigHdr The config header for this varstore.
3805 @param VarStorageData The varstore info.
3806 @param DefaultIdArray The Default id array.
3807 @param DefaultAltCfgResp The DefaultAltCfgResp info may be return.
3808
3809 @retval TRUE Need to continue
3810 @retval Others NO need to continue or error occur.
3811 **/
3812 EFI_STATUS
3813 GenerateAltConfigResp (
3814 IN EFI_HII_HANDLE HiiHandle,
3815 IN CHAR16 *ConfigHdr,
3816 IN IFR_VARSTORAGE_DATA *VarStorageData,
3817 IN IFR_DEFAULT_DATA *DefaultIdArray,
3818 IN OUT EFI_STRING *DefaultAltCfgResp
3819 )
3820 {
3821 BOOLEAN DataExist;
3822 UINTN Length;
3823 LIST_ENTRY *Link;
3824 LIST_ENTRY *LinkData;
3825 LIST_ENTRY *LinkDefault;
3826 LIST_ENTRY *ListEntry;
3827 CHAR16 *StringPtr;
3828 IFR_BLOCK_DATA *BlockData;
3829 IFR_DEFAULT_DATA *DefaultId;
3830 IFR_DEFAULT_DATA *DefaultValueData;
3831 UINTN Width;
3832 UINT8 *TmpBuffer;
3833 CHAR16 *DefaultString;
3834 UINTN StrSize;
3835
3836 BlockData = NULL;
3837 DataExist = FALSE;
3838 DefaultString = NULL;
3839 //
3840 // Add length for <ConfigHdr> + '\0'
3841 //
3842 Length = StrLen (ConfigHdr) + 1;
3843
3844 UpdateBlockDataArray (&VarStorageData->BlockEntry);
3845
3846 for (Link = DefaultIdArray->Entry.ForwardLink; Link != &DefaultIdArray->Entry; Link = Link->ForwardLink) {
3847 DefaultId = BASE_CR (Link, IFR_DEFAULT_DATA, Entry);
3848 //
3849 // Add length for "&<ConfigHdr>&ALTCFG=XXXX"
3850 // |1| StrLen (ConfigHdr) | 8 | 4 |
3851 //
3852 Length += (1 + StrLen (ConfigHdr) + 8 + 4);
3853
3854 for (LinkData = VarStorageData->BlockEntry.ForwardLink; LinkData != &VarStorageData->BlockEntry; LinkData = LinkData->ForwardLink) {
3855 BlockData = BASE_CR (LinkData, IFR_BLOCK_DATA, Entry);
3856 ListEntry = &BlockData->DefaultValueEntry;
3857 for (LinkDefault = ListEntry->ForwardLink; LinkDefault != ListEntry; LinkDefault = LinkDefault->ForwardLink) {
3858 DefaultValueData = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry);
3859 if (DefaultValueData->DefaultId != DefaultId->DefaultId) {
3860 continue;
3861 }
3862 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) {
3863 //
3864 // Add length for "&Name1=zzzzzzzzzzzz"
3865 // |1|Name|1|Value|
3866 //
3867 Length += (1 + StrLen (BlockData->Name) + 1 + BlockData->Width * 2);
3868 } else {
3869 //
3870 // Add length for "&OFFSET=XXXX&WIDTH=YYYY&VALUE=zzzzzzzzzzzz"
3871 // | 8 | 4 | 7 | 4 | 7 | Width * 2 |
3872 //
3873 Length += (8 + 4 + 7 + 4 + 7 + BlockData->Width * 2);
3874 }
3875 DataExist = TRUE;
3876 }
3877 }
3878 }
3879
3880 //
3881 // No default value is found. The default string doesn't exist.
3882 //
3883 if (!DataExist) {
3884 return EFI_SUCCESS;
3885 }
3886
3887 //
3888 // Allocate buffer for the entire <DefaultAltCfgResp>
3889 //
3890 *DefaultAltCfgResp = AllocateZeroPool (Length * sizeof (CHAR16));
3891 if (*DefaultAltCfgResp == NULL) {
3892 return EFI_OUT_OF_RESOURCES;
3893 }
3894 StringPtr = *DefaultAltCfgResp;
3895
3896 //
3897 // Start with <ConfigHdr>
3898 //
3899 StrCpyS (StringPtr, Length, ConfigHdr);
3900 StringPtr += StrLen (StringPtr);
3901
3902 for (Link = DefaultIdArray->Entry.ForwardLink; Link != &DefaultIdArray->Entry; Link = Link->ForwardLink) {
3903 DefaultId = BASE_CR (Link, IFR_DEFAULT_DATA, Entry);
3904 //
3905 // Add <AltConfigHdr> of the form "&<ConfigHdr>&ALTCFG=XXXX\0"
3906 // |1| StrLen (ConfigHdr) | 8 | 4 |
3907 //
3908 UnicodeSPrint (
3909 StringPtr,
3910 (1 + StrLen (ConfigHdr) + 8 + 4 + 1) * sizeof (CHAR16),
3911 L"&%s&ALTCFG=%04X",
3912 ConfigHdr,
3913 DefaultId->DefaultId
3914 );
3915 StringPtr += StrLen (StringPtr);
3916
3917 for (LinkData = VarStorageData->BlockEntry.ForwardLink; LinkData != &VarStorageData->BlockEntry; LinkData = LinkData->ForwardLink) {
3918 BlockData = BASE_CR (LinkData, IFR_BLOCK_DATA, Entry);
3919 ListEntry = &BlockData->DefaultValueEntry;
3920 for (LinkDefault = ListEntry->ForwardLink; LinkDefault != ListEntry; LinkDefault = LinkDefault->ForwardLink) {
3921 DefaultValueData = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry);
3922 if (DefaultValueData->DefaultId != DefaultId->DefaultId) {
3923 continue;
3924 }
3925 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) {
3926 UnicodeSPrint (
3927 StringPtr,
3928 (1 + StrLen (ConfigHdr) + 1) * sizeof (CHAR16),
3929 L"&%s=",
3930 BlockData->Name
3931 );
3932 StringPtr += StrLen (StringPtr);
3933 } else {
3934 //
3935 // Add <BlockConfig>
3936 // <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number>
3937 //
3938 UnicodeSPrint (
3939 StringPtr,
3940 (8 + 4 + 7 + 4 + 7 + 1) * sizeof (CHAR16),
3941 L"&OFFSET=%04X&WIDTH=%04X&VALUE=",
3942 BlockData->Offset,
3943 BlockData->Width
3944 );
3945 StringPtr += StrLen (StringPtr);
3946 }
3947 Width = BlockData->Width;
3948 //
3949 // Convert Value to a hex string in "%x" format
3950 // NOTE: This is in the opposite byte that GUID and PATH use
3951 //
3952 if (BlockData->OpCode == EFI_IFR_STRING_OP){
3953 DefaultString = InternalGetString(HiiHandle, DefaultValueData->Value.string);
3954 TmpBuffer = AllocateZeroPool (Width);
3955 ASSERT (TmpBuffer != NULL);
3956 if (DefaultString != NULL) {
3957 StrSize = StrLen(DefaultString)* sizeof (CHAR16);
3958 if (StrSize > Width) {
3959 StrSize = Width;
3960 }
3961 CopyMem (TmpBuffer, (UINT8 *) DefaultString, StrSize);
3962 }
3963 } else {
3964 TmpBuffer = (UINT8 *) &(DefaultValueData->Value);
3965 }
3966 for (; Width > 0 && (TmpBuffer != NULL); Width--) {
3967 UnicodeValueToStringS (
3968 StringPtr,
3969 Length * sizeof (CHAR16) - ((UINTN)StringPtr - (UINTN)*DefaultAltCfgResp),
3970 PREFIX_ZERO | RADIX_HEX,
3971 TmpBuffer[Width - 1],
3972 2
3973 );
3974 StringPtr += StrnLenS (StringPtr, Length - ((UINTN)StringPtr - (UINTN)*DefaultAltCfgResp) / sizeof (CHAR16));
3975 }
3976 if (DefaultString != NULL){
3977 FreePool(DefaultString);
3978 DefaultString = NULL;
3979 }
3980 if (BlockData->OpCode == EFI_IFR_STRING_OP && TmpBuffer != NULL) {
3981 FreePool(TmpBuffer);
3982 TmpBuffer = NULL;
3983 }
3984 }
3985 }
3986 }
3987
3988 HiiToLower (*DefaultAltCfgResp);
3989
3990 return EFI_SUCCESS;
3991 }
3992
3993 /**
3994 This function gets the full request string and full default value string by
3995 parsing IFR data in HII form packages.
3996
3997 When Request points to NULL string, the request string and default value string
3998 for each varstore in form package will return.
3999
4000 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package.
4001 @param DevicePath Device Path which Hii Config Access Protocol is registered.
4002 @param Request Pointer to a null-terminated Unicode string in
4003 <ConfigRequest> format. When it doesn't contain
4004 any RequestElement, it will be updated to return
4005 the full RequestElement retrieved from IFR data.
4006 If it points to NULL, the request string for the first
4007 varstore in form package will be merged into a
4008 <MultiConfigRequest> format string and return.
4009 @param AltCfgResp Pointer to a null-terminated Unicode string in
4010 <ConfigAltResp> format. When the pointer is to NULL,
4011 the full default value string retrieved from IFR data
4012 will return. When the pinter is to a string, the
4013 full default value string retrieved from IFR data
4014 will be merged into the input string and return.
4015 When Request points to NULL, the default value string
4016 for each varstore in form package will be merged into
4017 a <MultiConfigAltResp> format string and return.
4018 @param PointerProgress Optional parameter, it can be NULL.
4019 When it is not NULL, if Request is NULL, it returns NULL.
4020 On return, points to a character in the Request
4021 string. Points to the string's null terminator if
4022 request was successful. Points to the most recent
4023 & before the first failing name / value pair (or
4024 the beginning of the string if the failure is in
4025 the first name / value pair) if the request was
4026 not successful.
4027 @retval EFI_SUCCESS The Results string is set to the full request string.
4028 And AltCfgResp contains all default value string.
4029 @retval EFI_OUT_OF_RESOURCES Not enough memory for the return string.
4030 @retval EFI_NOT_FOUND The varstore (Guid and Name) in Request string
4031 can't be found in Form package.
4032 @retval EFI_NOT_FOUND HiiPackage can't be got on the input HiiHandle.
4033 @retval EFI_INVALID_PARAMETER Request points to NULL.
4034
4035 **/
4036 EFI_STATUS
4037 EFIAPI
4038 GetFullStringFromHiiFormPackages (
4039 IN HII_DATABASE_RECORD *DataBaseRecord,
4040 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
4041 IN OUT EFI_STRING *Request,
4042 IN OUT EFI_STRING *AltCfgResp,
4043 OUT EFI_STRING *PointerProgress OPTIONAL
4044 )
4045 {
4046 EFI_STATUS Status;
4047 UINT8 *HiiFormPackage;
4048 UINTN PackageSize;
4049 IFR_BLOCK_DATA *RequestBlockArray;
4050 IFR_BLOCK_DATA *BlockData;
4051 IFR_DEFAULT_DATA *DefaultValueData;
4052 IFR_DEFAULT_DATA *DefaultId;
4053 IFR_DEFAULT_DATA *DefaultIdArray;
4054 IFR_VARSTORAGE_DATA *VarStorageData;
4055 EFI_STRING DefaultAltCfgResp;
4056 EFI_STRING ConfigHdr;
4057 EFI_STRING StringPtr;
4058 EFI_STRING Progress;
4059
4060 if (DataBaseRecord == NULL || DevicePath == NULL || Request == NULL || AltCfgResp == NULL) {
4061 return EFI_INVALID_PARAMETER;
4062 }
4063
4064 //
4065 // Initialize the local variables.
4066 //
4067 RequestBlockArray = NULL;
4068 DefaultIdArray = NULL;
4069 VarStorageData = NULL;
4070 DefaultAltCfgResp = NULL;
4071 ConfigHdr = NULL;
4072 HiiFormPackage = NULL;
4073 PackageSize = 0;
4074 Progress = *Request;
4075
4076 Status = GetFormPackageData (DataBaseRecord, &HiiFormPackage, &PackageSize);
4077 if (EFI_ERROR (Status)) {
4078 goto Done;
4079 }
4080
4081 //
4082 // 1. Get the request block array by Request String when Request string contains the block array.
4083 //
4084 StringPtr = NULL;
4085 if (*Request != NULL) {
4086 StringPtr = *Request;
4087 //
4088 // Jump <ConfigHdr>
4089 //
4090 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
4091 Status = EFI_INVALID_PARAMETER;
4092 goto Done;
4093 }
4094 StringPtr += StrLen (L"GUID=");
4095 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&NAME=", StrLen (L"&NAME=")) != 0) {
4096 StringPtr++;
4097 }
4098 if (*StringPtr == L'\0') {
4099 Status = EFI_INVALID_PARAMETER;
4100 goto Done;
4101 }
4102 StringPtr += StrLen (L"&NAME=");
4103 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&PATH=", StrLen (L"&PATH=")) != 0) {
4104 StringPtr++;
4105 }
4106 if (*StringPtr == L'\0') {
4107 Status = EFI_INVALID_PARAMETER;
4108 goto Done;
4109 }
4110 StringPtr += StrLen (L"&PATH=");
4111 while (*StringPtr != L'\0' && *StringPtr != L'&') {
4112 StringPtr ++;
4113 }
4114
4115 if (*StringPtr == L'\0') {
4116 //
4117 // No request block is found.
4118 //
4119 StringPtr = NULL;
4120 }
4121 }
4122
4123 //
4124 // If StringPtr != NULL, get the request elements.
4125 //
4126 if (StringPtr != NULL) {
4127 if (StrStr (StringPtr, L"&OFFSET=") != NULL) {
4128 RequestBlockArray = GetBlockElement(StringPtr, &Progress);
4129 } else {
4130 RequestBlockArray = GetNameElement(StringPtr, &Progress);
4131 }
4132
4133 if (RequestBlockArray == NULL) {
4134 Status = EFI_INVALID_PARAMETER;
4135 goto Done;
4136 }
4137 }
4138
4139 //
4140 // Initialize DefaultIdArray to store the map between DeaultId and DefaultName
4141 //
4142 DefaultIdArray = (IFR_DEFAULT_DATA *) AllocateZeroPool (sizeof (IFR_DEFAULT_DATA));
4143 if (DefaultIdArray == NULL) {
4144 Status = EFI_OUT_OF_RESOURCES;
4145 goto Done;
4146 }
4147 InitializeListHead (&DefaultIdArray->Entry);
4148
4149 //
4150 // Initialize VarStorageData to store the var store Block and Default value information.
4151 //
4152 VarStorageData = (IFR_VARSTORAGE_DATA *) AllocateZeroPool (sizeof (IFR_VARSTORAGE_DATA));
4153 if (VarStorageData == NULL) {
4154 Status = EFI_OUT_OF_RESOURCES;
4155 goto Done;
4156 }
4157 InitializeListHead (&VarStorageData->Entry);
4158 InitializeListHead (&VarStorageData->BlockEntry);
4159
4160 //
4161 // 2. Parse FormPackage to get BlockArray and DefaultId Array for the request BlockArray.
4162 //
4163
4164 //
4165 // Parse the opcode in form package to get the default setting.
4166 //
4167 Status = ParseIfrData (DataBaseRecord->Handle,
4168 HiiFormPackage,
4169 (UINT32) PackageSize,
4170 *Request,
4171 RequestBlockArray,
4172 VarStorageData,
4173 DefaultIdArray);
4174 if (EFI_ERROR (Status)) {
4175 goto Done;
4176 }
4177
4178 //
4179 // No requested varstore in IFR data and directly return
4180 //
4181 if (VarStorageData->Type == 0 && VarStorageData->Name == NULL) {
4182 Status = EFI_SUCCESS;
4183 goto Done;
4184 }
4185
4186 //
4187 // 3. Construct Request Element (Block Name) for 2.1 and 2.2 case.
4188 //
4189 Status = GenerateHdr (VarStorageData, DevicePath, &ConfigHdr);
4190 if (EFI_ERROR (Status)) {
4191 goto Done;
4192 }
4193
4194 if (RequestBlockArray == NULL) {
4195 if (!GenerateConfigRequest(ConfigHdr, VarStorageData, &Status, Request)) {
4196 goto Done;
4197 }
4198 }
4199
4200 //
4201 // 4. Construct Default Value string in AltResp according to request element.
4202 // Go through all VarStorageData Entry and get the DefaultId array for each one
4203 // Then construct them all to : ConfigHdr AltConfigHdr ConfigBody AltConfigHdr ConfigBody
4204 //
4205 Status = GenerateAltConfigResp (DataBaseRecord->Handle,ConfigHdr, VarStorageData, DefaultIdArray, &DefaultAltCfgResp);
4206 if (EFI_ERROR (Status)) {
4207 goto Done;
4208 }
4209
4210 //
4211 // 5. Merge string into the input AltCfgResp if the input *AltCfgResp is not NULL.
4212 //
4213 if (*AltCfgResp != NULL && DefaultAltCfgResp != NULL) {
4214 Status = MergeDefaultString (AltCfgResp, DefaultAltCfgResp);
4215 FreePool (DefaultAltCfgResp);
4216 } else if (*AltCfgResp == NULL) {
4217 *AltCfgResp = DefaultAltCfgResp;
4218 }
4219
4220 Done:
4221 if (RequestBlockArray != NULL) {
4222 //
4223 // Free Link Array RequestBlockArray
4224 //
4225 while (!IsListEmpty (&RequestBlockArray->Entry)) {
4226 BlockData = BASE_CR (RequestBlockArray->Entry.ForwardLink, IFR_BLOCK_DATA, Entry);
4227 RemoveEntryList (&BlockData->Entry);
4228 if (BlockData->Name != NULL) {
4229 FreePool (BlockData->Name);
4230 }
4231 FreePool (BlockData);
4232 }
4233
4234 FreePool (RequestBlockArray);
4235 }
4236
4237 if (VarStorageData != NULL) {
4238 //
4239 // Free link array VarStorageData
4240 //
4241 while (!IsListEmpty (&VarStorageData->BlockEntry)) {
4242 BlockData = BASE_CR (VarStorageData->BlockEntry.ForwardLink, IFR_BLOCK_DATA, Entry);
4243 RemoveEntryList (&BlockData->Entry);
4244 if (BlockData->Name != NULL) {
4245 FreePool (BlockData->Name);
4246 }
4247 //
4248 // Free default value link array
4249 //
4250 while (!IsListEmpty (&BlockData->DefaultValueEntry)) {
4251 DefaultValueData = BASE_CR (BlockData->DefaultValueEntry.ForwardLink, IFR_DEFAULT_DATA, Entry);
4252 RemoveEntryList (&DefaultValueData->Entry);
4253 FreePool (DefaultValueData);
4254 }
4255 FreePool (BlockData);
4256 }
4257 if (VarStorageData ->Name != NULL) {
4258 FreePool (VarStorageData ->Name);
4259 VarStorageData ->Name = NULL;
4260 }
4261 FreePool (VarStorageData);
4262 }
4263
4264 if (DefaultIdArray != NULL) {
4265 //
4266 // Free DefaultId Array
4267 //
4268 while (!IsListEmpty (&DefaultIdArray->Entry)) {
4269 DefaultId = BASE_CR (DefaultIdArray->Entry.ForwardLink, IFR_DEFAULT_DATA, Entry);
4270 RemoveEntryList (&DefaultId->Entry);
4271 FreePool (DefaultId);
4272 }
4273 FreePool (DefaultIdArray);
4274 }
4275
4276 //
4277 // Free the allocated string
4278 //
4279 if (ConfigHdr != NULL) {
4280 FreePool (ConfigHdr);
4281 }
4282
4283 //
4284 // Free Package data
4285 //
4286 if (HiiFormPackage != NULL) {
4287 FreePool (HiiFormPackage);
4288 }
4289
4290 if (PointerProgress != NULL) {
4291 if (*Request == NULL) {
4292 *PointerProgress = NULL;
4293 } else if (EFI_ERROR (Status)) {
4294 *PointerProgress = *Request;
4295 } else {
4296 *PointerProgress = *Request + StrLen (*Request);
4297 }
4298 }
4299
4300 return Status;
4301 }
4302
4303 /**
4304 This function gets the full request resp string by
4305 parsing IFR data in HII form packages.
4306
4307 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
4308 instance.
4309 @param EfiVarStoreInfo The efi varstore info which is save in the EFI
4310 varstore data structure.
4311 @param Request Pointer to a null-terminated Unicode string in
4312 <ConfigRequest> format.
4313 @param RequestResp Pointer to a null-terminated Unicode string in
4314 <ConfigResp> format.
4315 @param AccessProgress On return, points to a character in the Request
4316 string. Points to the string's null terminator if
4317 request was successful. Points to the most recent
4318 & before the first failing name / value pair (or
4319 the beginning of the string if the failure is in
4320 the first name / value pair) if the request was
4321 not successful.
4322
4323 @retval EFI_SUCCESS The Results string is set to the full request string.
4324 And AltCfgResp contains all default value string.
4325 @retval EFI_OUT_OF_RESOURCES Not enough memory for the return string.
4326 @retval EFI_INVALID_PARAMETER Request points to NULL.
4327
4328 **/
4329 EFI_STATUS
4330 GetConfigRespFromEfiVarStore (
4331 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
4332 IN EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo,
4333 IN EFI_STRING Request,
4334 OUT EFI_STRING *RequestResp,
4335 OUT EFI_STRING *AccessProgress
4336 )
4337 {
4338 EFI_STATUS Status;
4339 EFI_STRING VarStoreName;
4340 UINTN NameSize;
4341 UINT8 *VarStore;
4342 UINTN BufferSize;
4343
4344 Status = EFI_SUCCESS;
4345 BufferSize = 0;
4346 VarStore = NULL;
4347 VarStoreName = NULL;
4348 *AccessProgress = Request;
4349
4350 NameSize = AsciiStrSize ((CHAR8 *)EfiVarStoreInfo->Name);
4351 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
4352 if (VarStoreName == NULL) {
4353 Status = EFI_OUT_OF_RESOURCES;
4354 goto Done;
4355 }
4356 AsciiStrToUnicodeStrS ((CHAR8 *) EfiVarStoreInfo->Name, VarStoreName, NameSize);
4357
4358
4359 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, NULL);
4360 if (Status != EFI_BUFFER_TOO_SMALL) {
4361 goto Done;
4362 }
4363
4364 VarStore = AllocateZeroPool (BufferSize);
4365 ASSERT (VarStore != NULL);
4366 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, VarStore);
4367 if (EFI_ERROR (Status)) {
4368 goto Done;
4369 }
4370
4371 Status = HiiBlockToConfig(This, Request, VarStore, BufferSize, RequestResp, AccessProgress);
4372 if (EFI_ERROR (Status)) {
4373 goto Done;
4374 }
4375
4376 Done:
4377 if (VarStoreName != NULL) {
4378 FreePool (VarStoreName);
4379 }
4380
4381 if (VarStore != NULL) {
4382 FreePool (VarStore);
4383 }
4384
4385 return Status;
4386 }
4387
4388
4389 /**
4390 This function route the full request resp string for efi varstore.
4391
4392 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
4393 instance.
4394 @param EfiVarStoreInfo The efi varstore info which is save in the EFI
4395 varstore data structure.
4396 @param RequestResp Pointer to a null-terminated Unicode string in
4397 <ConfigResp> format.
4398 @param Result Pointer to a null-terminated Unicode string in
4399 <ConfigResp> format.
4400
4401 @retval EFI_SUCCESS The Results string is set to the full request string.
4402 And AltCfgResp contains all default value string.
4403 @retval EFI_OUT_OF_RESOURCES Not enough memory for the return string.
4404 @retval EFI_INVALID_PARAMETER Request points to NULL.
4405
4406 **/
4407 EFI_STATUS
4408 RouteConfigRespForEfiVarStore (
4409 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
4410 IN EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo,
4411 IN EFI_STRING RequestResp,
4412 OUT EFI_STRING *Result
4413 )
4414 {
4415 EFI_STATUS Status;
4416 EFI_STRING VarStoreName;
4417 UINTN NameSize;
4418 UINT8 *VarStore;
4419 UINTN BufferSize;
4420 UINTN BlockSize;
4421
4422 Status = EFI_SUCCESS;
4423 BufferSize = 0;
4424 VarStore = NULL;
4425 VarStoreName = NULL;
4426 *Result = RequestResp;
4427
4428 NameSize = AsciiStrSize ((CHAR8 *)EfiVarStoreInfo->Name);
4429 VarStoreName = AllocateZeroPool (NameSize * sizeof (CHAR16));
4430 if (VarStoreName == NULL) {
4431 Status = EFI_OUT_OF_RESOURCES;
4432 goto Done;
4433 }
4434 AsciiStrToUnicodeStrS ((CHAR8 *) EfiVarStoreInfo->Name, VarStoreName, NameSize);
4435
4436 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, NULL);
4437 if (Status != EFI_BUFFER_TOO_SMALL) {
4438 DEBUG ((DEBUG_ERROR, "The variable does not exist!"));
4439 goto Done;
4440 }
4441
4442 BlockSize = BufferSize;
4443 VarStore = AllocateZeroPool (BufferSize);
4444 ASSERT (VarStore != NULL);
4445 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, VarStore);
4446 if (EFI_ERROR (Status)) {
4447 goto Done;
4448 }
4449
4450 Status = HiiConfigToBlock(This, RequestResp, VarStore, &BlockSize, Result);
4451 if (EFI_ERROR (Status)) {
4452 goto Done;
4453 }
4454
4455 Status = gRT->SetVariable (VarStoreName, &EfiVarStoreInfo->Guid, EfiVarStoreInfo->Attributes, BufferSize, VarStore);
4456 if (EFI_ERROR (Status)) {
4457 *Result = RequestResp;
4458 goto Done;
4459 }
4460
4461 Done:
4462 if (VarStoreName != NULL) {
4463 FreePool (VarStoreName);
4464 }
4465
4466 if (VarStore != NULL) {
4467 FreePool (VarStore);
4468 }
4469
4470 return Status;
4471 }
4472
4473 /**
4474 Validate the config request elements.
4475
4476 @param ConfigElements A null-terminated Unicode string in <ConfigRequest> format,
4477 without configHdr field.
4478
4479 @retval CHAR16 * THE first Name/value pair not correct.
4480 @retval NULL Success parse the name/value pair
4481 **/
4482 CHAR16 *
4483 OffsetWidthValidate (
4484 CHAR16 *ConfigElements
4485 )
4486 {
4487 CHAR16 *StringPtr;
4488 CHAR16 *RetVal;
4489
4490 StringPtr = ConfigElements;
4491
4492 while (1) {
4493 RetVal = StringPtr;
4494 if (StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) != 0) {
4495 return RetVal;
4496 }
4497
4498 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {
4499 StringPtr++;
4500 }
4501 if (*StringPtr == L'\0') {
4502 return RetVal;
4503 }
4504
4505 StringPtr += StrLen (L"&WIDTH=");
4506 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) != 0) {
4507 StringPtr ++;
4508 }
4509
4510 if (*StringPtr == L'\0') {
4511 return NULL;
4512 }
4513 }
4514 }
4515
4516 /**
4517 Validate the config request elements.
4518
4519 @param ConfigElements A null-terminated Unicode string in <ConfigRequest> format,
4520 without configHdr field.
4521
4522 @retval CHAR16 * THE first Name/value pair not correct.
4523 @retval NULL Success parse the name/value pair
4524
4525 **/
4526 CHAR16 *
4527 NameValueValidate (
4528 CHAR16 *ConfigElements
4529 )
4530 {
4531 CHAR16 *StringPtr;
4532 CHAR16 *RetVal;
4533
4534 StringPtr = ConfigElements;
4535
4536 while (1) {
4537 RetVal = StringPtr;
4538 if (*StringPtr != L'&') {
4539 return RetVal;
4540 }
4541 StringPtr += 1;
4542
4543 StringPtr = StrStr (StringPtr, L"&");
4544
4545 if (StringPtr == NULL) {
4546 return NULL;
4547 }
4548 }
4549 }
4550
4551 /**
4552 Validate the config request string.
4553
4554 @param ConfigRequest A null-terminated Unicode string in <ConfigRequest> format.
4555
4556 @retval CHAR16 * THE first element not correct.
4557 @retval NULL Success parse the name/value pair
4558
4559 **/
4560 CHAR16 *
4561 ConfigRequestValidate (
4562 CHAR16 *ConfigRequest
4563 )
4564 {
4565 BOOLEAN HasNameField;
4566 CHAR16 *StringPtr;
4567
4568 HasNameField = TRUE;
4569 StringPtr = ConfigRequest;
4570
4571 //
4572 // Check <ConfigHdr>
4573 //
4574 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
4575 return ConfigRequest;
4576 }
4577 StringPtr += StrLen (L"GUID=");
4578 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&NAME=", StrLen (L"&NAME=")) != 0) {
4579 StringPtr++;
4580 }
4581 if (*StringPtr == L'\0') {
4582 return ConfigRequest;
4583 }
4584 StringPtr += StrLen (L"&NAME=");
4585 if (*StringPtr == L'&') {
4586 HasNameField = FALSE;
4587 }
4588 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&PATH=", StrLen (L"&PATH=")) != 0) {
4589 StringPtr++;
4590 }
4591 if (*StringPtr == L'\0') {
4592 return ConfigRequest;
4593 }
4594 StringPtr += StrLen (L"&PATH=");
4595 while (*StringPtr != L'\0' && *StringPtr != L'&') {
4596 StringPtr ++;
4597 }
4598
4599 if (*StringPtr == L'\0') {
4600 return NULL;
4601 }
4602
4603 if (HasNameField) {
4604 //
4605 // Should be Buffer varstore, config request should be "OFFSET/Width" pairs.
4606 //
4607 return OffsetWidthValidate(StringPtr);
4608 } else {
4609 //
4610 // Should be Name/Value varstore, config request should be "&name1&name2..." pairs.
4611 //
4612 return NameValueValidate(StringPtr);
4613 }
4614 }
4615
4616 /**
4617 This function allows a caller to extract the current configuration
4618 for one or more named elements from one or more drivers.
4619
4620 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
4621 instance.
4622 @param Request A null-terminated Unicode string in
4623 <MultiConfigRequest> format.
4624 @param Progress On return, points to a character in the Request
4625 string. Points to the string's null terminator if
4626 request was successful. Points to the most recent
4627 & before the first failing name / value pair (or
4628 the beginning of the string if the failure is in
4629 the first name / value pair) if the request was
4630 not successful.
4631 @param Results Null-terminated Unicode string in
4632 <MultiConfigAltResp> format which has all values
4633 filled in for the names in the Request string.
4634 String to be allocated by the called function.
4635
4636 @retval EFI_SUCCESS The Results string is filled with the values
4637 corresponding to all requested names.
4638 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the parts of the
4639 results that must be stored awaiting possible
4640 future protocols.
4641 @retval EFI_NOT_FOUND Routing data doesn't match any known driver.
4642 Progress set to the "G" in "GUID" of the routing
4643 header that doesn't match. Note: There is no
4644 requirement that all routing data be validated
4645 before any configuration extraction.
4646 @retval EFI_INVALID_PARAMETER For example, passing in a NULL for the Request
4647 parameter would result in this type of error. The
4648 Progress parameter is set to NULL.
4649 @retval EFI_INVALID_PARAMETER Illegal syntax. Progress set to most recent &
4650 before the error or the beginning of the string.
4651 @retval EFI_INVALID_PARAMETER The ExtractConfig function of the underlying HII
4652 Configuration Access Protocol returned
4653 EFI_INVALID_PARAMETER. Progress set to most recent
4654 & before the error or the beginning of the string.
4655
4656 **/
4657 EFI_STATUS
4658 EFIAPI
4659 HiiConfigRoutingExtractConfig (
4660 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
4661 IN CONST EFI_STRING Request,
4662 OUT EFI_STRING *Progress,
4663 OUT EFI_STRING *Results
4664 )
4665 {
4666 HII_DATABASE_PRIVATE_DATA *Private;
4667 EFI_STRING StringPtr;
4668 EFI_STRING ConfigRequest;
4669 UINTN Length;
4670 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
4671 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
4672 EFI_STATUS Status;
4673 LIST_ENTRY *Link;
4674 HII_DATABASE_RECORD *Database;
4675 UINT8 *DevicePathPkg;
4676 UINT8 *CurrentDevicePath;
4677 EFI_HANDLE DriverHandle;
4678 EFI_HII_HANDLE HiiHandle;
4679 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;
4680 EFI_STRING AccessProgress;
4681 EFI_STRING AccessResults;
4682 EFI_STRING AccessProgressBackup;
4683 EFI_STRING AccessResultsBackup;
4684 EFI_STRING DefaultResults;
4685 BOOLEAN FirstElement;
4686 BOOLEAN IfrDataParsedFlag;
4687 BOOLEAN IsEfiVarStore;
4688 EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo;
4689 EFI_STRING ErrorPtr;
4690 UINTN DevicePathSize;
4691 UINTN ConigStringSize;
4692 UINTN ConigStringSizeNewsize;
4693 EFI_STRING ConfigStringPtr;
4694
4695 if (This == NULL || Progress == NULL || Results == NULL) {
4696 return EFI_INVALID_PARAMETER;
4697 }
4698
4699 if (Request == NULL) {
4700 *Progress = NULL;
4701 return EFI_INVALID_PARAMETER;
4702 }
4703
4704 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
4705 StringPtr = Request;
4706 *Progress = StringPtr;
4707 DefaultResults = NULL;
4708 ConfigRequest = NULL;
4709 Status = EFI_SUCCESS;
4710 AccessResults = NULL;
4711 AccessProgress = NULL;
4712 AccessResultsBackup = NULL;
4713 AccessProgressBackup = NULL;
4714 DevicePath = NULL;
4715 IfrDataParsedFlag = FALSE;
4716 IsEfiVarStore = FALSE;
4717 EfiVarStoreInfo = NULL;
4718
4719 //
4720 // The first element of <MultiConfigRequest> should be
4721 // <GuidHdr>, which is in 'GUID='<Guid> syntax.
4722 //
4723 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
4724 return EFI_INVALID_PARAMETER;
4725 }
4726
4727 FirstElement = TRUE;
4728
4729 //
4730 // Allocate a fix length of memory to store Results. Reallocate memory for
4731 // Results if this fix length is insufficient.
4732 //
4733 *Results = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH);
4734 if (*Results == NULL) {
4735 return EFI_OUT_OF_RESOURCES;
4736 }
4737
4738 while (*StringPtr != 0 && StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) == 0) {
4739 //
4740 // If parsing error, set Progress to the beginning of the <MultiConfigRequest>
4741 // or most recent & before the error.
4742 //
4743 if (StringPtr == Request) {
4744 *Progress = StringPtr;
4745 } else {
4746 *Progress = StringPtr - 1;
4747 }
4748
4749 //
4750 // Process each <ConfigRequest> of <MultiConfigRequest>
4751 //
4752 Length = CalculateConfigStringLen (StringPtr);
4753 ConfigRequest = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), StringPtr);
4754 if (ConfigRequest == NULL) {
4755 Status = EFI_OUT_OF_RESOURCES;
4756 goto Done;
4757 }
4758 *(ConfigRequest + Length) = 0;
4759
4760 //
4761 // Get the UEFI device path
4762 //
4763 Status = GetDevicePath (ConfigRequest, (UINT8 **) &DevicePath);
4764 if (EFI_ERROR (Status)) {
4765 goto Done;
4766 }
4767
4768 //
4769 // Find driver which matches the routing data.
4770 //
4771 DriverHandle = NULL;
4772 HiiHandle = NULL;
4773 Database = NULL;
4774 for (Link = Private->DatabaseList.ForwardLink;
4775 Link != &Private->DatabaseList;
4776 Link = Link->ForwardLink
4777 ) {
4778 Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
4779 if ((DevicePathPkg = Database->PackageList->DevicePathPkg) != NULL) {
4780 CurrentDevicePath = DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER);
4781 DevicePathSize = GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath);
4782 if ((CompareMem (DevicePath,CurrentDevicePath,DevicePathSize) == 0) && IsThisPackageList(Database, ConfigRequest)) {
4783 DriverHandle = Database->DriverHandle;
4784 HiiHandle = Database->Handle;
4785 break;
4786 }
4787 }
4788 }
4789
4790 //
4791 // Try to find driver handle by device path.
4792 //
4793 if (DriverHandle == NULL) {
4794 TempDevicePath = DevicePath;
4795 Status = gBS->LocateDevicePath (
4796 &gEfiDevicePathProtocolGuid,
4797 &TempDevicePath,
4798 &DriverHandle
4799 );
4800 if (EFI_ERROR (Status) || (DriverHandle == NULL)) {
4801 //
4802 // Routing data does not match any known driver.
4803 // Set Progress to the 'G' in "GUID" of the routing header.
4804 //
4805 *Progress = StringPtr;
4806 Status = EFI_NOT_FOUND;
4807 goto Done;
4808 }
4809 }
4810
4811 //
4812 // Validate ConfigRequest String.
4813 //
4814 ErrorPtr = ConfigRequestValidate(ConfigRequest);
4815 if (ErrorPtr != NULL) {
4816 *Progress = StrStr (StringPtr, ErrorPtr);
4817 Status = EFI_INVALID_PARAMETER;
4818 goto Done;
4819 }
4820
4821 //
4822 // Check whether ConfigRequest contains request string.
4823 //
4824 IfrDataParsedFlag = FALSE;
4825 if ((HiiHandle != NULL) && !GetElementsFromRequest(ConfigRequest)) {
4826 //
4827 // Get the full request string from IFR when HiiPackage is registered to HiiHandle
4828 //
4829 IfrDataParsedFlag = TRUE;
4830 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &ConfigRequest, &DefaultResults, &AccessProgress);
4831 if (EFI_ERROR (Status)) {
4832 //
4833 // AccessProgress indicates the parsing progress on <ConfigRequest>.
4834 // Map it to the progress on <MultiConfigRequest> then return it.
4835 //
4836 ASSERT (AccessProgress != NULL);
4837 *Progress = StrStr (StringPtr, AccessProgress);
4838 goto Done;
4839 }
4840 //
4841 // Not any request block is found.
4842 //
4843 if (!GetElementsFromRequest(ConfigRequest)) {
4844 AccessResults = AllocateCopyPool (StrSize (ConfigRequest), ConfigRequest);
4845 goto NextConfigString;
4846 }
4847 }
4848
4849 //
4850 // Check whether this ConfigRequest is search from Efi varstore type storage.
4851 //
4852 Status = GetVarStoreType(Database, ConfigRequest, &IsEfiVarStore, &EfiVarStoreInfo);
4853 if (EFI_ERROR (Status)) {
4854 goto Done;
4855 }
4856
4857 if (IsEfiVarStore) {
4858 //
4859 // Call the GetVariable function to extract settings.
4860 //
4861 Status = GetConfigRespFromEfiVarStore(This, EfiVarStoreInfo, ConfigRequest, &AccessResults, &AccessProgress);
4862 FreePool (EfiVarStoreInfo);
4863 if (EFI_ERROR (Status)) {
4864 //
4865 // AccessProgress indicates the parsing progress on <ConfigRequest>.
4866 // Map it to the progress on <MultiConfigRequest> then return it.
4867 //
4868 *Progress = StrStr (StringPtr, AccessProgress);
4869 goto Done;
4870 }
4871
4872 //
4873 // For EfiVarstore, call corresponding ConfigAccess protocol to get the AltCfgResp from driver.
4874 //
4875 Status = gBS->HandleProtocol (
4876 DriverHandle,
4877 &gEfiHiiConfigAccessProtocolGuid,
4878 (VOID **) &ConfigAccess
4879 );
4880 if (EFI_ERROR (Status)) {
4881 //
4882 // The driver has EfiVarStore, may not install ConfigAccess protocol.
4883 // So ignore the error status in this case.
4884 //
4885 Status = EFI_SUCCESS;
4886 } else {
4887 Status = ConfigAccess->ExtractConfig (
4888 ConfigAccess,
4889 ConfigRequest,
4890 &AccessProgressBackup,
4891 &AccessResultsBackup
4892 );
4893 if (!EFI_ERROR(Status)) {
4894 //
4895 //Merge the AltCfgResp in AccessResultsBackup to AccessResults
4896 //
4897 if ((AccessResultsBackup != NULL) && (StrStr (AccessResultsBackup, L"&ALTCFG=") != NULL)) {
4898 ConigStringSize = StrSize (AccessResults);
4899 ConfigStringPtr = StrStr (AccessResultsBackup, L"&GUID=");
4900 ConigStringSizeNewsize = StrSize (ConfigStringPtr) + ConigStringSize + sizeof (CHAR16);
4901 AccessResults = (EFI_STRING) ReallocatePool (
4902 ConigStringSize,
4903 ConigStringSizeNewsize,
4904 AccessResults);
4905 StrCatS (AccessResults, ConigStringSizeNewsize / sizeof (CHAR16), ConfigStringPtr);
4906 }
4907 } else {
4908 //
4909 // In the ExtractConfig function of some driver may not support EfiVarStore,
4910 // may return error status, just ignore the error status in this case.
4911 //
4912 Status = EFI_SUCCESS;
4913 }
4914 if (AccessResultsBackup != NULL) {
4915 FreePool (AccessResultsBackup);
4916 AccessResultsBackup = NULL;
4917 }
4918 }
4919 } else {
4920 //
4921 // Call corresponding ConfigAccess protocol to extract settings
4922 //
4923 Status = gBS->HandleProtocol (
4924 DriverHandle,
4925 &gEfiHiiConfigAccessProtocolGuid,
4926 (VOID **) &ConfigAccess
4927 );
4928 if (EFI_ERROR (Status)) {
4929 goto Done;
4930 }
4931
4932 Status = ConfigAccess->ExtractConfig (
4933 ConfigAccess,
4934 ConfigRequest,
4935 &AccessProgress,
4936 &AccessResults
4937 );
4938 }
4939 if (EFI_ERROR (Status)) {
4940 //
4941 // AccessProgress indicates the parsing progress on <ConfigRequest>.
4942 // Map it to the progress on <MultiConfigRequest> then return it.
4943 //
4944 *Progress = StrStr (StringPtr, AccessProgress);
4945 goto Done;
4946 }
4947
4948 //
4949 // Attach this <ConfigAltResp> to a <MultiConfigAltResp>. There is a '&'
4950 // which separates the first <ConfigAltResp> and the following ones.
4951 //
4952 ASSERT (*AccessProgress == 0);
4953
4954 //
4955 // Update AccessResults by getting default setting from IFR when HiiPackage is registered to HiiHandle
4956 //
4957 if (!IfrDataParsedFlag && HiiHandle != NULL) {
4958 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &ConfigRequest, &DefaultResults, NULL);
4959 ASSERT_EFI_ERROR (Status);
4960 }
4961
4962 FreePool (DevicePath);
4963 DevicePath = NULL;
4964
4965 if (DefaultResults != NULL) {
4966 Status = MergeDefaultString (&AccessResults, DefaultResults);
4967 ASSERT_EFI_ERROR (Status);
4968 FreePool (DefaultResults);
4969 DefaultResults = NULL;
4970 }
4971
4972 NextConfigString:
4973 if (!FirstElement) {
4974 Status = AppendToMultiString (Results, L"&");
4975 ASSERT_EFI_ERROR (Status);
4976 }
4977
4978 Status = AppendToMultiString (Results, AccessResults);
4979 ASSERT_EFI_ERROR (Status);
4980
4981 FirstElement = FALSE;
4982
4983 FreePool (AccessResults);
4984 AccessResults = NULL;
4985 FreePool (ConfigRequest);
4986 ConfigRequest = NULL;
4987
4988 //
4989 // Go to next <ConfigRequest> (skip '&').
4990 //
4991 StringPtr += Length;
4992 if (*StringPtr == 0) {
4993 *Progress = StringPtr;
4994 break;
4995 }
4996
4997 StringPtr++;
4998 }
4999
5000 Done:
5001 if (EFI_ERROR (Status)) {
5002 FreePool (*Results);
5003 *Results = NULL;
5004 }
5005
5006 if (ConfigRequest != NULL) {
5007 FreePool (ConfigRequest);
5008 }
5009
5010 if (AccessResults != NULL) {
5011 FreePool (AccessResults);
5012 }
5013
5014 if (DefaultResults != NULL) {
5015 FreePool (DefaultResults);
5016 }
5017
5018 if (DevicePath != NULL) {
5019 FreePool (DevicePath);
5020 }
5021
5022 return Status;
5023 }
5024
5025
5026 /**
5027 This function allows the caller to request the current configuration for the
5028 entirety of the current HII database and returns the data in a
5029 null-terminated Unicode string.
5030
5031 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
5032 instance.
5033 @param Results Null-terminated Unicode string in
5034 <MultiConfigAltResp> format which has all values
5035 filled in for the entirety of the current HII
5036 database. String to be allocated by the called
5037 function. De-allocation is up to the caller.
5038
5039 @retval EFI_SUCCESS The Results string is filled with the values
5040 corresponding to all requested names.
5041 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the parts of the
5042 results that must be stored awaiting possible
5043 future protocols.
5044 @retval EFI_INVALID_PARAMETER For example, passing in a NULL for the Results
5045 parameter would result in this type of error.
5046
5047 **/
5048 EFI_STATUS
5049 EFIAPI
5050 HiiConfigRoutingExportConfig (
5051 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
5052 OUT EFI_STRING *Results
5053 )
5054 {
5055 EFI_STATUS Status;
5056 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;
5057 EFI_STRING AccessResults;
5058 EFI_STRING Progress;
5059 EFI_STRING StringPtr;
5060 EFI_STRING ConfigRequest;
5061 UINTN Index;
5062 EFI_HANDLE *ConfigAccessHandles;
5063 UINTN NumberConfigAccessHandles;
5064 BOOLEAN FirstElement;
5065 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
5066 EFI_HII_HANDLE HiiHandle;
5067 EFI_STRING DefaultResults;
5068 HII_DATABASE_PRIVATE_DATA *Private;
5069 LIST_ENTRY *Link;
5070 HII_DATABASE_RECORD *Database;
5071 UINT8 *DevicePathPkg;
5072 UINT8 *CurrentDevicePath;
5073 BOOLEAN IfrDataParsedFlag;
5074
5075 if (This == NULL || Results == NULL) {
5076 return EFI_INVALID_PARAMETER;
5077 }
5078
5079 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
5080
5081 //
5082 // Allocate a fix length of memory to store Results. Reallocate memory for
5083 // Results if this fix length is insufficient.
5084 //
5085 *Results = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH);
5086 if (*Results == NULL) {
5087 return EFI_OUT_OF_RESOURCES;
5088 }
5089
5090 NumberConfigAccessHandles = 0;
5091 Status = gBS->LocateHandleBuffer (
5092 ByProtocol,
5093 &gEfiHiiConfigAccessProtocolGuid,
5094 NULL,
5095 &NumberConfigAccessHandles,
5096 &ConfigAccessHandles
5097 );
5098 if (EFI_ERROR (Status)) {
5099 return Status;
5100 }
5101
5102 FirstElement = TRUE;
5103
5104 for (Index = 0; Index < NumberConfigAccessHandles; Index++) {
5105 Status = gBS->HandleProtocol (
5106 ConfigAccessHandles[Index],
5107 &gEfiHiiConfigAccessProtocolGuid,
5108 (VOID **) &ConfigAccess
5109 );
5110 if (EFI_ERROR (Status)) {
5111 continue;
5112 }
5113
5114 //
5115 // Get DevicePath and HiiHandle for this ConfigAccess driver handle
5116 //
5117 IfrDataParsedFlag = FALSE;
5118 Progress = NULL;
5119 HiiHandle = NULL;
5120 DefaultResults = NULL;
5121 Database = NULL;
5122 ConfigRequest = NULL;
5123 DevicePath = DevicePathFromHandle (ConfigAccessHandles[Index]);
5124 if (DevicePath != NULL) {
5125 for (Link = Private->DatabaseList.ForwardLink;
5126 Link != &Private->DatabaseList;
5127 Link = Link->ForwardLink
5128 ) {
5129 Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
5130 if ((DevicePathPkg = Database->PackageList->DevicePathPkg) != NULL) {
5131 CurrentDevicePath = DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER);
5132 if (CompareMem (
5133 DevicePath,
5134 CurrentDevicePath,
5135 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath)
5136 ) == 0) {
5137 HiiHandle = Database->Handle;
5138 break;
5139 }
5140 }
5141 }
5142 }
5143
5144 Status = ConfigAccess->ExtractConfig (
5145 ConfigAccess,
5146 NULL,
5147 &Progress,
5148 &AccessResults
5149 );
5150 if (EFI_ERROR (Status)) {
5151 //
5152 // Update AccessResults by getting default setting from IFR when HiiPackage is registered to HiiHandle
5153 //
5154 if (HiiHandle != NULL && DevicePath != NULL) {
5155 IfrDataParsedFlag = TRUE;
5156 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &ConfigRequest, &DefaultResults, NULL);
5157 //
5158 // Get the full request string to get the Current setting again.
5159 //
5160 if (!EFI_ERROR (Status) && ConfigRequest != NULL) {
5161 Status = ConfigAccess->ExtractConfig (
5162 ConfigAccess,
5163 ConfigRequest,
5164 &Progress,
5165 &AccessResults
5166 );
5167 FreePool (ConfigRequest);
5168 } else {
5169 Status = EFI_NOT_FOUND;
5170 }
5171 }
5172 }
5173
5174 if (!EFI_ERROR (Status)) {
5175 //
5176 // Update AccessResults by getting default setting from IFR when HiiPackage is registered to HiiHandle
5177 //
5178 if (!IfrDataParsedFlag && HiiHandle != NULL && DevicePath != NULL) {
5179 StringPtr = StrStr (AccessResults, L"&GUID=");
5180 if (StringPtr != NULL) {
5181 *StringPtr = 0;
5182 }
5183 if (GetElementsFromRequest (AccessResults)) {
5184 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &AccessResults, &DefaultResults, NULL);
5185 ASSERT_EFI_ERROR (Status);
5186 }
5187 if (StringPtr != NULL) {
5188 *StringPtr = L'&';
5189 }
5190 }
5191 //
5192 // Merge the default sting from IFR code into the got setting from driver.
5193 //
5194 if (DefaultResults != NULL) {
5195 Status = MergeDefaultString (&AccessResults, DefaultResults);
5196 ASSERT_EFI_ERROR (Status);
5197 FreePool (DefaultResults);
5198 DefaultResults = NULL;
5199 }
5200
5201 //
5202 // Attach this <ConfigAltResp> to a <MultiConfigAltResp>. There is a '&'
5203 // which separates the first <ConfigAltResp> and the following ones.
5204 //
5205 if (!FirstElement) {
5206 Status = AppendToMultiString (Results, L"&");
5207 ASSERT_EFI_ERROR (Status);
5208 }
5209
5210 Status = AppendToMultiString (Results, AccessResults);
5211 ASSERT_EFI_ERROR (Status);
5212
5213 FirstElement = FALSE;
5214
5215 FreePool (AccessResults);
5216 AccessResults = NULL;
5217 }
5218 }
5219 FreePool (ConfigAccessHandles);
5220
5221 return EFI_SUCCESS;
5222 }
5223
5224
5225 /**
5226 This function processes the results of processing forms and routes it to the
5227 appropriate handlers or storage.
5228
5229 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
5230 instance.
5231 @param Configuration A null-terminated Unicode string in
5232 <MulltiConfigResp> format.
5233 @param Progress A pointer to a string filled in with the offset of
5234 the most recent & before the first failing name /
5235 value pair (or the beginning of the string if the
5236 failure is in the first name / value pair) or the
5237 terminating NULL if all was successful.
5238
5239 @retval EFI_SUCCESS The results have been distributed or are awaiting
5240 distribution.
5241 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the parts of the
5242 results that must be stored awaiting possible
5243 future protocols.
5244 @retval EFI_INVALID_PARAMETER Passing in a NULL for the Configuration parameter
5245 would result in this type of error.
5246 @retval EFI_NOT_FOUND Target for the specified routing data was not
5247 found.
5248
5249 **/
5250 EFI_STATUS
5251 EFIAPI
5252 HiiConfigRoutingRouteConfig (
5253 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
5254 IN CONST EFI_STRING Configuration,
5255 OUT EFI_STRING *Progress
5256 )
5257 {
5258 HII_DATABASE_PRIVATE_DATA *Private;
5259 EFI_STRING StringPtr;
5260 EFI_STRING ConfigResp;
5261 UINTN Length;
5262 EFI_STATUS Status;
5263 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
5264 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
5265 LIST_ENTRY *Link;
5266 HII_DATABASE_RECORD *Database;
5267 UINT8 *DevicePathPkg;
5268 UINT8 *CurrentDevicePath;
5269 EFI_HANDLE DriverHandle;
5270 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;
5271 EFI_STRING AccessProgress;
5272 EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo;
5273 BOOLEAN IsEfiVarstore;
5274 UINTN DevicePathSize;
5275
5276 if (This == NULL || Progress == NULL) {
5277 return EFI_INVALID_PARAMETER;
5278 }
5279
5280 if (Configuration == NULL) {
5281 *Progress = NULL;
5282 return EFI_INVALID_PARAMETER;
5283 }
5284
5285 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
5286 StringPtr = Configuration;
5287 *Progress = StringPtr;
5288 Database = NULL;
5289 AccessProgress = NULL;
5290 EfiVarStoreInfo= NULL;
5291 IsEfiVarstore = FALSE;
5292
5293 //
5294 // The first element of <MultiConfigResp> should be
5295 // <GuidHdr>, which is in 'GUID='<Guid> syntax.
5296 //
5297 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
5298 return EFI_INVALID_PARAMETER;
5299 }
5300
5301 while (*StringPtr != 0 && StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) == 0) {
5302 //
5303 // If parsing error, set Progress to the beginning of the <MultiConfigResp>
5304 // or most recent & before the error.
5305 //
5306 if (StringPtr == Configuration) {
5307 *Progress = StringPtr;
5308 } else {
5309 *Progress = StringPtr - 1;
5310 }
5311
5312 //
5313 // Process each <ConfigResp> of <MultiConfigResp>
5314 //
5315 Length = CalculateConfigStringLen (StringPtr);
5316 ConfigResp = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), StringPtr);
5317 if (ConfigResp == NULL) {
5318 return EFI_OUT_OF_RESOURCES;
5319 }
5320 //
5321 // Append '\0' to the end of ConfigRequest
5322 //
5323 *(ConfigResp + Length) = 0;
5324
5325 //
5326 // Get the UEFI device path
5327 //
5328 Status = GetDevicePath (ConfigResp, (UINT8 **) &DevicePath);
5329 if (EFI_ERROR (Status)) {
5330 FreePool (ConfigResp);
5331 return Status;
5332 }
5333
5334 //
5335 // Find driver which matches the routing data.
5336 //
5337 DriverHandle = NULL;
5338 for (Link = Private->DatabaseList.ForwardLink;
5339 Link != &Private->DatabaseList;
5340 Link = Link->ForwardLink
5341 ) {
5342 Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
5343
5344 if ((DevicePathPkg = Database->PackageList->DevicePathPkg) != NULL) {
5345 CurrentDevicePath = DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER);
5346 DevicePathSize = GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath);
5347 if ((CompareMem (DevicePath,CurrentDevicePath,DevicePathSize) == 0) && IsThisPackageList(Database, ConfigResp)) {
5348 DriverHandle = Database->DriverHandle;
5349 break;
5350 }
5351 }
5352 }
5353
5354 //
5355 // Try to find driver handle by device path.
5356 //
5357 if (DriverHandle == NULL) {
5358 TempDevicePath = DevicePath;
5359 Status = gBS->LocateDevicePath (
5360 &gEfiDevicePathProtocolGuid,
5361 &TempDevicePath,
5362 &DriverHandle
5363 );
5364 if (EFI_ERROR (Status) || (DriverHandle == NULL)) {
5365 //
5366 // Routing data does not match any known driver.
5367 // Set Progress to the 'G' in "GUID" of the routing header.
5368 //
5369 FreePool (DevicePath);
5370 *Progress = StringPtr;
5371 FreePool (ConfigResp);
5372 return EFI_NOT_FOUND;
5373 }
5374 }
5375
5376 FreePool (DevicePath);
5377
5378 //
5379 // Check whether this ConfigRequest is search from Efi varstore type storage.
5380 //
5381 Status = GetVarStoreType(Database, ConfigResp, &IsEfiVarstore, &EfiVarStoreInfo);
5382 if (EFI_ERROR (Status)) {
5383 return Status;
5384 }
5385
5386 if (IsEfiVarstore) {
5387 //
5388 // Call the SetVariable function to route settings.
5389 //
5390 Status = RouteConfigRespForEfiVarStore(This, EfiVarStoreInfo, ConfigResp, &AccessProgress);
5391 FreePool (EfiVarStoreInfo);
5392 } else {
5393 //
5394 // Call corresponding ConfigAccess protocol to route settings
5395 //
5396 Status = gBS->HandleProtocol (
5397 DriverHandle,
5398 &gEfiHiiConfigAccessProtocolGuid,
5399 (VOID **) &ConfigAccess
5400 );
5401 if (EFI_ERROR (Status)) {
5402 *Progress = StringPtr;
5403 FreePool (ConfigResp);
5404 return EFI_NOT_FOUND;
5405 }
5406
5407 Status = ConfigAccess->RouteConfig (
5408 ConfigAccess,
5409 ConfigResp,
5410 &AccessProgress
5411 );
5412 }
5413 if (EFI_ERROR (Status)) {
5414 ASSERT (AccessProgress != NULL);
5415 //
5416 // AccessProgress indicates the parsing progress on <ConfigResp>.
5417 // Map it to the progress on <MultiConfigResp> then return it.
5418 //
5419 *Progress = StrStr (StringPtr, AccessProgress);
5420
5421 FreePool (ConfigResp);
5422 return Status;
5423 }
5424
5425 FreePool (ConfigResp);
5426 ConfigResp = NULL;
5427
5428 //
5429 // Go to next <ConfigResp> (skip '&').
5430 //
5431 StringPtr += Length;
5432 if (*StringPtr == 0) {
5433 *Progress = StringPtr;
5434 break;
5435 }
5436
5437 StringPtr++;
5438
5439 }
5440
5441 return EFI_SUCCESS;
5442 }
5443
5444
5445 /**
5446 This helper function is to be called by drivers to map configuration data
5447 stored in byte array ("block") formats such as UEFI Variables into current
5448 configuration strings.
5449
5450 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
5451 instance.
5452 @param ConfigRequest A null-terminated Unicode string in
5453 <ConfigRequest> format.
5454 @param Block Array of bytes defining the block's configuration.
5455 @param BlockSize Length in bytes of Block.
5456 @param Config Filled-in configuration string. String allocated
5457 by the function. Returned only if call is
5458 successful. It is <ConfigResp> string format.
5459 @param Progress A pointer to a string filled in with the offset of
5460 the most recent & before the first failing
5461 name/value pair (or the beginning of the string if
5462 the failure is in the first name / value pair) or
5463 the terminating NULL if all was successful.
5464
5465 @retval EFI_SUCCESS The request succeeded. Progress points to the null
5466 terminator at the end of the ConfigRequest
5467 string.
5468 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate Config. Progress
5469 points to the first character of ConfigRequest.
5470 @retval EFI_INVALID_PARAMETER Passing in a NULL for the ConfigRequest or
5471 Block parameter would result in this type of
5472 error. Progress points to the first character of
5473 ConfigRequest.
5474 @retval EFI_DEVICE_ERROR Block not large enough. Progress undefined.
5475 @retval EFI_INVALID_PARAMETER Encountered non <BlockName> formatted string.
5476 Block is left updated and Progress points at
5477 the "&" preceding the first non-<BlockName>.
5478
5479 **/
5480 EFI_STATUS
5481 EFIAPI
5482 HiiBlockToConfig (
5483 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
5484 IN CONST EFI_STRING ConfigRequest,
5485 IN CONST UINT8 *Block,
5486 IN CONST UINTN BlockSize,
5487 OUT EFI_STRING *Config,
5488 OUT EFI_STRING *Progress
5489 )
5490 {
5491 HII_DATABASE_PRIVATE_DATA *Private;
5492 EFI_STRING StringPtr;
5493 UINTN Length;
5494 EFI_STATUS Status;
5495 EFI_STRING TmpPtr;
5496 UINT8 *TmpBuffer;
5497 UINTN Offset;
5498 UINTN Width;
5499 UINT8 *Value;
5500 EFI_STRING ValueStr;
5501 EFI_STRING ConfigElement;
5502 UINTN Index;
5503 UINT8 *TemBuffer;
5504 CHAR16 *TemString;
5505 CHAR16 TemChar;
5506
5507 TmpBuffer = NULL;
5508
5509 if (This == NULL || Progress == NULL || Config == NULL) {
5510 return EFI_INVALID_PARAMETER;
5511 }
5512
5513 if (Block == NULL || ConfigRequest == NULL) {
5514 *Progress = ConfigRequest;
5515 return EFI_INVALID_PARAMETER;
5516 }
5517
5518
5519 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
5520 ASSERT (Private != NULL);
5521
5522 StringPtr = ConfigRequest;
5523 ValueStr = NULL;
5524 Value = NULL;
5525 ConfigElement = NULL;
5526
5527 //
5528 // Allocate a fix length of memory to store Results. Reallocate memory for
5529 // Results if this fix length is insufficient.
5530 //
5531 *Config = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH);
5532 if (*Config == NULL) {
5533 return EFI_OUT_OF_RESOURCES;
5534 }
5535
5536 //
5537 // Jump <ConfigHdr>
5538 //
5539 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
5540 *Progress = StringPtr;
5541 Status = EFI_INVALID_PARAMETER;
5542 goto Exit;
5543 }
5544 while (*StringPtr != 0 && StrnCmp (StringPtr, L"PATH=", StrLen (L"PATH=")) != 0) {
5545 StringPtr++;
5546 }
5547 if (*StringPtr == 0) {
5548 *Progress = StringPtr - 1;
5549 Status = EFI_INVALID_PARAMETER;
5550 goto Exit;
5551 }
5552
5553 while (*StringPtr != L'&' && *StringPtr != 0) {
5554 StringPtr++;
5555 }
5556 if (*StringPtr == 0) {
5557 *Progress = StringPtr;
5558
5559 AppendToMultiString(Config, ConfigRequest);
5560 HiiToLower (*Config);
5561
5562 return EFI_SUCCESS;
5563 }
5564 //
5565 // Skip '&'
5566 //
5567 StringPtr++;
5568
5569 //
5570 // Copy <ConfigHdr> and an additional '&' to <ConfigResp>
5571 //
5572 TemChar = *StringPtr;
5573 *StringPtr = '\0';
5574 AppendToMultiString(Config, ConfigRequest);
5575 *StringPtr = TemChar;
5576
5577 //
5578 // Parse each <RequestElement> if exists
5579 // Only <BlockName> format is supported by this help function.
5580 // <BlockName> ::= 'OFFSET='<Number>&'WIDTH='<Number>
5581 //
5582 while (*StringPtr != 0 && StrnCmp (StringPtr, L"OFFSET=", StrLen (L"OFFSET=")) == 0) {
5583 //
5584 // Back up the header of one <BlockName>
5585 //
5586 TmpPtr = StringPtr;
5587
5588 StringPtr += StrLen (L"OFFSET=");
5589 //
5590 // Get Offset
5591 //
5592 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
5593 if (EFI_ERROR (Status)) {
5594 *Progress = TmpPtr - 1;
5595 goto Exit;
5596 }
5597 Offset = 0;
5598 CopyMem (
5599 &Offset,
5600 TmpBuffer,
5601 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
5602 );
5603 FreePool (TmpBuffer);
5604
5605 StringPtr += Length;
5606 if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {
5607 *Progress = TmpPtr - 1;
5608 Status = EFI_INVALID_PARAMETER;
5609 goto Exit;
5610 }
5611 StringPtr += StrLen (L"&WIDTH=");
5612
5613 //
5614 // Get Width
5615 //
5616 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
5617 if (EFI_ERROR (Status)) {
5618 *Progress = TmpPtr - 1;
5619 goto Exit;
5620 }
5621 Width = 0;
5622 CopyMem (
5623 &Width,
5624 TmpBuffer,
5625 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
5626 );
5627 FreePool (TmpBuffer);
5628
5629 StringPtr += Length;
5630 if (*StringPtr != 0 && *StringPtr != L'&') {
5631 *Progress = TmpPtr - 1;
5632 Status = EFI_INVALID_PARAMETER;
5633 goto Exit;
5634 }
5635
5636 //
5637 // Calculate Value and convert it to hex string.
5638 //
5639 if (Offset + Width > BlockSize) {
5640 *Progress = StringPtr;
5641 Status = EFI_DEVICE_ERROR;
5642 goto Exit;
5643 }
5644
5645 Value = (UINT8 *) AllocateZeroPool (Width);
5646 if (Value == NULL) {
5647 *Progress = ConfigRequest;
5648 Status = EFI_OUT_OF_RESOURCES;
5649 goto Exit;
5650 }
5651
5652 CopyMem (Value, (UINT8 *) Block + Offset, Width);
5653
5654 Length = Width * 2 + 1;
5655 ValueStr = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16));
5656 if (ValueStr == NULL) {
5657 *Progress = ConfigRequest;
5658 Status = EFI_OUT_OF_RESOURCES;
5659 goto Exit;
5660 }
5661
5662 TemString = ValueStr;
5663 TemBuffer = Value + Width - 1;
5664 for (Index = 0; Index < Width; Index ++, TemBuffer --) {
5665 UnicodeValueToStringS (
5666 TemString,
5667 Length * sizeof (CHAR16) - ((UINTN)TemString - (UINTN)ValueStr),
5668 PREFIX_ZERO | RADIX_HEX,
5669 *TemBuffer,
5670 2
5671 );
5672 TemString += StrnLenS (TemString, Length - ((UINTN)TemString - (UINTN)ValueStr) / sizeof (CHAR16));
5673 }
5674
5675 FreePool (Value);
5676 Value = NULL;
5677
5678 //
5679 // Build a ConfigElement
5680 //
5681 Length += StringPtr - TmpPtr + 1 + StrLen (L"VALUE=");
5682 ConfigElement = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16));
5683 if (ConfigElement == NULL) {
5684 Status = EFI_OUT_OF_RESOURCES;
5685 goto Exit;
5686 }
5687 CopyMem (ConfigElement, TmpPtr, (StringPtr - TmpPtr + 1) * sizeof (CHAR16));
5688 if (*StringPtr == 0) {
5689 *(ConfigElement + (StringPtr - TmpPtr)) = L'&';
5690 }
5691 *(ConfigElement + (StringPtr - TmpPtr) + 1) = 0;
5692 StrCatS (ConfigElement, Length, L"VALUE=");
5693 StrCatS (ConfigElement, Length, ValueStr);
5694
5695 AppendToMultiString (Config, ConfigElement);
5696
5697 FreePool (ConfigElement);
5698 FreePool (ValueStr);
5699 ConfigElement = NULL;
5700 ValueStr = NULL;
5701
5702 //
5703 // If '\0', parsing is finished. Otherwise skip '&' to continue
5704 //
5705 if (*StringPtr == 0) {
5706 break;
5707 }
5708 AppendToMultiString (Config, L"&");
5709 StringPtr++;
5710
5711 }
5712
5713 if (*StringPtr != 0) {
5714 *Progress = StringPtr - 1;
5715 Status = EFI_INVALID_PARAMETER;
5716 goto Exit;
5717 }
5718
5719 HiiToLower (*Config);
5720 *Progress = StringPtr;
5721 return EFI_SUCCESS;
5722
5723 Exit:
5724 if (*Config != NULL) {
5725 FreePool (*Config);
5726 *Config = NULL;
5727 }
5728 if (ValueStr != NULL) {
5729 FreePool (ValueStr);
5730 }
5731 if (Value != NULL) {
5732 FreePool (Value);
5733 }
5734 if (ConfigElement != NULL) {
5735 FreePool (ConfigElement);
5736 }
5737
5738 return Status;
5739
5740 }
5741
5742
5743 /**
5744 This helper function is to be called by drivers to map configuration strings
5745 to configurations stored in byte array ("block") formats such as UEFI Variables.
5746
5747 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
5748 instance.
5749 @param ConfigResp A null-terminated Unicode string in <ConfigResp>
5750 format.
5751 @param Block A possibly null array of bytes representing the
5752 current block. Only bytes referenced in the
5753 ConfigResp string in the block are modified. If
5754 this parameter is null or if the *BlockSize
5755 parameter is (on input) shorter than required by
5756 the Configuration string, only the BlockSize
5757 parameter is updated and an appropriate status
5758 (see below) is returned.
5759 @param BlockSize The length of the Block in units of UINT8. On
5760 input, this is the size of the Block. On output,
5761 if successful, contains the largest index of the
5762 modified byte in the Block, or the required buffer
5763 size if the Block is not large enough.
5764 @param Progress On return, points to an element of the ConfigResp
5765 string filled in with the offset of the most
5766 recent '&' before the first failing name / value
5767 pair (or the beginning of the string if the
5768 failure is in the first name / value pair) or the
5769 terminating NULL if all was successful.
5770
5771 @retval EFI_SUCCESS The request succeeded. Progress points to the null
5772 terminator at the end of the ConfigResp string.
5773 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate Config. Progress
5774 points to the first character of ConfigResp.
5775 @retval EFI_INVALID_PARAMETER Passing in a NULL for the ConfigResp or
5776 Block parameter would result in this type of
5777 error. Progress points to the first character of
5778 ConfigResp.
5779 @retval EFI_INVALID_PARAMETER Encountered non <BlockName> formatted name /
5780 value pair. Block is left updated and
5781 Progress points at the '&' preceding the first
5782 non-<BlockName>.
5783 @retval EFI_BUFFER_TOO_SMALL Block not large enough. Progress undefined.
5784 BlockSize is updated with the required buffer size.
5785 @retval EFI_NOT_FOUND Target for the specified routing data was not found.
5786 Progress points to the "G" in "GUID" of the errant
5787 routing data.
5788
5789 **/
5790 EFI_STATUS
5791 EFIAPI
5792 HiiConfigToBlock (
5793 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
5794 IN CONST EFI_STRING ConfigResp,
5795 IN OUT UINT8 *Block,
5796 IN OUT UINTN *BlockSize,
5797 OUT EFI_STRING *Progress
5798 )
5799 {
5800 HII_DATABASE_PRIVATE_DATA *Private;
5801 EFI_STRING StringPtr;
5802 EFI_STRING TmpPtr;
5803 UINTN Length;
5804 EFI_STATUS Status;
5805 UINT8 *TmpBuffer;
5806 UINTN Offset;
5807 UINTN Width;
5808 UINT8 *Value;
5809 UINTN BufferSize;
5810 UINTN MaxBlockSize;
5811
5812 TmpBuffer = NULL;
5813
5814 if (This == NULL || BlockSize == NULL || Progress == NULL) {
5815 return EFI_INVALID_PARAMETER;
5816 }
5817
5818 *Progress = ConfigResp;
5819 if (ConfigResp == NULL) {
5820 return EFI_INVALID_PARAMETER;
5821 }
5822
5823 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
5824 ASSERT (Private != NULL);
5825
5826 StringPtr = ConfigResp;
5827 BufferSize = *BlockSize;
5828 Value = NULL;
5829 MaxBlockSize = 0;
5830
5831 //
5832 // Jump <ConfigHdr>
5833 //
5834 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
5835 *Progress = StringPtr;
5836 Status = EFI_INVALID_PARAMETER;
5837 goto Exit;
5838 }
5839 while (*StringPtr != 0 && StrnCmp (StringPtr, L"PATH=", StrLen (L"PATH=")) != 0) {
5840 StringPtr++;
5841 }
5842 if (*StringPtr == 0) {
5843 *Progress = StringPtr;
5844 Status = EFI_INVALID_PARAMETER;
5845 goto Exit;
5846 }
5847
5848 while (*StringPtr != L'&' && *StringPtr != 0) {
5849 StringPtr++;
5850 }
5851 if (*StringPtr == 0) {
5852 *Progress = StringPtr;
5853 Status = EFI_INVALID_PARAMETER;
5854 goto Exit;
5855 }
5856
5857 //
5858 // Parse each <ConfigElement> if exists
5859 // Only '&'<BlockConfig> format is supported by this help function.
5860 // <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE='<Number>
5861 //
5862 while (*StringPtr != 0 && StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) == 0) {
5863 TmpPtr = StringPtr;
5864 StringPtr += StrLen (L"&OFFSET=");
5865 //
5866 // Get Offset
5867 //
5868 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
5869 if (EFI_ERROR (Status)) {
5870 *Progress = TmpPtr;
5871 goto Exit;
5872 }
5873 Offset = 0;
5874 CopyMem (
5875 &Offset,
5876 TmpBuffer,
5877 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
5878 );
5879 FreePool (TmpBuffer);
5880
5881 StringPtr += Length;
5882 if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {
5883 *Progress = TmpPtr;
5884 Status = EFI_INVALID_PARAMETER;
5885 goto Exit;
5886 }
5887 StringPtr += StrLen (L"&WIDTH=");
5888
5889 //
5890 // Get Width
5891 //
5892 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
5893 if (EFI_ERROR (Status)) {
5894 *Progress = TmpPtr;
5895 goto Exit;
5896 }
5897 Width = 0;
5898 CopyMem (
5899 &Width,
5900 TmpBuffer,
5901 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
5902 );
5903 FreePool (TmpBuffer);
5904
5905 StringPtr += Length;
5906 if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) != 0) {
5907 *Progress = TmpPtr;
5908 Status = EFI_INVALID_PARAMETER;
5909 goto Exit;
5910 }
5911 StringPtr += StrLen (L"&VALUE=");
5912
5913 //
5914 // Get Value
5915 //
5916 Status = GetValueOfNumber (StringPtr, &Value, &Length);
5917 if (EFI_ERROR (Status)) {
5918 *Progress = TmpPtr;
5919 goto Exit;
5920 }
5921
5922 StringPtr += Length;
5923 if (*StringPtr != 0 && *StringPtr != L'&') {
5924 *Progress = TmpPtr;
5925 Status = EFI_INVALID_PARAMETER;
5926 goto Exit;
5927 }
5928
5929 //
5930 // Update the Block with configuration info
5931 //
5932 if ((Block != NULL) && (Offset + Width <= BufferSize)) {
5933 CopyMem (Block + Offset, Value, Width);
5934 }
5935 if (Offset + Width > MaxBlockSize) {
5936 MaxBlockSize = Offset + Width;
5937 }
5938
5939 FreePool (Value);
5940 Value = NULL;
5941
5942 //
5943 // If '\0', parsing is finished.
5944 //
5945 if (*StringPtr == 0) {
5946 break;
5947 }
5948 }
5949
5950 //
5951 // The input string is not ConfigResp format, return error.
5952 //
5953 if (*StringPtr != 0) {
5954 *Progress = StringPtr;
5955 Status = EFI_INVALID_PARAMETER;
5956 goto Exit;
5957 }
5958
5959 *Progress = StringPtr + StrLen (StringPtr);
5960 *BlockSize = MaxBlockSize - 1;
5961
5962 if (MaxBlockSize > BufferSize) {
5963 *BlockSize = MaxBlockSize;
5964 if (Block != NULL) {
5965 return EFI_BUFFER_TOO_SMALL;
5966 }
5967 }
5968
5969 if (Block == NULL) {
5970 *Progress = ConfigResp;
5971 return EFI_INVALID_PARAMETER;
5972 }
5973
5974 return EFI_SUCCESS;
5975
5976 Exit:
5977
5978 if (Value != NULL) {
5979 FreePool (Value);
5980 }
5981 return Status;
5982 }
5983
5984
5985 /**
5986 This helper function is to be called by drivers to extract portions of
5987 a larger configuration string.
5988
5989 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL
5990 instance.
5991 @param Configuration A null-terminated Unicode string in
5992 <MultiConfigAltResp> format.
5993 @param Guid A pointer to the GUID value to search for in the
5994 routing portion of the ConfigResp string when
5995 retrieving the requested data. If Guid is NULL,
5996 then all GUID values will be searched for.
5997 @param Name A pointer to the NAME value to search for in the
5998 routing portion of the ConfigResp string when
5999 retrieving the requested data. If Name is NULL,
6000 then all Name values will be searched for.
6001 @param DevicePath A pointer to the PATH value to search for in the
6002 routing portion of the ConfigResp string when
6003 retrieving the requested data. If DevicePath is
6004 NULL, then all DevicePath values will be searched
6005 for.
6006 @param AltCfgId A pointer to the ALTCFG value to search for in the
6007 routing portion of the ConfigResp string when
6008 retrieving the requested data. If this parameter
6009 is NULL, then the current setting will be
6010 retrieved.
6011 @param AltCfgResp A pointer to a buffer which will be allocated by
6012 the function which contains the retrieved string
6013 as requested. This buffer is only allocated if
6014 the call was successful. It is <ConfigResp> format.
6015
6016 @retval EFI_SUCCESS The request succeeded. The requested data was
6017 extracted and placed in the newly allocated
6018 AltCfgResp buffer.
6019 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate AltCfgResp.
6020 @retval EFI_INVALID_PARAMETER Any parameter is invalid.
6021 @retval EFI_NOT_FOUND Target for the specified routing data was not
6022 found.
6023
6024 **/
6025 EFI_STATUS
6026 EFIAPI
6027 HiiGetAltCfg (
6028 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
6029 IN CONST EFI_STRING Configuration,
6030 IN CONST EFI_GUID *Guid,
6031 IN CONST EFI_STRING Name,
6032 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
6033 IN CONST UINT16 *AltCfgId,
6034 OUT EFI_STRING *AltCfgResp
6035 )
6036 {
6037 EFI_STATUS Status;
6038 EFI_STRING StringPtr;
6039 EFI_STRING HdrStart;
6040 EFI_STRING HdrEnd;
6041 EFI_STRING TmpPtr;
6042 UINTN Length;
6043 EFI_STRING GuidStr;
6044 EFI_STRING NameStr;
6045 EFI_STRING PathStr;
6046 EFI_STRING AltIdStr;
6047 EFI_STRING Result;
6048 BOOLEAN GuidFlag;
6049 BOOLEAN NameFlag;
6050 BOOLEAN PathFlag;
6051
6052 HdrStart = NULL;
6053 HdrEnd = NULL;
6054 GuidStr = NULL;
6055 NameStr = NULL;
6056 PathStr = NULL;
6057 AltIdStr = NULL;
6058 Result = NULL;
6059 GuidFlag = FALSE;
6060 NameFlag = FALSE;
6061 PathFlag = FALSE;
6062
6063 if (This == NULL || Configuration == NULL || AltCfgResp == NULL) {
6064 return EFI_INVALID_PARAMETER;
6065 }
6066
6067 StringPtr = Configuration;
6068 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) {
6069 return EFI_INVALID_PARAMETER;
6070 }
6071
6072 //
6073 // Generate the sub string for later matching.
6074 //
6075 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) Guid, 1, &GuidStr);
6076 GenerateSubStr (
6077 L"PATH=",
6078 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) DevicePath),
6079 (VOID *) DevicePath,
6080 1,
6081 &PathStr
6082 );
6083 if (AltCfgId != NULL) {
6084 GenerateSubStr (L"ALTCFG=", sizeof (UINT16), (VOID *) AltCfgId, 3, &AltIdStr);
6085 }
6086 if (Name != NULL) {
6087 GenerateSubStr (L"NAME=", StrLen (Name) * sizeof (CHAR16), (VOID *) Name, 2, &NameStr);
6088 } else {
6089 GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr);
6090 }
6091
6092 while (*StringPtr != 0) {
6093 //
6094 // Try to match the GUID
6095 //
6096 if (!GuidFlag) {
6097 TmpPtr = StrStr (StringPtr, GuidStr);
6098 if (TmpPtr == NULL) {
6099 Status = EFI_NOT_FOUND;
6100 goto Exit;
6101 }
6102 HdrStart = TmpPtr;
6103
6104 //
6105 // Jump to <NameHdr>
6106 //
6107 if (Guid != NULL) {
6108 StringPtr = TmpPtr + StrLen (GuidStr);
6109 } else {
6110 StringPtr = StrStr (TmpPtr, L"NAME=");
6111 if (StringPtr == NULL) {
6112 Status = EFI_NOT_FOUND;
6113 goto Exit;
6114 }
6115 }
6116 GuidFlag = TRUE;
6117 }
6118
6119 //
6120 // Try to match the NAME
6121 //
6122 if (GuidFlag && !NameFlag) {
6123 if (StrnCmp (StringPtr, NameStr, StrLen (NameStr)) != 0) {
6124 GuidFlag = FALSE;
6125 } else {
6126 //
6127 // Jump to <PathHdr>
6128 //
6129 if (Name != NULL) {
6130 StringPtr += StrLen (NameStr);
6131 } else {
6132 StringPtr = StrStr (StringPtr, L"PATH=");
6133 if (StringPtr == NULL) {
6134 Status = EFI_NOT_FOUND;
6135 goto Exit;
6136 }
6137 }
6138 NameFlag = TRUE;
6139 }
6140 }
6141
6142 //
6143 // Try to match the DevicePath
6144 //
6145 if (GuidFlag && NameFlag && !PathFlag) {
6146 if (StrnCmp (StringPtr, PathStr, StrLen (PathStr)) != 0) {
6147 GuidFlag = FALSE;
6148 NameFlag = FALSE;
6149 } else {
6150 //
6151 // Jump to '&' before <DescHdr> or <ConfigBody>
6152 //
6153 if (DevicePath != NULL) {
6154 StringPtr += StrLen (PathStr);
6155 } else {
6156 StringPtr = StrStr (StringPtr, L"&");
6157 if (StringPtr == NULL) {
6158 Status = EFI_NOT_FOUND;
6159 goto Exit;
6160 }
6161 StringPtr ++;
6162 }
6163 PathFlag = TRUE;
6164 HdrEnd = StringPtr;
6165 }
6166 }
6167
6168 //
6169 // Try to match the AltCfgId
6170 //
6171 if (GuidFlag && NameFlag && PathFlag) {
6172 if (AltCfgId == NULL) {
6173 //
6174 // Return Current Setting when AltCfgId is NULL.
6175 //
6176 Status = OutputConfigBody (StringPtr, &Result);
6177 goto Exit;
6178 }
6179 //
6180 // Search the <ConfigAltResp> to get the <AltResp> with AltCfgId.
6181 //
6182 if (StrnCmp (StringPtr, AltIdStr, StrLen (AltIdStr)) != 0) {
6183 GuidFlag = FALSE;
6184 NameFlag = FALSE;
6185 PathFlag = FALSE;
6186 } else {
6187 //
6188 // Skip AltIdStr and &
6189 //
6190 StringPtr = StringPtr + StrLen (AltIdStr);
6191 Status = OutputConfigBody (StringPtr, &Result);
6192 goto Exit;
6193 }
6194 }
6195 }
6196
6197 Status = EFI_NOT_FOUND;
6198
6199 Exit:
6200 *AltCfgResp = NULL;
6201 if (!EFI_ERROR (Status) && (Result != NULL)) {
6202 //
6203 // Copy the <ConfigHdr> and <ConfigBody>
6204 //
6205 Length = HdrEnd - HdrStart + StrLen (Result) + 1;
6206 *AltCfgResp = AllocateZeroPool (Length * sizeof (CHAR16));
6207 if (*AltCfgResp == NULL) {
6208 Status = EFI_OUT_OF_RESOURCES;
6209 } else {
6210 StrnCpyS (*AltCfgResp, Length, HdrStart, HdrEnd - HdrStart);
6211 StrCatS (*AltCfgResp, Length, Result);
6212 Status = EFI_SUCCESS;
6213 }
6214 }
6215
6216 if (GuidStr != NULL) {
6217 FreePool (GuidStr);
6218 }
6219 if (NameStr != NULL) {
6220 FreePool (NameStr);
6221 }
6222 if (PathStr != NULL) {
6223 FreePool (PathStr);
6224 }
6225 if (AltIdStr != NULL) {
6226 FreePool (AltIdStr);
6227 }
6228 if (Result != NULL) {
6229 FreePool (Result);
6230 }
6231
6232 return Status;
6233
6234 }
6235
6236
EFI Development Kit II mirror for PVE