2 Implementation of interfaces function for EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL.
4 Copyright (c) 2015, 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
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.
16 #include "HiiDatabase.h"
18 extern HII_DATABASE_PRIVATE_DATA mPrivate
;
21 Convert the hex UNICODE %02x encoding of a UEFI device path to binary
22 from <PathHdr> of <MultiKeywordRequest>.
24 This is a internal function.
26 @param String MultiKeywordRequest string.
27 @param DevicePathData Binary of a UEFI device path.
28 @param NextString string follow the possible PathHdr string.
30 @retval EFI_INVALID_PARAMETER The device path is not valid or the incoming parameter is invalid.
31 @retval EFI_OUT_OF_RESOURCES Lake of resources to store neccesary structures.
32 @retval EFI_SUCCESS The device path is retrieved and translated to binary format.
33 The Input string not include PathHdr section.
39 OUT UINT8
**DevicePathData
,
40 OUT EFI_STRING
*NextString
45 UINT8
*DevicePathBuffer
;
49 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
51 ASSERT (NextString
!= NULL
&& DevicePathData
!= NULL
);
54 // KeywordRequest == NULL case.
57 *DevicePathData
= NULL
;
65 if (*String
== L
'&') {
70 // Find the 'PATH=' of <PathHdr>.
72 if (StrnCmp (String
, L
"PATH=", StrLen (L
"PATH=")) != 0) {
73 if (StrnCmp (String
, L
"KEYWORD=", StrLen (L
"KEYWORD=")) != 0) {
74 return EFI_INVALID_PARAMETER
;
77 // Not include PathHdr, return success and DevicePath = NULL.
79 *DevicePathData
= NULL
;
86 // Check whether path data does exist.
88 String
+= StrLen (L
"PATH=");
90 return EFI_INVALID_PARAMETER
;
95 // The content between 'PATH=' of <ConfigHdr> and '&' of next element
96 // or '\0' (end of configuration string) is the UNICODE %02x bytes encoding
97 // of UEFI device path.
99 for (Length
= 0; *String
!= 0 && *String
!= L
'&'; String
++, Length
++);
102 // Save the return next keyword string value.
104 *NextString
= String
;
107 // Check DevicePath Length
109 if (((Length
+ 1) / 2) < sizeof (EFI_DEVICE_PATH_PROTOCOL
)) {
110 return EFI_INVALID_PARAMETER
;
114 // The data in <PathHdr> is encoded as hex UNICODE %02x bytes in the same order
115 // as the device path resides in RAM memory.
116 // Translate the data into binary.
118 DevicePathBuffer
= (UINT8
*) AllocateZeroPool ((Length
+ 1) / 2);
119 if (DevicePathBuffer
== NULL
) {
120 return EFI_OUT_OF_RESOURCES
;
124 // Convert DevicePath
126 ZeroMem (TemStr
, sizeof (TemStr
));
127 for (Index
= 0; Index
< Length
; Index
++) {
128 TemStr
[0] = PathHdr
[Index
];
129 DigitUint8
= (UINT8
) StrHexToUint64 (TemStr
);
130 if ((Index
& 1) == 0) {
131 DevicePathBuffer
[Index
/2] = DigitUint8
;
133 DevicePathBuffer
[Index
/2] = (UINT8
) ((DevicePathBuffer
[Index
/2] << 4) + DigitUint8
);
138 // Validate DevicePath
140 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) DevicePathBuffer
;
141 while (!IsDevicePathEnd (DevicePath
)) {
142 if ((DevicePath
->Type
== 0) || (DevicePath
->SubType
== 0) || (DevicePathNodeLength (DevicePath
) < sizeof (EFI_DEVICE_PATH_PROTOCOL
))) {
144 // Invalid device path
146 FreePool (DevicePathBuffer
);
147 return EFI_INVALID_PARAMETER
;
149 DevicePath
= NextDevicePathNode (DevicePath
);
153 // return the device path
155 *DevicePathData
= DevicePathBuffer
;
161 Get NameSpace from the input NameSpaceId string.
163 This is a internal function.
165 @param String <NameSpaceId> format string.
166 @param NameSpace Return the name space string.
167 @param NextString Return the next string follow namespace.
169 @retval EFI_SUCCESS Get the namespace string success.
170 @retval EFI_INVALID_PARAMETER The NameSpaceId string not follow spec definition.
175 IN EFI_STRING String
,
176 OUT CHAR8
**NameSpace
,
177 OUT EFI_STRING
*NextString
182 ASSERT (NameSpace
!= NULL
);
187 // Input NameSpaceId == NULL
189 if (String
== NULL
) {
191 if (NextString
!= NULL
) {
198 // Skip '&' if exist.
200 if (*String
== L
'&') {
204 if (StrnCmp (String
, L
"NAMESPACE=", StrLen (L
"NAMESPACE=")) != 0) {
205 return EFI_INVALID_PARAMETER
;
207 String
+= StrLen (L
"NAMESPACE=");
209 TmpPtr
= StrStr (String
, L
"&");
210 if (TmpPtr
!= NULL
) {
213 if (NextString
!= NULL
) {
214 *NextString
= String
+ StrLen (String
);
218 // Input NameSpace is unicode string. The language in String package is ascii string.
219 // Here will convert the unicode string to ascii and save it.
221 *NameSpace
= AllocatePool (StrLen (String
) + 1);
222 if (*NameSpace
== NULL
) {
223 return EFI_OUT_OF_RESOURCES
;
225 UnicodeStrToAsciiStr (String
, *NameSpace
);
227 if (TmpPtr
!= NULL
) {
235 Get Keyword from the input KeywordRequest string.
237 This is a internal function.
239 @param String KeywordRequestformat string.
240 @param Keyword return the extract keyword string.
241 @param NextString return the next string follow this keyword sectin.
243 @retval EFI_SUCCESS Success to get the keyword string.
244 @retval EFI_INVALID_PARAMETER Parsr the input string return error.
249 IN EFI_STRING String
,
250 OUT EFI_STRING
*Keyword
,
251 OUT EFI_STRING
*NextString
256 ASSERT ((Keyword
!= NULL
) && (NextString
!= NULL
));
261 // KeywordRequest == NULL case.
263 if (String
== NULL
) {
270 // Skip '&' if exist.
272 if (*String
== L
'&') {
276 if (StrnCmp (String
, L
"KEYWORD=", StrLen (L
"KEYWORD=")) != 0) {
277 return EFI_INVALID_PARAMETER
;
280 String
+= StrLen (L
"KEYWORD=");
282 TmpPtr
= StrStr (String
, L
"&");
283 if (TmpPtr
!= NULL
) {
286 *NextString
= String
+ StrLen (String
);
288 *Keyword
= AllocateCopyPool (StrSize (String
), String
);
289 if (*Keyword
== NULL
) {
290 return EFI_OUT_OF_RESOURCES
;
293 if (TmpPtr
!= NULL
) {
301 Get value from the input KeywordRequest string.
303 This is a internal function.
305 @param String KeywordRequestformat string.
306 @param Value return the extract value string.
307 @param NextString return the next string follow this keyword sectin.
309 @retval EFI_SUCCESS Success to get the keyword string.
310 @retval EFI_INVALID_PARAMETER Parsr the input string return error.
315 IN EFI_STRING String
,
316 OUT EFI_STRING
*Value
,
317 OUT EFI_STRING
*NextString
322 ASSERT ((Value
!= NULL
) && (NextString
!= NULL
) && (String
!= NULL
));
325 // Skip '&' if exist.
327 if (*String
== L
'&') {
331 if (StrnCmp (String
, L
"VALUE=", StrLen (L
"VALUE=")) != 0) {
332 return EFI_INVALID_PARAMETER
;
335 String
+= StrLen (L
"VALUE=");
337 TmpPtr
= StrStr (String
, L
"&");
338 if (TmpPtr
!= NULL
) {
341 *NextString
= String
+ StrLen (String
);
343 *Value
= AllocateCopyPool (StrSize (String
), String
);
344 if (*Value
== NULL
) {
345 return EFI_OUT_OF_RESOURCES
;
348 if (TmpPtr
!= NULL
) {
356 Get filter from the input KeywordRequest string.
358 This is a internal function.
360 @param String KeywordRequestformat string.
361 @param FilterFlags return the filter condition.
362 @param NextString return the next string follow this keyword sectin.
364 @retval EFI_SUCCESS Success to get the keyword string.
365 @retval EFI_INVALID_PARAMETER Parsr the input string return error.
370 IN EFI_STRING String
,
371 OUT UINT8
*FilterFlags
,
372 OUT EFI_STRING
*NextString
379 ASSERT ((FilterFlags
!= NULL
) && (NextString
!= NULL
));
382 // String end, no filter section.
384 if (String
== NULL
) {
393 // Skip '&' if exist.
395 if (*String
== L
'&') {
399 if (StrnCmp (String
, L
"ReadOnly", StrLen (L
"ReadOnly")) == 0) {
401 // Find ReadOnly filter.
403 *FilterFlags
|= EFI_KEYWORD_FILTER_READONY
;
404 String
+= StrLen (L
"ReadOnly");
405 } else if (StrnCmp (String
, L
"ReadWrite", StrLen (L
"ReadWrite")) == 0) {
407 // Find ReadWrite filter.
409 *FilterFlags
|= EFI_KEYWORD_FILTER_REAWRITE
;
410 String
+= StrLen (L
"ReadWrite");
411 } else if (StrnCmp (String
, L
"Buffer", StrLen (L
"Buffer")) == 0) {
413 // Find Buffer Filter.
415 *FilterFlags
|= EFI_KEYWORD_FILTER_BUFFER
;
416 String
+= StrLen (L
"Buffer");
417 } else if (StrnCmp (String
, L
"Numeric", StrLen (L
"Numeric")) == 0) {
419 // Find Numeric Filter
421 String
+= StrLen (L
"Numeric");
422 if (*String
!= L
':') {
423 *FilterFlags
|= EFI_KEYWORD_FILTER_NUMERIC
;
428 *FilterFlags
|= EFI_KEYWORD_FILTER_NUMERIC_1
;
431 *FilterFlags
|= EFI_KEYWORD_FILTER_NUMERIC_2
;
434 *FilterFlags
|= EFI_KEYWORD_FILTER_NUMERIC_4
;
437 *FilterFlags
|= EFI_KEYWORD_FILTER_NUMERIC_8
;
447 // Check whether other filter item defined by Platform.
449 if ((StrnCmp (String
, L
"&PATH", StrLen (L
"&PATH")) == 0) ||
450 (StrnCmp (String
, L
"&KEYWORD", StrLen (L
"&KEYWORD")) == 0)) {
452 // New KeywordRequest start, no platform defined filter.
456 // Platform defined filter rule.
457 // Just skip platform defined filter rule, return success.
459 PathPtr
= StrStr(String
, L
"&PATH");
460 KeywordPtr
= StrStr(String
, L
"&KEYWORD");
461 if (PathPtr
!= NULL
&& KeywordPtr
!= NULL
) {
463 // If both sections exist, return the first follow string.
465 String
= KeywordPtr
> PathPtr
? PathPtr
: KeywordPtr
;
466 } else if (PathPtr
!= NULL
) {
468 // Should not exist PathPtr != NULL && KeywordPtr == NULL case.
471 } else if (KeywordPtr
!= NULL
) {
473 // Just to the next keyword section.
478 // Only has paltform defined filter section, just skip it.
480 String
+= StrLen (String
);
486 *NextString
= String
;
492 Extract Readonly flag from opcode.
494 This is a internal function.
496 @param OpCodeData Input opcode for this question.
498 @retval TRUE This question is readonly.
499 @retval FALSE This question is not readonly.
503 ExtractReadOnlyFromOpCode (
507 EFI_IFR_QUESTION_HEADER
*QuestionHdr
;
509 ASSERT (OpCodeData
!= NULL
);
511 QuestionHdr
= (EFI_IFR_QUESTION_HEADER
*) (OpCodeData
+ sizeof (EFI_IFR_OP_HEADER
));
513 return (QuestionHdr
->Flags
& EFI_IFR_FLAG_READ_ONLY
) != 0;
517 Create a circuit to check the filter section.
519 This is a internal function.
521 @param OpCodeData The questin binary ifr data.
522 @param KeywordRequest KeywordRequestformat string.
523 @param NextString return the next string follow this keyword sectin.
524 @param ReadOnly Return whether this question is read only.
526 @retval KEYWORD_HANDLER_NO_ERROR Success validate.
527 @retval KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED Validate fail.
532 IN UINT8
*OpCodeData
,
533 IN CHAR16
*KeywordRequest
,
534 OUT CHAR16
**NextString
,
535 OUT BOOLEAN
*ReadOnly
541 EFI_IFR_QUESTION_HEADER
*QuestionHdr
;
542 EFI_IFR_OP_HEADER
*OpCodeHdr
;
546 RetVal
= KEYWORD_HANDLER_NO_ERROR
;
547 StringPtr
= KeywordRequest
;
549 OpCodeHdr
= (EFI_IFR_OP_HEADER
*) OpCodeData
;
550 QuestionHdr
= (EFI_IFR_QUESTION_HEADER
*) (OpCodeData
+ sizeof (EFI_IFR_OP_HEADER
));
551 if (OpCodeHdr
->OpCode
== EFI_IFR_ONE_OF_OP
|| OpCodeHdr
->OpCode
== EFI_IFR_NUMERIC_OP
) {
552 Flags
= *(OpCodeData
+ sizeof (EFI_IFR_OP_HEADER
) + sizeof (EFI_IFR_QUESTION_HEADER
));
558 // Get ReadOnly flag from Question.
560 *ReadOnly
= ExtractReadOnlyFromOpCode(OpCodeData
);
562 while (ExtractFilter (StringPtr
, &FilterFlags
, &NextFilter
)) {
563 switch (FilterFlags
) {
564 case EFI_KEYWORD_FILTER_READONY
:
565 if ((QuestionHdr
->Flags
& EFI_IFR_FLAG_READ_ONLY
) == 0) {
566 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
571 case EFI_KEYWORD_FILTER_REAWRITE
:
572 if ((QuestionHdr
->Flags
& EFI_IFR_FLAG_READ_ONLY
) != 0) {
573 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
578 case EFI_KEYWORD_FILTER_BUFFER
:
580 // Only these three opcode use numeric value type.
582 if (OpCodeHdr
->OpCode
== EFI_IFR_ONE_OF_OP
|| OpCodeHdr
->OpCode
== EFI_IFR_NUMERIC_OP
|| OpCodeHdr
->OpCode
== EFI_IFR_CHECKBOX_OP
) {
583 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
588 case EFI_KEYWORD_FILTER_NUMERIC
:
589 if (OpCodeHdr
->OpCode
!= EFI_IFR_ONE_OF_OP
&& OpCodeHdr
->OpCode
!= EFI_IFR_NUMERIC_OP
&& OpCodeHdr
->OpCode
!= EFI_IFR_CHECKBOX_OP
) {
590 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
595 case EFI_KEYWORD_FILTER_NUMERIC_1
:
596 case EFI_KEYWORD_FILTER_NUMERIC_2
:
597 case EFI_KEYWORD_FILTER_NUMERIC_4
:
598 case EFI_KEYWORD_FILTER_NUMERIC_8
:
599 if (OpCodeHdr
->OpCode
!= EFI_IFR_ONE_OF_OP
&& OpCodeHdr
->OpCode
!= EFI_IFR_NUMERIC_OP
&& OpCodeHdr
->OpCode
!= EFI_IFR_CHECKBOX_OP
) {
600 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
605 // For numeric and oneof, it has flags field to specify the detail numeric type.
607 if (OpCodeHdr
->OpCode
== EFI_IFR_ONE_OF_OP
|| OpCodeHdr
->OpCode
== EFI_IFR_NUMERIC_OP
) {
608 switch (Flags
& EFI_IFR_NUMERIC_SIZE
) {
609 case EFI_IFR_NUMERIC_SIZE_1
:
610 if (FilterFlags
!= EFI_KEYWORD_FILTER_NUMERIC_1
) {
611 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
616 case EFI_IFR_NUMERIC_SIZE_2
:
617 if (FilterFlags
!= EFI_KEYWORD_FILTER_NUMERIC_2
) {
618 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
623 case EFI_IFR_NUMERIC_SIZE_4
:
624 if (FilterFlags
!= EFI_KEYWORD_FILTER_NUMERIC_4
) {
625 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
630 case EFI_IFR_NUMERIC_SIZE_8
:
631 if (FilterFlags
!= EFI_KEYWORD_FILTER_NUMERIC_8
) {
632 RetVal
= KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED
;
650 // Jump to the next filter.
652 StringPtr
= NextFilter
;
657 // The current filter which is processing.
659 *NextString
= StringPtr
;
665 Get HII_DATABASE_RECORD from the input device path info.
667 This is a internal function.
669 @param DevicePath UEFI device path protocol.
671 @retval Internal data base record.
674 HII_DATABASE_RECORD
*
675 GetRecordFromDevicePath (
676 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
680 UINT8
*DevicePathPkg
;
681 UINT8
*CurrentDevicePath
;
682 UINTN DevicePathSize
;
683 HII_DATABASE_RECORD
*TempDatabase
;
685 ASSERT (DevicePath
!= NULL
);
687 for (Link
= mPrivate
.DatabaseList
.ForwardLink
; Link
!= &mPrivate
.DatabaseList
; Link
= Link
->ForwardLink
) {
688 TempDatabase
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
689 DevicePathPkg
= TempDatabase
->PackageList
->DevicePathPkg
;
690 if (DevicePathPkg
!= NULL
) {
691 CurrentDevicePath
= DevicePathPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
);
692 DevicePathSize
= GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL
*) CurrentDevicePath
);
693 if ((CompareMem (DevicePath
, CurrentDevicePath
, DevicePathSize
) == 0)) {
703 Calculate the size of StringSrc and output it. Also copy string text from src
706 This is a internal function.
708 @param StringSrc Points to current null-terminated string.
709 @param BufferSize Length of the buffer.
710 @param StringDest Buffer to store the string text.
712 @retval EFI_SUCCESS The string text was outputed successfully.
713 @retval EFI_OUT_OF_RESOURCES Out of resource.
717 GetUnicodeStringTextAndSize (
719 OUT UINTN
*BufferSize
,
720 OUT EFI_STRING
*StringDest
726 ASSERT (StringSrc
!= NULL
&& BufferSize
!= NULL
&& StringDest
!= NULL
);
728 StringSize
= sizeof (CHAR16
);
729 StringPtr
= StringSrc
;
730 while (ReadUnaligned16 ((UINT16
*) StringPtr
) != 0) {
731 StringSize
+= sizeof (CHAR16
);
732 StringPtr
+= sizeof (CHAR16
);
735 *StringDest
= AllocatePool (StringSize
);
736 if (*StringDest
== NULL
) {
737 return EFI_OUT_OF_RESOURCES
;
740 CopyMem (*StringDest
, StringSrc
, StringSize
);
742 *BufferSize
= StringSize
;
747 Find the string id for the input keyword.
749 @param StringPackage Hii string package instance.
750 @param KeywordValue Input keyword value.
751 @param StringId The string's id, which is unique within PackageList.
754 @retval EFI_SUCCESS The string text and font is retrieved
756 @retval EFI_NOT_FOUND The specified text or font info can not be found
758 @retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
762 GetStringIdFromString (
763 IN HII_STRING_PACKAGE_INSTANCE
*StringPackage
,
764 IN CHAR16
*KeywordValue
,
765 OUT EFI_STRING_ID
*StringId
769 EFI_STRING_ID CurrentStringId
;
772 UINT8
*StringTextPtr
;
777 EFI_HII_SIBT_EXT2_BLOCK Ext2
;
781 CHAR8
*AsciiKeywordValue
;
784 ASSERT (StringPackage
!= NULL
&& KeywordValue
!= NULL
&& StringId
!= NULL
);
785 ASSERT (StringPackage
->Signature
== HII_STRING_PACKAGE_SIGNATURE
);
788 Status
= EFI_SUCCESS
;
790 BlockHdr
= StringPackage
->StringBlock
;
795 // Make a ascii keyword value for later use.
797 AsciiKeywordValue
= AllocatePool (StrLen (KeywordValue
) + 1);
798 if (AsciiKeywordValue
== NULL
) {
799 return EFI_OUT_OF_RESOURCES
;
801 UnicodeStrToAsciiStr(KeywordValue
, AsciiKeywordValue
);
803 while (*BlockHdr
!= EFI_HII_SIBT_END
) {
805 case EFI_HII_SIBT_STRING_SCSU
:
806 Offset
= sizeof (EFI_HII_STRING_BLOCK
);
807 StringTextPtr
= BlockHdr
+ Offset
;
808 BlockSize
+= Offset
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
809 if (AsciiStrCmp(AsciiKeywordValue
, (CHAR8
*) StringTextPtr
) == 0) {
810 *StringId
= CurrentStringId
;
816 case EFI_HII_SIBT_STRING_SCSU_FONT
:
817 Offset
= sizeof (EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK
) - sizeof (UINT8
);
818 StringTextPtr
= BlockHdr
+ Offset
;
819 if (AsciiStrCmp(AsciiKeywordValue
, (CHAR8
*) StringTextPtr
) == 0) {
820 *StringId
= CurrentStringId
;
823 BlockSize
+= Offset
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
827 case EFI_HII_SIBT_STRINGS_SCSU
:
828 CopyMem (&StringCount
, BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
), sizeof (UINT16
));
829 StringTextPtr
= (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_SIBT_STRINGS_SCSU_BLOCK
) - sizeof (UINT8
));
830 BlockSize
+= StringTextPtr
- BlockHdr
;
832 for (Index
= 0; Index
< StringCount
; Index
++) {
833 BlockSize
+= AsciiStrSize ((CHAR8
*) StringTextPtr
);
834 if (AsciiStrCmp(AsciiKeywordValue
, (CHAR8
*) StringTextPtr
) == 0) {
835 *StringId
= CurrentStringId
;
838 StringTextPtr
= StringTextPtr
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
843 case EFI_HII_SIBT_STRINGS_SCSU_FONT
:
846 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
849 StringTextPtr
= (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK
) - sizeof (UINT8
));
850 BlockSize
+= StringTextPtr
- BlockHdr
;
852 for (Index
= 0; Index
< StringCount
; Index
++) {
853 BlockSize
+= AsciiStrSize ((CHAR8
*) StringTextPtr
);
854 if (AsciiStrCmp(AsciiKeywordValue
, (CHAR8
*) StringTextPtr
) == 0) {
855 *StringId
= CurrentStringId
;
858 StringTextPtr
= StringTextPtr
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
863 case EFI_HII_SIBT_STRING_UCS2
:
864 Offset
= sizeof (EFI_HII_STRING_BLOCK
);
865 StringTextPtr
= BlockHdr
+ Offset
;
867 // Use StringSize to store the size of the specified string, including the NULL
870 Status
= GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
871 if (EFI_ERROR (Status
)) {
875 if (StrCmp(KeywordValue
, String
) == 0) {
876 *StringId
= CurrentStringId
;
879 BlockSize
+= Offset
+ StringSize
;
883 case EFI_HII_SIBT_STRING_UCS2_FONT
:
884 Offset
= sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK
) - sizeof (CHAR16
);
885 StringTextPtr
= BlockHdr
+ Offset
;
887 // Use StringSize to store the size of the specified string, including the NULL
890 Status
= GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
891 if (EFI_ERROR (Status
)) {
895 if (StrCmp(KeywordValue
, String
) == 0) {
896 *StringId
= CurrentStringId
;
899 BlockSize
+= Offset
+ StringSize
;
903 case EFI_HII_SIBT_STRINGS_UCS2
:
904 Offset
= sizeof (EFI_HII_SIBT_STRINGS_UCS2_BLOCK
) - sizeof (CHAR16
);
905 StringTextPtr
= BlockHdr
+ Offset
;
907 CopyMem (&StringCount
, BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
), sizeof (UINT16
));
908 for (Index
= 0; Index
< StringCount
; Index
++) {
909 Status
= GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
910 if (EFI_ERROR (Status
)) {
914 BlockSize
+= StringSize
;
915 if (StrCmp(KeywordValue
, String
) == 0) {
916 *StringId
= CurrentStringId
;
919 StringTextPtr
= StringTextPtr
+ StringSize
;
924 case EFI_HII_SIBT_STRINGS_UCS2_FONT
:
925 Offset
= sizeof (EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK
) - sizeof (CHAR16
);
926 StringTextPtr
= BlockHdr
+ Offset
;
930 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
933 for (Index
= 0; Index
< StringCount
; Index
++) {
934 Status
= GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
935 if (EFI_ERROR (Status
)) {
939 BlockSize
+= StringSize
;
940 if (StrCmp(KeywordValue
, String
) == 0) {
941 *StringId
= CurrentStringId
;
944 StringTextPtr
= StringTextPtr
+ StringSize
;
949 case EFI_HII_SIBT_DUPLICATE
:
950 BlockSize
+= sizeof (EFI_HII_SIBT_DUPLICATE_BLOCK
);
954 case EFI_HII_SIBT_SKIP1
:
955 SkipCount
= (UINT16
) (*(UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
)));
956 CurrentStringId
= (UINT16
) (CurrentStringId
+ SkipCount
);
957 BlockSize
+= sizeof (EFI_HII_SIBT_SKIP1_BLOCK
);
960 case EFI_HII_SIBT_SKIP2
:
961 CopyMem (&SkipCount
, BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
), sizeof (UINT16
));
962 CurrentStringId
= (UINT16
) (CurrentStringId
+ SkipCount
);
963 BlockSize
+= sizeof (EFI_HII_SIBT_SKIP2_BLOCK
);
966 case EFI_HII_SIBT_EXT1
:
969 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
972 BlockSize
+= Length8
;
975 case EFI_HII_SIBT_EXT2
:
976 CopyMem (&Ext2
, BlockHdr
, sizeof (EFI_HII_SIBT_EXT2_BLOCK
));
977 BlockSize
+= Ext2
.Length
;
980 case EFI_HII_SIBT_EXT4
:
983 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
987 BlockSize
+= Length32
;
994 if (String
!= NULL
) {
999 BlockHdr
= StringPackage
->StringBlock
+ BlockSize
;
1002 Status
= EFI_NOT_FOUND
;
1005 if (AsciiKeywordValue
!= NULL
) {
1006 FreePool (AsciiKeywordValue
);
1008 if (String
!= NULL
) {
1015 Find the next valid string id for the input string id.
1017 @param StringPackage Hii string package instance.
1018 @param StringId The current string id which is already got.
1019 1 means just begin to get the string id.
1020 @param KeywordValue Return the string for the next string id.
1023 @retval EFI_STRING_ID Not 0 means a valid stringid found.
1024 0 means not found a valid string id.
1028 IN HII_STRING_PACKAGE_INSTANCE
*StringPackage
,
1029 IN EFI_STRING_ID StringId
,
1030 OUT EFI_STRING
*KeywordValue
1034 EFI_STRING_ID CurrentStringId
;
1037 UINT8
*StringTextPtr
;
1042 EFI_HII_SIBT_EXT2_BLOCK Ext2
;
1048 ASSERT (StringPackage
!= NULL
);
1049 ASSERT (StringPackage
->Signature
== HII_STRING_PACKAGE_SIGNATURE
);
1051 CurrentStringId
= 1;
1056 // Parse the string blocks to get the string text and font.
1058 BlockHdr
= StringPackage
->StringBlock
;
1061 while (*BlockHdr
!= EFI_HII_SIBT_END
) {
1062 switch (*BlockHdr
) {
1063 case EFI_HII_SIBT_STRING_SCSU
:
1064 Offset
= sizeof (EFI_HII_STRING_BLOCK
);
1065 StringTextPtr
= BlockHdr
+ Offset
;
1068 *KeywordValue
= AllocatePool (AsciiStrSize ((CHAR8
*) StringTextPtr
) * sizeof (CHAR16
));
1069 if (*KeywordValue
== NULL
) {
1072 AsciiStrToUnicodeStr ((CHAR8
*) StringTextPtr
, *KeywordValue
);
1073 return CurrentStringId
;
1074 } else if (CurrentStringId
== StringId
) {
1078 BlockSize
+= Offset
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
1082 case EFI_HII_SIBT_STRING_SCSU_FONT
:
1083 Offset
= sizeof (EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK
) - sizeof (UINT8
);
1084 StringTextPtr
= BlockHdr
+ Offset
;
1087 *KeywordValue
= AllocatePool (AsciiStrSize ((CHAR8
*) StringTextPtr
) * sizeof (CHAR16
));
1088 if (*KeywordValue
== NULL
) {
1091 AsciiStrToUnicodeStr ((CHAR8
*) StringTextPtr
, *KeywordValue
);
1092 return CurrentStringId
;
1093 } else if (CurrentStringId
== StringId
) {
1097 BlockSize
+= Offset
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
1101 case EFI_HII_SIBT_STRINGS_SCSU
:
1102 CopyMem (&StringCount
, BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
), sizeof (UINT16
));
1103 StringTextPtr
= (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_SIBT_STRINGS_SCSU_BLOCK
) - sizeof (UINT8
));
1104 BlockSize
+= StringTextPtr
- BlockHdr
;
1106 for (Index
= 0; Index
< StringCount
; Index
++) {
1108 *KeywordValue
= AllocatePool (AsciiStrSize ((CHAR8
*) StringTextPtr
) * sizeof (CHAR16
));
1109 if (*KeywordValue
== NULL
) {
1112 AsciiStrToUnicodeStr ((CHAR8
*) StringTextPtr
, *KeywordValue
);
1113 return CurrentStringId
;
1114 } else if (CurrentStringId
== StringId
) {
1118 BlockSize
+= AsciiStrSize ((CHAR8
*) StringTextPtr
);
1119 StringTextPtr
= StringTextPtr
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
1124 case EFI_HII_SIBT_STRINGS_SCSU_FONT
:
1127 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
1130 StringTextPtr
= (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK
) - sizeof (UINT8
));
1131 BlockSize
+= StringTextPtr
- BlockHdr
;
1133 for (Index
= 0; Index
< StringCount
; Index
++) {
1135 *KeywordValue
= AllocatePool (AsciiStrSize ((CHAR8
*) StringTextPtr
) * sizeof (CHAR16
));
1136 if (*KeywordValue
== NULL
) {
1139 AsciiStrToUnicodeStr ((CHAR8
*) StringTextPtr
, *KeywordValue
);
1140 return CurrentStringId
;
1141 } else if (CurrentStringId
== StringId
) {
1145 BlockSize
+= AsciiStrSize ((CHAR8
*) StringTextPtr
);
1146 StringTextPtr
= StringTextPtr
+ AsciiStrSize ((CHAR8
*) StringTextPtr
);
1151 case EFI_HII_SIBT_STRING_UCS2
:
1152 Offset
= sizeof (EFI_HII_STRING_BLOCK
);
1153 StringTextPtr
= BlockHdr
+ Offset
;
1155 // Use StringSize to store the size of the specified string, including the NULL
1158 GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
1159 if (FindString
&& (String
!= NULL
) && (*String
!= L
'\0')) {
1161 // String protocol use this type for the string id which has value for other package.
1162 // It will allocate an empty string block for this string id. so here we also check
1163 // *String != L'\0' to prohibit this case.
1165 *KeywordValue
= String
;
1166 return CurrentStringId
;
1167 } else if (CurrentStringId
== StringId
) {
1171 BlockSize
+= Offset
+ StringSize
;
1175 case EFI_HII_SIBT_STRING_UCS2_FONT
:
1176 Offset
= sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK
) - sizeof (CHAR16
);
1177 StringTextPtr
= BlockHdr
+ Offset
;
1179 // Use StringSize to store the size of the specified string, including the NULL
1182 GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
1184 *KeywordValue
= String
;
1185 return CurrentStringId
;
1186 } else if (CurrentStringId
== StringId
) {
1190 BlockSize
+= Offset
+ StringSize
;
1194 case EFI_HII_SIBT_STRINGS_UCS2
:
1195 Offset
= sizeof (EFI_HII_SIBT_STRINGS_UCS2_BLOCK
) - sizeof (CHAR16
);
1196 StringTextPtr
= BlockHdr
+ Offset
;
1197 BlockSize
+= Offset
;
1198 CopyMem (&StringCount
, BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
), sizeof (UINT16
));
1199 for (Index
= 0; Index
< StringCount
; Index
++) {
1200 GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
1203 *KeywordValue
= String
;
1204 return CurrentStringId
;
1205 } else if (CurrentStringId
== StringId
) {
1209 BlockSize
+= StringSize
;
1210 StringTextPtr
= StringTextPtr
+ StringSize
;
1215 case EFI_HII_SIBT_STRINGS_UCS2_FONT
:
1216 Offset
= sizeof (EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK
) - sizeof (CHAR16
);
1217 StringTextPtr
= BlockHdr
+ Offset
;
1218 BlockSize
+= Offset
;
1221 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
1224 for (Index
= 0; Index
< StringCount
; Index
++) {
1225 GetUnicodeStringTextAndSize (StringTextPtr
, &StringSize
, &String
);
1227 *KeywordValue
= String
;
1228 return CurrentStringId
;
1229 } else if (CurrentStringId
== StringId
) {
1233 BlockSize
+= StringSize
;
1234 StringTextPtr
= StringTextPtr
+ StringSize
;
1239 case EFI_HII_SIBT_DUPLICATE
:
1240 BlockSize
+= sizeof (EFI_HII_SIBT_DUPLICATE_BLOCK
);
1244 case EFI_HII_SIBT_SKIP1
:
1245 SkipCount
= (UINT16
) (*(UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
)));
1246 CurrentStringId
= (UINT16
) (CurrentStringId
+ SkipCount
);
1247 BlockSize
+= sizeof (EFI_HII_SIBT_SKIP1_BLOCK
);
1250 case EFI_HII_SIBT_SKIP2
:
1251 CopyMem (&SkipCount
, BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
), sizeof (UINT16
));
1252 CurrentStringId
= (UINT16
) (CurrentStringId
+ SkipCount
);
1253 BlockSize
+= sizeof (EFI_HII_SIBT_SKIP2_BLOCK
);
1256 case EFI_HII_SIBT_EXT1
:
1259 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
1262 BlockSize
+= Length8
;
1265 case EFI_HII_SIBT_EXT2
:
1266 CopyMem (&Ext2
, BlockHdr
, sizeof (EFI_HII_SIBT_EXT2_BLOCK
));
1267 BlockSize
+= Ext2
.Length
;
1270 case EFI_HII_SIBT_EXT4
:
1273 (UINT8
*)((UINTN
)BlockHdr
+ sizeof (EFI_HII_STRING_BLOCK
) + sizeof (UINT8
)),
1277 BlockSize
+= Length32
;
1284 if (String
!= NULL
) {
1289 BlockHdr
= StringPackage
->StringBlock
+ BlockSize
;
1296 Get string package from the input NameSpace string.
1298 This is a internal function.
1300 @param DatabaseRecord HII_DATABASE_RECORD format string.
1301 @param NameSpace NameSpace format string.
1302 @param KeywordValue Keyword value.
1303 @param StringId String Id for this keyword.
1305 @retval KEYWORD_HANDLER_NO_ERROR Get String id succes.
1306 @retval KEYWORD_HANDLER_KEYWORD_NOT_FOUND Not found the string id in the string package.
1307 @retval KEYWORD_HANDLER_NAMESPACE_ID_NOT_FOUND Not found the string package for this namespace.
1308 @retval KEYWORD_HANDLER_UNDEFINED_PROCESSING_ERROR Out of resource error.
1312 GetStringIdFromRecord (
1313 IN HII_DATABASE_RECORD
*DatabaseRecord
,
1314 IN CHAR8
**NameSpace
,
1315 IN CHAR16
*KeywordValue
,
1316 OUT EFI_STRING_ID
*StringId
1320 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageListNode
;
1321 HII_STRING_PACKAGE_INSTANCE
*StringPackage
;
1326 ASSERT (DatabaseRecord
!= NULL
&& NameSpace
!= NULL
&& KeywordValue
!= NULL
);
1328 PackageListNode
= DatabaseRecord
->PackageList
;
1329 RetVal
= KEYWORD_HANDLER_NAMESPACE_ID_NOT_FOUND
;
1331 if (*NameSpace
!= NULL
) {
1334 Name
= UEFI_CONFIG_LANG
;
1337 for (Link
= PackageListNode
->StringPkgHdr
.ForwardLink
; Link
!= &PackageListNode
->StringPkgHdr
; Link
= Link
->ForwardLink
) {
1338 StringPackage
= CR (Link
, HII_STRING_PACKAGE_INSTANCE
, StringEntry
, HII_STRING_PACKAGE_SIGNATURE
);
1340 if (AsciiStrnCmp(Name
, StringPackage
->StringPkgHdr
->Language
, AsciiStrLen (Name
)) == 0) {
1341 Status
= GetStringIdFromString (StringPackage
, KeywordValue
, StringId
);
1342 if (EFI_ERROR (Status
)) {
1343 return KEYWORD_HANDLER_KEYWORD_NOT_FOUND
;
1345 if (*NameSpace
== NULL
) {
1346 *NameSpace
= AllocateCopyPool (AsciiStrSize (StringPackage
->StringPkgHdr
->Language
), StringPackage
->StringPkgHdr
->Language
);
1347 if (*NameSpace
== NULL
) {
1348 return KEYWORD_HANDLER_UNDEFINED_PROCESSING_ERROR
;
1351 return KEYWORD_HANDLER_NO_ERROR
;
1360 Tell whether this Operand is an Statement OpCode.
1362 @param Operand Operand of an IFR OpCode.
1364 @retval TRUE This is an Statement OpCode.
1365 @retval FALSE Not an Statement OpCode.
1373 if ((Operand
== EFI_IFR_SUBTITLE_OP
) ||
1374 (Operand
== EFI_IFR_TEXT_OP
) ||
1375 (Operand
== EFI_IFR_RESET_BUTTON_OP
) ||
1376 (Operand
== EFI_IFR_REF_OP
) ||
1377 (Operand
== EFI_IFR_ACTION_OP
) ||
1378 (Operand
== EFI_IFR_NUMERIC_OP
) ||
1379 (Operand
== EFI_IFR_ORDERED_LIST_OP
) ||
1380 (Operand
== EFI_IFR_CHECKBOX_OP
) ||
1381 (Operand
== EFI_IFR_STRING_OP
) ||
1382 (Operand
== EFI_IFR_PASSWORD_OP
) ||
1383 (Operand
== EFI_IFR_DATE_OP
) ||
1384 (Operand
== EFI_IFR_TIME_OP
) ||
1385 (Operand
== EFI_IFR_GUID_OP
) ||
1386 (Operand
== EFI_IFR_ONE_OF_OP
)) {
1394 Tell whether this Operand is an Statement OpCode.
1396 @param Operand Operand of an IFR OpCode.
1398 @retval TRUE This is an Statement OpCode.
1399 @retval FALSE Not an Statement OpCode.
1407 if ((Operand
== EFI_IFR_VARSTORE_OP
) ||
1408 (Operand
== EFI_IFR_VARSTORE_NAME_VALUE_OP
) ||
1409 (Operand
== EFI_IFR_VARSTORE_EFI_OP
)) {
1417 Base on the prompt string id to find the question.
1419 @param FormPackage The input form package.
1420 @param KeywordStrId The input prompt string id for one question.
1422 @retval the opcode for the question.
1426 FindQuestionFromStringId (
1427 IN HII_IFR_PACKAGE_INSTANCE
*FormPackage
,
1428 IN EFI_STRING_ID KeywordStrId
1433 EFI_IFR_STATEMENT_HEADER
*StatementHeader
;
1434 EFI_IFR_OP_HEADER
*OpCodeHeader
;
1437 ASSERT (FormPackage
!= NULL
);
1439 FormDataLen
= FormPackage
->FormPkgHdr
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
);
1441 while (Offset
< FormDataLen
) {
1442 OpCodeData
= FormPackage
->IfrData
+ Offset
;
1443 OpCodeHeader
= (EFI_IFR_OP_HEADER
*) OpCodeData
;
1445 if (IsStatementOpCode(OpCodeHeader
->OpCode
)) {
1446 StatementHeader
= (EFI_IFR_STATEMENT_HEADER
*) (OpCodeData
+ sizeof (EFI_IFR_OP_HEADER
));
1447 if (StatementHeader
->Prompt
== KeywordStrId
) {
1452 Offset
+= OpCodeHeader
->Length
;
1459 Base on the varstore id to find the storage info.
1461 @param FormPackage The input form package.
1462 @param VarStoreId The input storage id.
1464 @retval the opcode for the storage.
1468 FindStorageFromVarId (
1469 IN HII_IFR_PACKAGE_INSTANCE
*FormPackage
,
1470 IN EFI_VARSTORE_ID VarStoreId
1475 EFI_IFR_OP_HEADER
*OpCodeHeader
;
1478 ASSERT (FormPackage
!= NULL
);
1480 FormDataLen
= FormPackage
->FormPkgHdr
.Length
- sizeof (EFI_HII_PACKAGE_HEADER
);
1482 while (Offset
< FormDataLen
) {
1483 OpCodeData
= FormPackage
->IfrData
+ Offset
;
1484 OpCodeHeader
= (EFI_IFR_OP_HEADER
*) OpCodeData
;
1486 if (IsStorageOpCode(OpCodeHeader
->OpCode
)) {
1487 switch (OpCodeHeader
->OpCode
) {
1488 case EFI_IFR_VARSTORE_OP
:
1489 if (VarStoreId
== ((EFI_IFR_VARSTORE
*) OpCodeData
)->VarStoreId
) {
1494 case EFI_IFR_VARSTORE_NAME_VALUE_OP
:
1495 if (VarStoreId
== ((EFI_IFR_VARSTORE_NAME_VALUE
*) OpCodeData
)->VarStoreId
) {
1500 case EFI_IFR_VARSTORE_EFI_OP
:
1501 if (VarStoreId
== ((EFI_IFR_VARSTORE_EFI
*) OpCodeData
)->VarStoreId
) {
1511 Offset
+= OpCodeHeader
->Length
;
1518 Get width info for one question.
1520 @param OpCodeData The input opcode for one question.
1522 @retval the width info for one question.
1527 IN UINT8
*OpCodeData
1530 UINT8
*NextOpCodeData
;
1532 ASSERT (OpCodeData
!= NULL
);
1534 switch (((EFI_IFR_OP_HEADER
*) OpCodeData
)->OpCode
) {
1535 case EFI_IFR_REF_OP
:
1536 return (UINT16
) sizeof (EFI_HII_REF
);
1538 case EFI_IFR_ONE_OF_OP
:
1539 case EFI_IFR_NUMERIC_OP
:
1540 switch (((EFI_IFR_ONE_OF
*) OpCodeData
)->Flags
& EFI_IFR_NUMERIC_SIZE
) {
1541 case EFI_IFR_NUMERIC_SIZE_1
:
1542 return (UINT16
) sizeof (UINT8
);
1544 case EFI_IFR_NUMERIC_SIZE_2
:
1545 return (UINT16
) sizeof (UINT16
);
1547 case EFI_IFR_NUMERIC_SIZE_4
:
1548 return (UINT16
) sizeof (UINT32
);
1550 case EFI_IFR_NUMERIC_SIZE_8
:
1551 return (UINT16
) sizeof (UINT64
);
1558 case EFI_IFR_ORDERED_LIST_OP
:
1559 NextOpCodeData
= OpCodeData
+ ((EFI_IFR_ORDERED_LIST
*) OpCodeData
)->Header
.Length
;
1561 // OneOfOption must follow the orderedlist opcode.
1563 ASSERT (((EFI_IFR_OP_HEADER
*) NextOpCodeData
)->OpCode
== EFI_IFR_ONE_OF_OPTION_OP
);
1564 switch (((EFI_IFR_ONE_OF_OPTION
*) NextOpCodeData
)->Type
) {
1565 case EFI_IFR_TYPE_NUM_SIZE_8
:
1566 return (UINT16
) sizeof (UINT8
) * ((EFI_IFR_ORDERED_LIST
*) OpCodeData
)->MaxContainers
;
1568 case EFI_IFR_TYPE_NUM_SIZE_16
:
1569 return (UINT16
) sizeof (UINT16
) * ((EFI_IFR_ORDERED_LIST
*) OpCodeData
)->MaxContainers
;
1571 case EFI_IFR_TYPE_NUM_SIZE_32
:
1572 return (UINT16
) sizeof (UINT32
) * ((EFI_IFR_ORDERED_LIST
*) OpCodeData
)->MaxContainers
;
1574 case EFI_IFR_TYPE_NUM_SIZE_64
:
1575 return (UINT16
) sizeof (UINT64
) * ((EFI_IFR_ORDERED_LIST
*) OpCodeData
)->MaxContainers
;
1582 case EFI_IFR_CHECKBOX_OP
:
1583 return (UINT16
) sizeof (BOOLEAN
);
1585 case EFI_IFR_PASSWORD_OP
:
1586 return (UINT16
)((UINTN
) ((EFI_IFR_PASSWORD
*) OpCodeData
)->MaxSize
* sizeof (CHAR16
));
1588 case EFI_IFR_STRING_OP
:
1589 return (UINT16
)((UINTN
) ((EFI_IFR_STRING
*) OpCodeData
)->MaxSize
* sizeof (CHAR16
));
1591 case EFI_IFR_DATE_OP
:
1592 return (UINT16
) sizeof (EFI_HII_DATE
);
1594 case EFI_IFR_TIME_OP
:
1595 return (UINT16
) sizeof (EFI_HII_TIME
);
1604 Converts all hex dtring characters in range ['A'..'F'] to ['a'..'f'] for
1605 hex digits that appear between a '=' and a '&' in a config string.
1607 If ConfigString is NULL, then ASSERT().
1609 @param[in] ConfigString Pointer to a Null-terminated Unicode string.
1611 @return Pointer to the Null-terminated Unicode result string.
1616 InternalLowerConfigString (
1617 IN EFI_STRING ConfigString
1623 ASSERT (ConfigString
!= NULL
);
1626 // Convert all hex digits in range [A-F] in the configuration header to [a-f]
1628 for (String
= ConfigString
, Lower
= FALSE
; *String
!= L
'\0'; String
++) {
1629 if (*String
== L
'=') {
1631 } else if (*String
== L
'&') {
1633 } else if (Lower
&& *String
>= L
'A' && *String
<= L
'F') {
1634 *String
= (CHAR16
) (*String
- L
'A' + L
'a');
1638 return ConfigString
;
1642 Allocates and returns a Null-terminated Unicode <ConfigHdr> string.
1644 The format of a <ConfigHdr> is as follows:
1646 GUID=<HexCh>32&NAME=<Char>NameLength&PATH=<HexChar>DevicePathSize<Null>
1648 @param[in] OpCodeData The opcode for the storage.
1649 @param[in] DriverHandle The driver handle which supports a Device Path Protocol
1650 that is the routing information PATH. Each byte of
1651 the Device Path associated with DriverHandle is converted
1652 to a 2 Unicode character hexidecimal string.
1654 @retval NULL DriverHandle does not support the Device Path Protocol.
1655 @retval Other A pointer to the Null-terminate Unicode <ConfigHdr> string
1659 ConstructConfigHdr (
1660 IN UINT8
*OpCodeData
,
1661 IN EFI_HANDLE DriverHandle
1665 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1666 UINTN DevicePathSize
;
1668 CHAR16
*ReturnString
;
1676 ASSERT (OpCodeData
!= NULL
);
1678 switch (((EFI_IFR_OP_HEADER
*)OpCodeData
)->OpCode
) {
1679 case EFI_IFR_VARSTORE_OP
:
1680 Guid
= (EFI_GUID
*)(UINTN
*)&((EFI_IFR_VARSTORE
*) OpCodeData
)->Guid
;
1681 AsciiName
= (CHAR8
*) ((EFI_IFR_VARSTORE
*) OpCodeData
)->Name
;
1684 case EFI_IFR_VARSTORE_NAME_VALUE_OP
:
1685 Guid
= (EFI_GUID
*)(UINTN
*)&((EFI_IFR_VARSTORE_NAME_VALUE
*) OpCodeData
)->Guid
;
1689 case EFI_IFR_VARSTORE_EFI_OP
:
1690 Guid
= (EFI_GUID
*)(UINTN
*)&((EFI_IFR_VARSTORE_EFI
*) OpCodeData
)->Guid
;
1691 AsciiName
= (CHAR8
*) ((EFI_IFR_VARSTORE_EFI
*) OpCodeData
)->Name
;
1701 if (AsciiName
!= NULL
) {
1702 Name
= AllocateZeroPool (AsciiStrSize (AsciiName
) * 2);
1703 ASSERT (Name
!= NULL
);
1704 AsciiStrToUnicodeStr(AsciiName
, Name
);
1710 // Compute the length of Name in Unicode characters.
1711 // If Name is NULL, then the length is 0.
1715 NameLength
= StrLen (Name
);
1721 // Retrieve DevicePath Protocol associated with DriverHandle
1723 if (DriverHandle
!= NULL
) {
1724 DevicePath
= DevicePathFromHandle (DriverHandle
);
1725 if (DevicePath
== NULL
) {
1729 // Compute the size of the device path in bytes
1731 DevicePathSize
= GetDevicePathSize (DevicePath
);
1735 // GUID=<HexCh>32&NAME=<Char>NameLength&PATH=<HexChar>DevicePathSize <Null>
1736 // | 5 | sizeof (EFI_GUID) * 2 | 6 | NameStrLen*4 | 6 | DevicePathSize * 2 | 1 |
1738 MaxLen
= 5 + sizeof (EFI_GUID
) * 2 + 6 + NameLength
* 4 + 6 + DevicePathSize
* 2 + 1;
1739 String
= AllocateZeroPool (MaxLen
* sizeof (CHAR16
));
1740 if (String
== NULL
) {
1745 // Start with L"GUID="
1747 StrCpyS (String
, MaxLen
, L
"GUID=");
1748 ReturnString
= String
;
1749 String
+= StrLen (String
);
1753 // Append Guid converted to <HexCh>32
1755 for (Index
= 0, Buffer
= (UINT8
*)Guid
; Index
< sizeof (EFI_GUID
); Index
++) {
1756 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, *(Buffer
++), 2);
1763 StrCatS (ReturnString
, MaxLen
, L
"&NAME=");
1764 String
+= StrLen (String
);
1768 // Append Name converted to <Char>NameLength
1770 for (; *Name
!= L
'\0'; Name
++) {
1771 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, *Name
, 4);
1778 StrCatS (ReturnString
, MaxLen
, L
"&PATH=");
1779 String
+= StrLen (String
);
1782 // Append the device path associated with DriverHandle converted to <HexChar>DevicePathSize
1784 for (Index
= 0, Buffer
= (UINT8
*)DevicePath
; Index
< DevicePathSize
; Index
++) {
1785 String
+= UnicodeValueToString (String
, PREFIX_ZERO
| RADIX_HEX
, *(Buffer
++), 2);
1789 // Null terminate the Unicode string
1794 // Convert all hex digits in range [A-F] in the configuration header to [a-f]
1796 return InternalLowerConfigString (ReturnString
);
1800 Generate the Config request element for one question.
1802 @param Name The name info for one question.
1803 @param Offset The offset info for one question.
1804 @param Width The width info for one question.
1806 @return Pointer to the Null-terminated Unicode request element string.
1810 ConstructRequestElement (
1821 // Add <BlockName> length for each Name
1823 // <BlockName> ::= Name + \0
1826 Length
= StrLen (Name
) + 1;
1829 // Add <BlockName> length for each Offset/Width pair
1831 // <BlockName> ::= OFFSET=1234&WIDTH=1234 + \0
1832 // | 7 | 4 | 7 | 4 | 1
1834 Length
= (7 + 4 + 7 + 4 + 1);
1838 // Allocate buffer for the entire <ConfigRequest>
1840 StringPtr
= AllocateZeroPool (Length
* sizeof (CHAR16
));
1841 ASSERT (StringPtr
!= NULL
);
1849 (StrLen (Name
) + 1) * sizeof (CHAR16
),
1855 // Append OFFSET=XXXX&WIDTH=YYYY\0
1859 (7 + 4 + 7 + 4 + 1) * sizeof (CHAR16
),
1860 L
"OFFSET=%04X&WIDTH=%04X",
1870 Get string value for question's name field.
1872 @param DatabaseRecord HII_DATABASE_RECORD format string.
1873 @param NameId The string id for the name field.
1875 @retval Name string.
1880 IN HII_DATABASE_RECORD
*DatabaseRecord
,
1881 IN EFI_STRING_ID NameId
1885 CHAR8
*PlatformLanguage
;
1886 CHAR8
*SupportedLanguages
;
1887 CHAR8
*BestLanguage
;
1893 BestLanguage
= NULL
;
1894 PlatformLanguage
= NULL
;
1895 SupportedLanguages
= NULL
;
1897 GetEfiGlobalVariable2 (L
"PlatformLang", (VOID
**)&PlatformLanguage
, NULL
);
1898 SupportedLanguages
= GetSupportedLanguages(DatabaseRecord
->Handle
);
1901 // Get the best matching language from SupportedLanguages
1903 BestLanguage
= GetBestLanguage (
1905 FALSE
, // RFC 4646 mode
1906 PlatformLanguage
!= NULL
? PlatformLanguage
: "", // Highest priority
1907 SupportedLanguages
, // Lowest priority
1910 if (BestLanguage
== NULL
) {
1911 BestLanguage
= AllocateCopyPool (AsciiStrLen ("en-US"), "en-US");
1912 ASSERT (BestLanguage
!= NULL
);
1916 Status
= mPrivate
.HiiString
.GetString (
1917 &mPrivate
.HiiString
,
1919 DatabaseRecord
->Handle
,
1925 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
1929 Name
= AllocateZeroPool (StringSize
);
1934 Status
= mPrivate
.HiiString
.GetString (
1935 &mPrivate
.HiiString
,
1937 DatabaseRecord
->Handle
,
1944 if (EFI_ERROR (Status
)) {
1951 if (SupportedLanguages
!= NULL
) {
1952 FreePool(SupportedLanguages
);
1954 if (BestLanguage
!= NULL
) {
1955 FreePool (BestLanguage
);
1957 if (PlatformLanguage
!= NULL
) {
1958 FreePool (PlatformLanguage
);
1965 Base on the input parameter to generate the ConfigRequest string.
1967 This is a internal function.
1969 @param DatabaseRecord HII_DATABASE_RECORD format string.
1970 @param KeywordStrId Keyword string id.
1971 @param OpCodeData The IFR data for this question.
1972 @param ConfigRequest Return the generate ConfigRequest string.
1974 @retval EFI_SUCCESS Generate ConfigResp string success.
1975 @retval EFI_OUT_OF_RESOURCES System out of memory resource error.
1976 @retval EFI_NOT_FOUND Not found the question which use this string id
1977 as the prompt string id.
1980 ExtractConfigRequest (
1981 IN HII_DATABASE_RECORD
*DatabaseRecord
,
1982 IN EFI_STRING_ID KeywordStrId
,
1983 OUT UINT8
**OpCodeData
,
1984 OUT EFI_STRING
*ConfigRequest
1988 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageListNode
;
1989 HII_IFR_PACKAGE_INSTANCE
*FormPackage
;
1990 EFI_IFR_QUESTION_HEADER
*Header
;
1997 CHAR16
*RequestElement
;
2001 ASSERT (DatabaseRecord
!= NULL
&& OpCodeData
!= NULL
&& ConfigRequest
!= NULL
);
2008 PackageListNode
= DatabaseRecord
->PackageList
;
2011 // Search the languages in the specified packagelist.
2013 for (Link
= PackageListNode
->FormPkgHdr
.ForwardLink
; Link
!= &PackageListNode
->FormPkgHdr
; Link
= Link
->ForwardLink
) {
2014 FormPackage
= CR (Link
, HII_IFR_PACKAGE_INSTANCE
, IfrEntry
, HII_IFR_PACKAGE_SIGNATURE
);
2016 OpCode
= FindQuestionFromStringId (FormPackage
, KeywordStrId
);
2017 if (OpCode
!= NULL
) {
2018 *OpCodeData
= OpCode
;
2019 Header
= (EFI_IFR_QUESTION_HEADER
*) (OpCode
+ sizeof (EFI_IFR_OP_HEADER
));
2021 // Header->VarStoreId == 0 means no storage for this question.
2023 ASSERT (Header
->VarStoreId
!= 0);
2024 DEBUG ((EFI_D_INFO
, "Varstore Id: 0x%x\n", Header
->VarStoreId
));
2026 Storage
= FindStorageFromVarId (FormPackage
, Header
->VarStoreId
);
2027 ASSERT (Storage
!= NULL
);
2029 if (((EFI_IFR_OP_HEADER
*) Storage
)->OpCode
== EFI_IFR_VARSTORE_NAME_VALUE_OP
) {
2030 Name
= GetNameFromId (DatabaseRecord
, Header
->VarStoreInfo
.VarName
);
2032 Offset
= Header
->VarStoreInfo
.VarOffset
;
2033 Width
= GetWidth (OpCode
);
2035 RequestElement
= ConstructRequestElement(Name
, Offset
, Width
);
2036 ConfigHdr
= ConstructConfigHdr(Storage
, DatabaseRecord
->DriverHandle
);
2037 ASSERT (ConfigHdr
!= NULL
);
2039 MaxLen
= StrLen (ConfigHdr
) + 1 + StrLen(RequestElement
) + 1;
2040 *ConfigRequest
= AllocatePool (MaxLen
* sizeof (CHAR16
));
2041 if (*ConfigRequest
== NULL
) {
2042 FreePool (ConfigHdr
);
2043 FreePool (RequestElement
);
2044 return EFI_OUT_OF_RESOURCES
;
2046 StringPtr
= *ConfigRequest
;
2048 StrCpyS (StringPtr
, MaxLen
, ConfigHdr
);
2050 StrCatS (StringPtr
, MaxLen
, L
"&");
2052 StrCatS (StringPtr
, MaxLen
, RequestElement
);
2054 FreePool (ConfigHdr
);
2055 FreePool (RequestElement
);
2061 return EFI_NOT_FOUND
;
2065 Base on the input parameter to generate the ConfigResp string.
2067 This is a internal function.
2069 @param DatabaseRecord HII_DATABASE_RECORD format string.
2070 @param KeywordStrId Keyword string id.
2071 @param ValueElement The value for the question which use keyword string id
2072 as the prompt string id.
2073 @param OpCodeData The IFR data for this question.
2074 @param ConfigResp Return the generate ConfigResp string.
2076 @retval EFI_SUCCESS Generate ConfigResp string success.
2077 @retval EFI_OUT_OF_RESOURCES System out of memory resource error.
2078 @retval EFI_NOT_FOUND Not found the question which use this string id
2079 as the prompt string id.
2083 IN HII_DATABASE_RECORD
*DatabaseRecord
,
2084 IN EFI_STRING_ID KeywordStrId
,
2085 IN EFI_STRING ValueElement
,
2086 OUT UINT8
**OpCodeData
,
2087 OUT EFI_STRING
*ConfigResp
2091 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageListNode
;
2092 HII_IFR_PACKAGE_INSTANCE
*FormPackage
;
2093 EFI_IFR_QUESTION_HEADER
*Header
;
2100 CHAR16
*RequestElement
;
2104 ASSERT ((DatabaseRecord
!= NULL
) && (OpCodeData
!= NULL
) && (ConfigResp
!= NULL
) && (ValueElement
!= NULL
));
2111 PackageListNode
= DatabaseRecord
->PackageList
;
2114 // Search the languages in the specified packagelist.
2116 for (Link
= PackageListNode
->FormPkgHdr
.ForwardLink
; Link
!= &PackageListNode
->FormPkgHdr
; Link
= Link
->ForwardLink
) {
2117 FormPackage
= CR (Link
, HII_IFR_PACKAGE_INSTANCE
, IfrEntry
, HII_IFR_PACKAGE_SIGNATURE
);
2119 OpCode
= FindQuestionFromStringId (FormPackage
, KeywordStrId
);
2120 if (OpCode
!= NULL
) {
2121 *OpCodeData
= OpCode
;
2122 Header
= (EFI_IFR_QUESTION_HEADER
*) (OpCode
+ sizeof (EFI_IFR_OP_HEADER
));
2124 // Header->VarStoreId == 0 means no storage for this question.
2126 ASSERT (Header
->VarStoreId
!= 0);
2127 DEBUG ((EFI_D_INFO
, "Varstore Id: 0x%x\n", Header
->VarStoreId
));
2129 Storage
= FindStorageFromVarId (FormPackage
, Header
->VarStoreId
);
2130 ASSERT (Storage
!= NULL
);
2132 if (((EFI_IFR_OP_HEADER
*) Storage
)->OpCode
== EFI_IFR_VARSTORE_NAME_VALUE_OP
) {
2133 Name
= GetNameFromId (DatabaseRecord
, Header
->VarStoreInfo
.VarName
);
2135 Offset
= Header
->VarStoreInfo
.VarOffset
;
2136 Width
= GetWidth (OpCode
);
2138 RequestElement
= ConstructRequestElement(Name
, Offset
, Width
);
2140 ConfigHdr
= ConstructConfigHdr(Storage
, DatabaseRecord
->DriverHandle
);
2141 ASSERT (ConfigHdr
!= NULL
);
2143 MaxLen
= StrLen (ConfigHdr
) + 1 + StrLen(RequestElement
) + 1 + StrLen (L
"VALUE=") + StrLen(ValueElement
) + 1;
2144 *ConfigResp
= AllocatePool (MaxLen
* sizeof (CHAR16
));
2145 if (*ConfigResp
== NULL
) {
2146 FreePool (ConfigHdr
);
2147 FreePool (RequestElement
);
2148 return EFI_OUT_OF_RESOURCES
;
2150 StringPtr
= *ConfigResp
;
2152 StrCpyS (StringPtr
, MaxLen
, ConfigHdr
);
2154 StrCatS (StringPtr
, MaxLen
, L
"&");
2157 StrCatS (StringPtr
, MaxLen
, RequestElement
);
2159 StrCatS (StringPtr
, MaxLen
, L
"&");
2161 StrCatS (StringPtr
, MaxLen
, L
"VALUE=");
2163 StrCatS (StringPtr
, MaxLen
, ValueElement
);
2165 FreePool (ConfigHdr
);
2166 FreePool (RequestElement
);
2172 return EFI_NOT_FOUND
;
2176 Get the Value section from the Hii driver.
2178 This is a internal function.
2180 @param ConfigRequest The input ConfigRequest string.
2181 @param ValueElement The respond Value section from the hii driver.
2183 @retval Misc value The error status return from ExtractConfig function.
2184 @retval EFI_OUT_OF_RESOURCES The memory can't be allocated
2185 @retval EFI_SUCCESS Get the value section success.
2189 ExtractValueFromDriver (
2190 IN CHAR16
*ConfigRequest
,
2191 OUT CHAR16
**ValueElement
2196 EFI_STRING Progress
;
2200 ASSERT ((ConfigRequest
!= NULL
) && (ValueElement
!= NULL
));
2202 Status
= mPrivate
.ConfigRouting
.ExtractConfig (
2203 &mPrivate
.ConfigRouting
,
2204 (EFI_STRING
) ConfigRequest
,
2208 if (EFI_ERROR (Status
)) {
2213 // Find Value Section and return it.
2215 StringPtr
= StrStr (Result
, L
"&VALUE=");
2216 ASSERT (StringPtr
!= NULL
);
2217 StringEnd
= StrStr (StringPtr
+ 1, L
"&");
2218 if (StringEnd
!= NULL
) {
2222 *ValueElement
= AllocateCopyPool (StrSize (StringPtr
), StringPtr
);
2223 if (*ValueElement
== NULL
) {
2224 return EFI_OUT_OF_RESOURCES
;
2227 if (StringEnd
!= NULL
) {
2236 Get EFI_STRING_ID info from the input device path, namespace and keyword.
2238 This is a internal function.
2240 @param DevicePath Input device path info.
2241 @param NameSpace NameSpace format string.
2242 @param KeywordData Keyword used to get string id.
2243 @param ProgressErr Return extra error type.
2244 @param KeywordStringId Return EFI_STRING_ID.
2245 @param DataBaseRecord DataBase record data for this driver.
2247 @retval EFI_INVALID_PARAMETER Can't find the database record base on the input device path or namespace.
2248 @retval EFI_NOT_FOUND Can't find the EFI_STRING_ID for the keyword.
2249 @retval EFI_SUCCESS Find the EFI_STRING_ID.
2253 GetStringIdFromDatabase (
2254 IN EFI_DEVICE_PATH_PROTOCOL
**DevicePath
,
2255 IN CHAR8
**NameSpace
,
2256 IN CHAR16
*KeywordData
,
2257 OUT UINT32
*ProgressErr
,
2258 OUT EFI_STRING_ID
*KeywordStringId
,
2259 OUT HII_DATABASE_RECORD
**DataBaseRecord
2262 HII_DATABASE_RECORD
*Record
;
2264 BOOLEAN FindNameSpace
;
2265 EFI_DEVICE_PATH_PROTOCOL
*DestDevicePath
;
2266 UINT8
*DevicePathPkg
;
2267 UINTN DevicePathSize
;
2269 ASSERT ((NameSpace
!= NULL
) && (KeywordData
!= NULL
) && (ProgressErr
!= NULL
) && (KeywordStringId
!= NULL
) && (DataBaseRecord
!= NULL
));
2271 FindNameSpace
= FALSE
;
2273 if (*DevicePath
!= NULL
) {
2275 // Get DataBaseRecord from device path protocol.
2277 Record
= GetRecordFromDevicePath(*DevicePath
);
2278 if (Record
== NULL
) {
2280 // Can't find the DatabaseRecord base on the input device path info.
2281 // NEED TO CONFIRM the return ProgressErr.
2283 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
2284 return EFI_INVALID_PARAMETER
;
2288 // Get string id from the record.
2290 *ProgressErr
= GetStringIdFromRecord (Record
, NameSpace
, KeywordData
, KeywordStringId
);
2291 switch (*ProgressErr
) {
2292 case KEYWORD_HANDLER_NO_ERROR
:
2293 *DataBaseRecord
= Record
;
2296 case KEYWORD_HANDLER_NAMESPACE_ID_NOT_FOUND
:
2297 return EFI_INVALID_PARAMETER
;
2300 ASSERT (*ProgressErr
== KEYWORD_HANDLER_KEYWORD_NOT_FOUND
);
2301 return EFI_NOT_FOUND
;
2305 // Find driver which matches the routing data.
2307 for (Link
= mPrivate
.DatabaseList
.ForwardLink
; Link
!= &mPrivate
.DatabaseList
; Link
= Link
->ForwardLink
) {
2308 Record
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
2310 *ProgressErr
= GetStringIdFromRecord (Record
, NameSpace
, KeywordData
, KeywordStringId
);
2311 if (*ProgressErr
== KEYWORD_HANDLER_NO_ERROR
) {
2312 *DataBaseRecord
= Record
;
2314 if ((DevicePathPkg
= Record
->PackageList
->DevicePathPkg
) != NULL
) {
2315 DestDevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) (DevicePathPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
));
2316 DevicePathSize
= GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL
*) DestDevicePath
);
2317 *DevicePath
= AllocateCopyPool (DevicePathSize
, DestDevicePath
);
2318 if (*DevicePath
== NULL
) {
2319 return EFI_OUT_OF_RESOURCES
;
2323 // Need to verify this ASSERT.
2329 } else if (*ProgressErr
== KEYWORD_HANDLER_UNDEFINED_PROCESSING_ERROR
) {
2330 return EFI_OUT_OF_RESOURCES
;
2331 } else if (*ProgressErr
== KEYWORD_HANDLER_KEYWORD_NOT_FOUND
) {
2332 FindNameSpace
= TRUE
;
2337 // When PathHdr not input, if ever find the namespace, will return KEYWORD_HANDLER_KEYWORD_NOT_FOUND.
2338 // This is a bit more progress than KEYWORD_HANDLER_NAMESPACE_ID_NOT_FOUND.
2340 if (FindNameSpace
) {
2341 return EFI_NOT_FOUND
;
2343 return EFI_INVALID_PARAMETER
;
2349 Genereate the KeywordResp String.
2351 <KeywordResp> ::= <NameSpaceId><PathHdr>'&'<Keyword>'&VALUE='<Number>['&READONLY']
2353 @param NameSpace NameSpace format string.
2354 @param DevicePath Input device path info.
2355 @param KeywordData Keyword used to get string id.
2356 @param ValueStr The value section for the keyword.
2357 @param ReadOnly Whether this value is readonly.
2358 @param KeywordResp Return the point to the KeywordResp string.
2360 @retval EFI_OUT_OF_RESOURCES The memory can't be allocated.
2361 @retval EFI_SUCCESS Generate the KeywordResp string.
2365 GenerateKeywordResp (
2366 IN CHAR8
*NameSpace
,
2367 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
2368 IN EFI_STRING KeywordData
,
2369 IN EFI_STRING ValueStr
,
2370 IN BOOLEAN ReadOnly
,
2371 OUT EFI_STRING
*KeywordResp
2377 CHAR16
*UnicodeNameSpace
;
2379 ASSERT ((NameSpace
!= NULL
) && (DevicePath
!= NULL
) && (KeywordData
!= NULL
) && (ValueStr
!= NULL
) && (KeywordResp
!= NULL
));
2382 // 1. Calculate the string length.
2385 // 1.1 NameSpaceId size.
2386 // 'NAMESPACE='<String>
2388 RespStrLen
= 10 + AsciiStrLen (NameSpace
);
2389 UnicodeNameSpace
= AllocatePool ((AsciiStrLen (NameSpace
) + 1) * sizeof (CHAR16
));
2390 if (UnicodeNameSpace
== NULL
) {
2391 return EFI_OUT_OF_RESOURCES
;
2393 AsciiStrToUnicodeStr(NameSpace
, UnicodeNameSpace
);
2396 // 1.2 PathHdr size.
2397 // PATH=<UEFI binary Device Path represented as hex number>'&'
2398 // Attention: The output include the '&' at the end.
2402 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL
*) DevicePath
),
2403 (VOID
*) DevicePath
,
2407 RespStrLen
+= StrLen (PathHdr
);
2410 // 1.3 Keyword setion.
2411 // 'KEYWORD='<String>[':'<DecCh>(1/4)]
2413 RespStrLen
+= 8 + StrLen (KeywordData
);
2416 // 1.4 Value section.
2417 // ValueStr = '&VALUE='<Number>
2419 RespStrLen
+= StrLen (ValueStr
);
2422 // 1.5 ReadOnly Section.
2430 // 2. Allocate the buffer and create the KeywordResp string include '\0'.
2433 *KeywordResp
= AllocatePool (RespStrLen
* sizeof (CHAR16
));
2434 if (*KeywordResp
== NULL
) {
2435 if (UnicodeNameSpace
!= NULL
) {
2436 FreePool (UnicodeNameSpace
);
2439 return EFI_OUT_OF_RESOURCES
;
2441 RespStr
= *KeywordResp
;
2444 // 2.1 Copy NameSpaceId section.
2446 StrCpyS (RespStr
, RespStrLen
, L
"NAMESPACE=");
2448 StrCatS (RespStr
, RespStrLen
, UnicodeNameSpace
);
2451 // 2.2 Copy PathHdr section.
2453 StrCatS (RespStr
, RespStrLen
, PathHdr
);
2456 // 2.3 Copy Keyword section.
2458 StrCatS (RespStr
, RespStrLen
, L
"KEYWORD=");
2460 StrCatS (RespStr
, RespStrLen
, KeywordData
);
2463 // 2.4 Copy the Value section.
2465 StrCatS (RespStr
, RespStrLen
, ValueStr
);
2468 // 2.5 Copy ReadOnly section if exist.
2471 StrCatS (RespStr
, RespStrLen
, L
"&READONLY");
2474 if (UnicodeNameSpace
!= NULL
) {
2475 FreePool (UnicodeNameSpace
);
2477 if (PathHdr
!= NULL
) {
2485 Merge the KeywordResp String to MultiKeywordResp string.
2487 This is a internal function.
2489 @param MultiKeywordResp The existed multikeywordresp string.
2490 @param KeywordResp The input keywordResp string.
2492 @retval EFI_OUT_OF_RESOURCES The memory can't be allocated.
2493 @retval EFI_SUCCESS Generate the MultiKeywordResp string.
2497 MergeToMultiKeywordResp (
2498 IN OUT EFI_STRING
*MultiKeywordResp
,
2499 IN EFI_STRING
*KeywordResp
2502 UINTN MultiKeywordRespLen
;
2503 EFI_STRING StringPtr
;
2505 if (*MultiKeywordResp
== NULL
) {
2506 *MultiKeywordResp
= *KeywordResp
;
2507 *KeywordResp
= NULL
;
2511 MultiKeywordRespLen
= (StrLen (*MultiKeywordResp
) + 1 + StrLen (*KeywordResp
) + 1) * sizeof (CHAR16
);
2513 StringPtr
= AllocateCopyPool (MultiKeywordRespLen
, *MultiKeywordResp
);
2514 if (StringPtr
== NULL
) {
2515 return EFI_OUT_OF_RESOURCES
;
2518 FreePool (*MultiKeywordResp
);
2519 *MultiKeywordResp
= StringPtr
;
2521 StrCatS (StringPtr
, MultiKeywordRespLen
/ sizeof (CHAR16
), L
"&");
2523 StrCatS (StringPtr
, MultiKeywordRespLen
/ sizeof (CHAR16
), *KeywordResp
);
2529 Enumerate all keyword in the system.
2531 If error occur when parse one keyword, just skip it and parse the next one.
2533 This is a internal function.
2535 @param NameSpace The namespace used to search the string.
2536 @param MultiResp Return the MultiKeywordResp string for the system.
2537 @param ProgressErr Return the error status.
2539 @retval EFI_OUT_OF_RESOURCES The memory can't be allocated.
2540 @retval EFI_SUCCESS Generate the MultiKeywordResp string.
2541 @retval EFI_NOT_FOUND No keyword found.
2545 EnumerateAllKeywords (
2546 IN CHAR8
*NameSpace
,
2547 OUT EFI_STRING
*MultiResp
,
2548 OUT UINT32
*ProgressErr
2552 LIST_ENTRY
*StringLink
;
2553 UINT8
*DevicePathPkg
;
2555 HII_DATABASE_RECORD
*DataBaseRecord
;
2556 HII_DATABASE_PACKAGE_LIST_INSTANCE
*PackageListNode
;
2557 HII_STRING_PACKAGE_INSTANCE
*StringPackage
;
2558 CHAR8
*LocalNameSpace
;
2559 EFI_STRING_ID NextStringId
;
2562 CHAR16
*ConfigRequest
;
2563 CHAR16
*ValueElement
;
2564 CHAR16
*KeywordResp
;
2565 CHAR16
*MultiKeywordResp
;
2566 CHAR16
*KeywordData
;
2568 BOOLEAN FindKeywordPackages
;
2570 DataBaseRecord
= NULL
;
2571 Status
= EFI_SUCCESS
;
2572 MultiKeywordResp
= NULL
;
2574 LocalNameSpace
= NULL
;
2575 ConfigRequest
= NULL
;
2576 ValueElement
= NULL
;
2578 FindKeywordPackages
= FALSE
;
2580 if (NameSpace
== NULL
) {
2581 NameSpace
= UEFI_CONFIG_LANG
;
2585 // Find driver which matches the routing data.
2587 for (Link
= mPrivate
.DatabaseList
.ForwardLink
; Link
!= &mPrivate
.DatabaseList
; Link
= Link
->ForwardLink
) {
2588 DataBaseRecord
= CR (Link
, HII_DATABASE_RECORD
, DatabaseEntry
, HII_DATABASE_RECORD_SIGNATURE
);
2589 if ((DevicePathPkg
= DataBaseRecord
->PackageList
->DevicePathPkg
) != NULL
) {
2590 DevicePath
= DevicePathPkg
+ sizeof (EFI_HII_PACKAGE_HEADER
);
2592 PackageListNode
= DataBaseRecord
->PackageList
;
2594 for (StringLink
= PackageListNode
->StringPkgHdr
.ForwardLink
; StringLink
!= &PackageListNode
->StringPkgHdr
; StringLink
= StringLink
->ForwardLink
) {
2595 StringPackage
= CR (StringLink
, HII_STRING_PACKAGE_INSTANCE
, StringEntry
, HII_STRING_PACKAGE_SIGNATURE
);
2598 // Check whether has keyword string package.
2600 if (AsciiStrnCmp(NameSpace
, StringPackage
->StringPkgHdr
->Language
, AsciiStrLen (NameSpace
)) == 0) {
2601 FindKeywordPackages
= TRUE
;
2603 // Keep the NameSpace string.
2605 LocalNameSpace
= AllocateCopyPool (AsciiStrSize (StringPackage
->StringPkgHdr
->Language
), StringPackage
->StringPkgHdr
->Language
);
2606 if (LocalNameSpace
== NULL
) {
2607 return EFI_OUT_OF_RESOURCES
;
2611 // 1 means just begin the enumerate the valid string ids.
2612 // StringId == 1 is always used to save the language for this string package.
2613 // Any valid string start from 2. so here initial it to 1.
2618 // Enumerate all valid stringid in the package.
2620 while ((NextStringId
= GetNextStringId (StringPackage
, NextStringId
, &KeywordData
)) != 0) {
2622 // 3.3 Construct the ConfigRequest string.
2624 Status
= ExtractConfigRequest (DataBaseRecord
, NextStringId
, &OpCode
, &ConfigRequest
);
2625 if (EFI_ERROR (Status
)) {
2627 // If can't generate ConfigRequest for this question, skip it and start the next.
2633 // 3.4 Extract Value for the input keyword.
2635 Status
= ExtractValueFromDriver(ConfigRequest
, &ValueElement
);
2636 if (EFI_ERROR (Status
)) {
2637 if (Status
!= EFI_OUT_OF_RESOURCES
) {
2639 // If can't generate ConfigRequest for this question, skip it and start the next.
2644 // If EFI_OUT_OF_RESOURCES error occur, no need to continue.
2650 // Extract readonly flag from opcode.
2652 ReadOnly
= ExtractReadOnlyFromOpCode(OpCode
);
2655 // 5. Generate KeywordResp string.
2657 ASSERT (DevicePath
!= NULL
);
2658 Status
= GenerateKeywordResp(LocalNameSpace
, (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
, KeywordData
, ValueElement
, ReadOnly
, &KeywordResp
);
2659 if (Status
!= EFI_SUCCESS
) {
2661 // If EFI_OUT_OF_RESOURCES error occur, no need to continue.
2667 // 6. Merge to the MultiKeywordResp string.
2669 Status
= MergeToMultiKeywordResp(&MultiKeywordResp
, &KeywordResp
);
2670 if (EFI_ERROR (Status
)) {
2675 // Clean the temp buffer to later use again.
2677 if (ConfigRequest
!= NULL
) {
2678 FreePool (ConfigRequest
);
2679 ConfigRequest
= NULL
;
2681 if (ValueElement
!= NULL
) {
2682 FreePool (ValueElement
);
2683 ValueElement
= NULL
;
2685 if (KeywordResp
!= NULL
) {
2686 FreePool (KeywordResp
);
2691 if (LocalNameSpace
!= NULL
) {
2692 FreePool (LocalNameSpace
);
2693 LocalNameSpace
= NULL
;
2700 // return the already get MultiKeywordString even error occured.
2702 if (MultiKeywordResp
== NULL
) {
2703 Status
= EFI_NOT_FOUND
;
2704 if (!FindKeywordPackages
) {
2705 *ProgressErr
= KEYWORD_HANDLER_NAMESPACE_ID_NOT_FOUND
;
2707 *ProgressErr
= KEYWORD_HANDLER_KEYWORD_NOT_FOUND
;
2710 Status
= EFI_SUCCESS
;
2712 *MultiResp
= MultiKeywordResp
;
2715 if (LocalNameSpace
!= NULL
) {
2716 FreePool (LocalNameSpace
);
2718 if (ConfigRequest
!= NULL
) {
2719 FreePool (ConfigRequest
);
2721 if (ValueElement
!= NULL
) {
2722 FreePool (ValueElement
);
2730 This function accepts a <MultiKeywordResp> formatted string, finds the associated
2731 keyword owners, creates a <MultiConfigResp> string from it and forwards it to the
2732 EFI_HII_ROUTING_PROTOCOL.RouteConfig function.
2734 If there is an issue in resolving the contents of the KeywordString, then the
2735 function returns an error and also sets the Progress and ProgressErr with the
2736 appropriate information about where the issue occurred and additional data about
2737 the nature of the issue.
2739 In the case when KeywordString containing multiple keywords, when an EFI_NOT_FOUND
2740 error is generated during processing the second or later keyword element, the system
2741 storage associated with earlier keywords is not modified. All elements of the
2742 KeywordString must successfully pass all tests for format and access prior to making
2743 any modifications to storage.
2745 In the case when EFI_DEVICE_ERROR is returned from the processing of a KeywordString
2746 containing multiple keywords, the state of storage associated with earlier keywords
2750 @param This Pointer to the EFI_KEYWORD_HANDLER _PROTOCOL instance.
2752 @param KeywordString A null-terminated string in <MultiKeywordResp> format.
2754 @param Progress On return, points to a character in the KeywordString.
2755 Points to the string's NULL terminator if the request
2756 was successful. Points to the most recent '&' before
2757 the first failing string element if the request was
2760 @param ProgressErr If during the processing of the KeywordString there was
2761 a failure, this parameter gives additional information
2762 about the possible source of the problem. The various
2763 errors are defined in "Related Definitions" below.
2766 @retval EFI_SUCCESS The specified action was completed successfully.
2768 @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
2769 1. KeywordString is NULL.
2770 2. Parsing of the KeywordString resulted in an
2771 error. See Progress and ProgressErr for more data.
2773 @retval EFI_NOT_FOUND An element of the KeywordString was not found.
2774 See ProgressErr for more data.
2776 @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated.
2777 See ProgressErr for more data.
2779 @retval EFI_ACCESS_DENIED The action violated system policy. See ProgressErr
2782 @retval EFI_DEVICE_ERROR An unexpected system error occurred. See ProgressErr
2788 EfiConfigKeywordHandlerSetData (
2789 IN EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL
*This
,
2790 IN CONST EFI_STRING KeywordString
,
2791 OUT EFI_STRING
*Progress
,
2792 OUT UINT32
*ProgressErr
2798 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
2799 CHAR16
*NextStringPtr
;
2800 CHAR16
*KeywordData
;
2801 EFI_STRING_ID KeywordStringId
;
2803 HII_DATABASE_RECORD
*DataBaseRecord
;
2806 CHAR16
*MultiConfigResp
;
2807 CHAR16
*ValueElement
;
2809 EFI_STRING InternalProgress
;
2811 CHAR16
*KeywordStartPos
;
2813 if (This
== NULL
|| Progress
== NULL
|| ProgressErr
== NULL
|| KeywordString
== NULL
) {
2814 return EFI_INVALID_PARAMETER
;
2817 *Progress
= KeywordString
;
2818 *ProgressErr
= KEYWORD_HANDLER_UNDEFINED_PROCESSING_ERROR
;
2819 Status
= EFI_SUCCESS
;
2820 MultiConfigResp
= NULL
;
2824 ValueElement
= NULL
;
2826 KeywordStartPos
= NULL
;
2827 KeywordStringId
= 0;
2830 // Use temp string to avoid changing input string buffer.
2832 TempString
= AllocateCopyPool (StrSize (KeywordString
), KeywordString
);
2833 ASSERT (TempString
!= NULL
);
2834 StringPtr
= TempString
;
2836 while ((StringPtr
!= NULL
) && (*StringPtr
!= L
'\0')) {
2838 // 1. Get NameSpace from NameSpaceId keyword.
2840 Status
= ExtractNameSpace (StringPtr
, &NameSpace
, &NextStringPtr
);
2841 if (EFI_ERROR (Status
)) {
2842 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
2845 ASSERT (NameSpace
!= NULL
);
2847 // 1.1 Check whether the input namespace is valid.
2849 if (AsciiStrnCmp(NameSpace
, UEFI_CONFIG_LANG
, AsciiStrLen (UEFI_CONFIG_LANG
)) != 0) {
2850 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
2851 Status
= EFI_INVALID_PARAMETER
;
2855 StringPtr
= NextStringPtr
;
2858 // 2. Get possible Device Path info from KeywordString.
2860 Status
= ExtractDevicePath (StringPtr
, (UINT8
**)&DevicePath
, &NextStringPtr
);
2861 if (EFI_ERROR (Status
)) {
2862 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
2865 StringPtr
= NextStringPtr
;
2868 // 3. Extract keyword from the KeywordRequest string.
2870 KeywordStartPos
= StringPtr
;
2871 Status
= ExtractKeyword(StringPtr
, &KeywordData
, &NextStringPtr
);
2872 if (EFI_ERROR (Status
)) {
2874 // Can't find Keyword base on the input device path info.
2876 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
2877 Status
= EFI_INVALID_PARAMETER
;
2880 StringPtr
= NextStringPtr
;
2883 // 4. Extract Value from the KeywordRequest string.
2885 Status
= ExtractValue (StringPtr
, &ValueElement
, &NextStringPtr
);
2886 if (EFI_ERROR (Status
)) {
2888 // Can't find Value base on the input device path info.
2890 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
2891 Status
= EFI_INVALID_PARAMETER
;
2894 StringPtr
= NextStringPtr
;
2897 // 5. Find ReadOnly filter.
2899 if ((StringPtr
!= NULL
) && StrnCmp (StringPtr
, L
"&ReadOnly", StrLen (L
"&ReadOnly")) == 0) {
2901 StringPtr
+= StrLen (L
"&ReadOnly");
2907 // 6. Get EFI_STRING_ID for the input keyword.
2909 Status
= GetStringIdFromDatabase (&DevicePath
, &NameSpace
, KeywordData
, &RetVal
, &KeywordStringId
, &DataBaseRecord
);
2910 if (EFI_ERROR (Status
)) {
2911 *ProgressErr
= RetVal
;
2916 // 7. Construct the ConfigRequest string.
2918 Status
= ExtractConfigResp (DataBaseRecord
, KeywordStringId
, ValueElement
, &OpCode
, &ConfigResp
);
2919 if (EFI_ERROR (Status
)) {
2924 // 8. Check the readonly flag.
2926 if (ExtractReadOnlyFromOpCode (OpCode
) != ReadOnly
) {
2927 *ProgressErr
= KEYWORD_HANDLER_ACCESS_NOT_PERMITTED
;
2928 Status
= EFI_ACCESS_DENIED
;
2933 // 9. Merge to the MultiKeywordResp string.
2935 Status
= MergeToMultiKeywordResp(&MultiConfigResp
, &ConfigResp
);
2936 if (EFI_ERROR (Status
)) {
2941 // 10. Clean the temp buffer point.
2943 FreePool (NameSpace
);
2944 FreePool (DevicePath
);
2945 FreePool (KeywordData
);
2946 FreePool (ValueElement
);
2950 ValueElement
= NULL
;
2951 if (ConfigResp
!= NULL
) {
2952 FreePool (ConfigResp
);
2955 KeywordStartPos
= NULL
;
2959 // 11. Set value to driver.
2961 Status
= mPrivate
.ConfigRouting
.RouteConfig(
2962 &mPrivate
.ConfigRouting
,
2963 (EFI_STRING
) MultiConfigResp
,
2966 if (EFI_ERROR (Status
)) {
2967 Status
= EFI_DEVICE_ERROR
;
2971 *ProgressErr
= KEYWORD_HANDLER_NO_ERROR
;
2974 if (KeywordStartPos
!= NULL
) {
2975 *Progress
= KeywordString
+ (KeywordStartPos
- TempString
);
2977 *Progress
= KeywordString
+ (StringPtr
- TempString
);
2980 ASSERT (TempString
!= NULL
);
2981 FreePool (TempString
);
2982 if (NameSpace
!= NULL
) {
2983 FreePool (NameSpace
);
2985 if (DevicePath
!= NULL
) {
2986 FreePool (DevicePath
);
2988 if (KeywordData
!= NULL
) {
2989 FreePool (KeywordData
);
2991 if (ValueElement
!= NULL
) {
2992 FreePool (ValueElement
);
2994 if (ConfigResp
!= NULL
) {
2995 FreePool (ConfigResp
);
2997 if (MultiConfigResp
!= NULL
&& MultiConfigResp
!= ConfigResp
) {
2998 FreePool (MultiConfigResp
);
3006 This function accepts a <MultiKeywordRequest> formatted string, finds the underlying
3007 keyword owners, creates a <MultiConfigRequest> string from it and forwards it to the
3008 EFI_HII_ROUTING_PROTOCOL.ExtractConfig function.
3010 If there is an issue in resolving the contents of the KeywordString, then the function
3011 returns an EFI_INVALID_PARAMETER and also set the Progress and ProgressErr with the
3012 appropriate information about where the issue occurred and additional data about the
3013 nature of the issue.
3015 In the case when KeywordString is NULL, or contains multiple keywords, or when
3016 EFI_NOT_FOUND is generated while processing the keyword elements, the Results string
3017 contains values returned for all keywords processed prior to the keyword generating the
3018 error but no values for the keyword with error or any following keywords.
3021 @param This Pointer to the EFI_KEYWORD_HANDLER _PROTOCOL instance.
3023 @param NameSpaceId A null-terminated string containing the platform configuration
3024 language to search through in the system. If a NULL is passed
3025 in, then it is assumed that any platform configuration language
3026 with the prefix of "x-UEFI-" are searched.
3028 @param KeywordString A null-terminated string in <MultiKeywordRequest> format. If a
3029 NULL is passed in the KeywordString field, all of the known
3030 keywords in the system for the NameSpaceId specified are
3031 returned in the Results field.
3033 @param Progress On return, points to a character in the KeywordString. Points
3034 to the string's NULL terminator if the request was successful.
3035 Points to the most recent '&' before the first failing string
3036 element if the request was not successful.
3038 @param ProgressErr If during the processing of the KeywordString there was a
3039 failure, this parameter gives additional information about the
3040 possible source of the problem. See the definitions in SetData()
3041 for valid value definitions.
3043 @param Results A null-terminated string in <MultiKeywordResp> format is returned
3044 which has all the values filled in for the keywords in the
3045 KeywordString. This is a callee-allocated field, and must be freed
3046 by the caller after being used.
3048 @retval EFI_SUCCESS The specified action was completed successfully.
3050 @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
3051 1.Progress, ProgressErr, or Resuts is NULL.
3052 2.Parsing of the KeywordString resulted in an error. See
3053 Progress and ProgressErr for more data.
3056 @retval EFI_NOT_FOUND An element of the KeywordString was not found. See
3057 ProgressErr for more data.
3059 @retval EFI_NOT_FOUND The NamespaceId specified was not found. See ProgressErr
3062 @retval EFI_OUT_OF_RESOURCES Required system resources could not be allocated. See
3063 ProgressErr for more data.
3065 @retval EFI_ACCESS_DENIED The action violated system policy. See ProgressErr for
3068 @retval EFI_DEVICE_ERROR An unexpected system error occurred. See ProgressErr
3074 EfiConfigKeywordHandlerGetData (
3075 IN EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL
*This
,
3076 IN CONST EFI_STRING NameSpaceId
, OPTIONAL
3077 IN CONST EFI_STRING KeywordString
, OPTIONAL
3078 OUT EFI_STRING
*Progress
,
3079 OUT UINT32
*ProgressErr
,
3080 OUT EFI_STRING
*Results
3085 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
3086 HII_DATABASE_RECORD
*DataBaseRecord
;
3088 CHAR16
*NextStringPtr
;
3089 CHAR16
*KeywordData
;
3090 EFI_STRING_ID KeywordStringId
;
3092 CHAR16
*ConfigRequest
;
3093 CHAR16
*ValueElement
;
3096 CHAR16
*KeywordResp
;
3097 CHAR16
*MultiKeywordResp
;
3100 if (This
== NULL
|| Progress
== NULL
|| ProgressErr
== NULL
|| Results
== NULL
) {
3101 return EFI_INVALID_PARAMETER
;
3104 *ProgressErr
= KEYWORD_HANDLER_UNDEFINED_PROCESSING_ERROR
;
3105 Status
= EFI_SUCCESS
;
3109 ConfigRequest
= NULL
;
3110 StringPtr
= KeywordString
;
3112 MultiKeywordResp
= NULL
;
3113 KeywordStringId
= 0;
3117 // Use temp string to avoid changing input string buffer.
3119 if (NameSpaceId
!= NULL
) {
3120 TempString
= AllocateCopyPool (StrSize (NameSpaceId
), NameSpaceId
);
3121 ASSERT (TempString
!= NULL
);
3124 // 1. Get NameSpace from NameSpaceId keyword.
3126 Status
= ExtractNameSpace (TempString
, &NameSpace
, NULL
);
3127 if (TempString
!= NULL
) {
3128 FreePool (TempString
);
3131 if (EFI_ERROR (Status
)) {
3132 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
3136 // 1.1 Check whether the input namespace is valid.
3138 if (NameSpace
!= NULL
){
3139 if (AsciiStrnCmp(NameSpace
, UEFI_CONFIG_LANG
, AsciiStrLen (UEFI_CONFIG_LANG
)) != 0) {
3140 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
3141 return EFI_INVALID_PARAMETER
;
3145 if (KeywordString
!= NULL
) {
3147 // Use temp string to avoid changing input string buffer.
3149 TempString
= AllocateCopyPool (StrSize (KeywordString
), KeywordString
);
3150 ASSERT (TempString
!= NULL
);
3151 StringPtr
= TempString
;
3153 while (*StringPtr
!= L
'\0') {
3155 // 2. Get possible Device Path info from KeywordString.
3157 Status
= ExtractDevicePath (StringPtr
, (UINT8
**)&DevicePath
, &NextStringPtr
);
3158 if (EFI_ERROR (Status
)) {
3159 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
3162 StringPtr
= NextStringPtr
;
3166 // 3. Process Keyword section from the input keywordRequest string.
3168 // 3.1 Extract keyword from the KeywordRequest string.
3170 Status
= ExtractKeyword(StringPtr
, &KeywordData
, &NextStringPtr
);
3171 if (EFI_ERROR (Status
)) {
3173 // Can't find Keyword base on the input device path info.
3175 *ProgressErr
= KEYWORD_HANDLER_MALFORMED_STRING
;
3176 Status
= EFI_INVALID_PARAMETER
;
3181 // 3.2 Get EFI_STRING_ID for the input keyword.
3183 Status
= GetStringIdFromDatabase (&DevicePath
, &NameSpace
, KeywordData
, &RetVal
, &KeywordStringId
, &DataBaseRecord
);
3184 if (EFI_ERROR (Status
)) {
3185 *ProgressErr
= RetVal
;
3190 // 3.3 Construct the ConfigRequest string.
3192 Status
= ExtractConfigRequest (DataBaseRecord
, KeywordStringId
, &OpCode
, &ConfigRequest
);
3193 if (EFI_ERROR (Status
)) {
3198 // 3.4 Extract Value for the input keyword.
3200 Status
= ExtractValueFromDriver(ConfigRequest
, &ValueElement
);
3201 if (EFI_ERROR (Status
)) {
3202 if (Status
!= EFI_OUT_OF_RESOURCES
) {
3203 Status
= EFI_DEVICE_ERROR
;
3207 StringPtr
= NextStringPtr
;
3210 // 4. Process the possible filter section.
3212 RetVal
= ValidateFilter (OpCode
, StringPtr
, &NextStringPtr
, &ReadOnly
);
3213 if (RetVal
!= KEYWORD_HANDLER_NO_ERROR
) {
3214 *ProgressErr
= RetVal
;
3215 Status
= EFI_INVALID_PARAMETER
;
3218 StringPtr
= NextStringPtr
;
3222 // 5. Generate KeywordResp string.
3224 Status
= GenerateKeywordResp(NameSpace
, DevicePath
, KeywordData
, ValueElement
, ReadOnly
, &KeywordResp
);
3225 if (Status
!= EFI_SUCCESS
) {
3230 // 6. Merge to the MultiKeywordResp string.
3232 Status
= MergeToMultiKeywordResp(&MultiKeywordResp
, &KeywordResp
);
3233 if (EFI_ERROR (Status
)) {
3238 // 7. Update return value.
3240 *Results
= MultiKeywordResp
;
3243 // 8. Clean the temp buffer.
3245 FreePool (DevicePath
);
3246 FreePool (KeywordData
);
3247 FreePool (ValueElement
);
3248 FreePool (ConfigRequest
);
3251 ValueElement
= NULL
;
3252 ConfigRequest
= NULL
;
3253 if (KeywordResp
!= NULL
) {
3254 FreePool (KeywordResp
);
3260 // Enumerate all keyword in the system.
3262 Status
= EnumerateAllKeywords(NameSpace
, &MultiKeywordResp
, ProgressErr
);
3263 if (EFI_ERROR (Status
)) {
3266 *Results
= MultiKeywordResp
;
3269 *ProgressErr
= KEYWORD_HANDLER_NO_ERROR
;
3272 *Progress
= KeywordString
+ (StringPtr
- TempString
);
3274 if (TempString
!= NULL
) {
3275 FreePool (TempString
);
3277 if (NameSpace
!= NULL
) {
3278 FreePool (NameSpace
);
3280 if (DevicePath
!= NULL
) {
3281 FreePool (DevicePath
);
3283 if (KeywordData
!= NULL
) {
3284 FreePool (KeywordData
);