VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/VarCheckUefiLib/VarCheckUefiLibNullClass.c@ 99404

最後變更 在這個檔案從99404是 99404,由 vboxsync 提交於 2 年 前

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • 屬性 svn:eol-style 設為 native
檔案大小: 22.5 KB
行 
1/** @file
2 Implementation functions and structures for var check uefi library.
3
4Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include <Uefi/UefiBaseType.h>
10
11#include <Library/VarCheckLib.h>
12#include <Library/BaseLib.h>
13#include <Library/BaseMemoryLib.h>
14#include <Library/DebugLib.h>
15#include <Library/DevicePathLib.h>
16
17#include <Guid/VariableFormat.h>
18#include <Guid/GlobalVariable.h>
19#include <Guid/HardwareErrorVariable.h>
20#include <Guid/ImageAuthentication.h>
21
22typedef
23EFI_STATUS
24(EFIAPI *INTERNAL_VAR_CHECK_FUNCTION)(
25 IN VAR_CHECK_VARIABLE_PROPERTY *Propery,
26 IN UINTN DataSize,
27 IN VOID *Data
28 );
29
30typedef struct {
31 CHAR16 *Name;
32 VAR_CHECK_VARIABLE_PROPERTY VariableProperty;
33 INTERNAL_VAR_CHECK_FUNCTION CheckFunction;
34} UEFI_DEFINED_VARIABLE_ENTRY;
35
36/**
37 Internal check for load option.
38
39 @param[in] VariablePropery Pointer to variable property.
40 @param[in] DataSize Data size.
41 @param[in] Data Pointer to data buffer.
42
43 @retval EFI_SUCCESS The SetVariable check result was success.
44 @retval EFI_INVALID_PARAMETER The data buffer is not a valid load option.
45
46**/
47EFI_STATUS
48EFIAPI
49InternalVarCheckLoadOption (
50 IN VAR_CHECK_VARIABLE_PROPERTY *VariablePropery,
51 IN UINTN DataSize,
52 IN VOID *Data
53 )
54{
55 UINT16 FilePathListLength;
56 CHAR16 *Description;
57 EFI_DEVICE_PATH_PROTOCOL *FilePathList;
58
59 FilePathListLength = *((UINT16 *)((UINTN)Data + sizeof (UINT32)));
60
61 //
62 // Check Description
63 //
64 Description = (CHAR16 *)((UINTN)Data + sizeof (UINT32) + sizeof (UINT16));
65 while (Description < (CHAR16 *)((UINTN)Data + DataSize)) {
66 if (*Description == L'\0') {
67 break;
68 }
69
70 Description++;
71 }
72
73 if ((UINTN)Description >= ((UINTN)Data + DataSize)) {
74 return EFI_INVALID_PARAMETER;
75 }
76
77 Description++;
78
79 //
80 // Check FilePathList
81 //
82 FilePathList = (EFI_DEVICE_PATH_PROTOCOL *)Description;
83 if ((UINTN)FilePathList > (MAX_ADDRESS - FilePathListLength)) {
84 return EFI_INVALID_PARAMETER;
85 }
86
87 if (((UINTN)FilePathList + FilePathListLength) > ((UINTN)Data + DataSize)) {
88 return EFI_INVALID_PARAMETER;
89 }
90
91 if (FilePathListLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
92 return EFI_INVALID_PARAMETER;
93 }
94
95 if (!IsDevicePathValid (FilePathList, FilePathListLength)) {
96 return EFI_INVALID_PARAMETER;
97 }
98
99 return EFI_SUCCESS;
100}
101
102/**
103 Internal check for key option.
104
105 @param[in] VariablePropery Pointer to variable property.
106 @param[in] DataSize Data size.
107 @param[in] Data Pointer to data buffer.
108
109 @retval EFI_SUCCESS The SetVariable check result was success.
110 @retval EFI_INVALID_PARAMETER The data buffer is not a valid key option.
111
112**/
113EFI_STATUS
114EFIAPI
115InternalVarCheckKeyOption (
116 IN VAR_CHECK_VARIABLE_PROPERTY *VariablePropery,
117 IN UINTN DataSize,
118 IN VOID *Data
119 )
120{
121 if (((DataSize - sizeof (EFI_KEY_OPTION)) % sizeof (EFI_INPUT_KEY)) != 0) {
122 return EFI_INVALID_PARAMETER;
123 }
124
125 return EFI_SUCCESS;
126}
127
128/**
129 Internal check for device path.
130
131 @param[in] VariablePropery Pointer to variable property.
132 @param[in] DataSize Data size.
133 @param[in] Data Pointer to data buffer.
134
135 @retval EFI_SUCCESS The SetVariable check result was success.
136 @retval EFI_INVALID_PARAMETER The data buffer is not a valid device path.
137
138**/
139EFI_STATUS
140EFIAPI
141InternalVarCheckDevicePath (
142 IN VAR_CHECK_VARIABLE_PROPERTY *VariablePropery,
143 IN UINTN DataSize,
144 IN VOID *Data
145 )
146{
147 if (!IsDevicePathValid ((EFI_DEVICE_PATH_PROTOCOL *)Data, DataSize)) {
148 return EFI_INVALID_PARAMETER;
149 }
150
151 return EFI_SUCCESS;
152}
153
154/**
155 Internal check for ASCII string.
156
157 @param[in] VariablePropery Pointer to variable property.
158 @param[in] DataSize Data size.
159 @param[in] Data Pointer to data buffer.
160
161 @retval EFI_SUCCESS The SetVariable check result was success.
162 @retval EFI_INVALID_PARAMETER The data buffer is not a Null-terminated ASCII string.
163
164**/
165EFI_STATUS
166EFIAPI
167InternalVarCheckAsciiString (
168 IN VAR_CHECK_VARIABLE_PROPERTY *VariablePropery,
169 IN UINTN DataSize,
170 IN VOID *Data
171 )
172{
173 CHAR8 *String;
174 UINTN Index;
175
176 String = (CHAR8 *)Data;
177 if (String[DataSize - 1] == '\0') {
178 return EFI_SUCCESS;
179 } else {
180 for (Index = 1; Index < DataSize && (String[DataSize - 1 - Index] != '\0'); Index++) {
181 }
182
183 if (Index == DataSize) {
184 return EFI_INVALID_PARAMETER;
185 }
186 }
187
188 return EFI_SUCCESS;
189}
190
191/**
192 Internal check for size array.
193
194 @param[in] VariablePropery Pointer to variable property.
195 @param[in] DataSize Data size.
196 @param[in] Data Pointer to data buffer.
197
198 @retval EFI_SUCCESS The SetVariable check result was success.
199 @retval EFI_INVALID_PARAMETER The DataSize is not size array.
200
201**/
202EFI_STATUS
203EFIAPI
204InternalVarCheckSizeArray (
205 IN VAR_CHECK_VARIABLE_PROPERTY *VariablePropery,
206 IN UINTN DataSize,
207 IN VOID *Data
208 )
209{
210 if ((DataSize % VariablePropery->MinSize) != 0) {
211 return EFI_INVALID_PARAMETER;
212 }
213
214 return EFI_SUCCESS;
215}
216
217//
218// To prevent name collisions with possible future globally defined variables,
219// other internal firmware data variables that are not defined here must be
220// saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or
221// any other GUID defined by the UEFI Specification. Implementations must
222// only permit the creation of variables with a UEFI Specification-defined
223// VendorGuid when these variables are documented in the UEFI Specification.
224//
225UEFI_DEFINED_VARIABLE_ENTRY mGlobalVariableList[] = {
226 {
227 EFI_LANG_CODES_VARIABLE_NAME,
228 {
229 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
230 0,
231 VARIABLE_ATTRIBUTE_BS_RT,
232 1,
233 MAX_UINTN
234 },
235 InternalVarCheckAsciiString
236 },
237 {
238 EFI_LANG_VARIABLE_NAME,
239 {
240 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
241 0,
242 VARIABLE_ATTRIBUTE_NV_BS_RT,
243 1,
244 MAX_UINTN
245 },
246 InternalVarCheckAsciiString
247 },
248 {
249 EFI_TIME_OUT_VARIABLE_NAME,
250 {
251 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
252 0,
253 VARIABLE_ATTRIBUTE_NV_BS_RT,
254 sizeof (UINT16),
255 sizeof (UINT16)
256 },
257 NULL
258 },
259 {
260 EFI_PLATFORM_LANG_CODES_VARIABLE_NAME,
261 {
262 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
263 0,
264 VARIABLE_ATTRIBUTE_BS_RT,
265 1,
266 MAX_UINTN
267 },
268 InternalVarCheckAsciiString
269 },
270 {
271 EFI_PLATFORM_LANG_VARIABLE_NAME,
272 {
273 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
274 0,
275 VARIABLE_ATTRIBUTE_NV_BS_RT,
276 1,
277 MAX_UINTN
278 },
279 InternalVarCheckAsciiString
280 },
281 {
282 EFI_CON_IN_VARIABLE_NAME,
283 {
284 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
285 0,
286 VARIABLE_ATTRIBUTE_NV_BS_RT,
287 sizeof (EFI_DEVICE_PATH_PROTOCOL),
288 MAX_UINTN
289 },
290 InternalVarCheckDevicePath
291 },
292 {
293 EFI_CON_OUT_VARIABLE_NAME,
294 {
295 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
296 0,
297 VARIABLE_ATTRIBUTE_NV_BS_RT,
298 sizeof (EFI_DEVICE_PATH_PROTOCOL),
299 MAX_UINTN
300 },
301 InternalVarCheckDevicePath
302 },
303 {
304 EFI_ERR_OUT_VARIABLE_NAME,
305 {
306 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
307 0,
308 VARIABLE_ATTRIBUTE_NV_BS_RT,
309 sizeof (EFI_DEVICE_PATH_PROTOCOL),
310 MAX_UINTN
311 },
312 InternalVarCheckDevicePath
313 },
314 {
315 EFI_CON_IN_DEV_VARIABLE_NAME,
316 {
317 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
318 0,
319 VARIABLE_ATTRIBUTE_BS_RT,
320 sizeof (EFI_DEVICE_PATH_PROTOCOL),
321 MAX_UINTN
322 },
323 InternalVarCheckDevicePath
324 },
325 {
326 EFI_CON_OUT_DEV_VARIABLE_NAME,
327 {
328 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
329 0,
330 VARIABLE_ATTRIBUTE_BS_RT,
331 sizeof (EFI_DEVICE_PATH_PROTOCOL),
332 MAX_UINTN
333 },
334 InternalVarCheckDevicePath
335 },
336 {
337 EFI_ERR_OUT_DEV_VARIABLE_NAME,
338 {
339 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
340 0,
341 VARIABLE_ATTRIBUTE_BS_RT,
342 sizeof (EFI_DEVICE_PATH_PROTOCOL),
343 MAX_UINTN
344 },
345 InternalVarCheckDevicePath
346 },
347 {
348 EFI_BOOT_ORDER_VARIABLE_NAME,
349 {
350 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
351 0,
352 VARIABLE_ATTRIBUTE_NV_BS_RT,
353 sizeof (UINT16),
354 MAX_UINTN
355 },
356 InternalVarCheckSizeArray
357 },
358 {
359 EFI_BOOT_NEXT_VARIABLE_NAME,
360 {
361 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
362 0,
363 VARIABLE_ATTRIBUTE_NV_BS_RT,
364 sizeof (UINT16),
365 sizeof (UINT16)
366 },
367 NULL
368 },
369 {
370 EFI_BOOT_CURRENT_VARIABLE_NAME,
371 {
372 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
373 0,
374 VARIABLE_ATTRIBUTE_BS_RT,
375 sizeof (UINT16),
376 sizeof (UINT16)
377 },
378 NULL
379 },
380 {
381 EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME,
382 {
383 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
384 0,
385 VARIABLE_ATTRIBUTE_BS_RT,
386 sizeof (UINT32),
387 sizeof (UINT32)
388 },
389 NULL
390 },
391 {
392 EFI_DRIVER_ORDER_VARIABLE_NAME,
393 {
394 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
395 0,
396 VARIABLE_ATTRIBUTE_NV_BS_RT,
397 sizeof (UINT16),
398 MAX_UINTN
399 },
400 InternalVarCheckSizeArray
401 },
402 {
403 EFI_SYS_PREP_ORDER_VARIABLE_NAME,
404 {
405 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
406 0,
407 VARIABLE_ATTRIBUTE_NV_BS_RT,
408 sizeof (UINT16),
409 MAX_UINTN
410 },
411 InternalVarCheckSizeArray
412 },
413 {
414 EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME,
415 {
416 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
417 0,
418 VARIABLE_ATTRIBUTE_NV_BS_RT,
419 sizeof (UINT16),
420 sizeof (UINT16)
421 },
422 NULL
423 },
424 {
425 EFI_SETUP_MODE_NAME,
426 {
427 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
428 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
429 VARIABLE_ATTRIBUTE_BS_RT,
430 sizeof (UINT8),
431 sizeof (UINT8)
432 },
433 NULL
434 },
435 {
436 EFI_KEY_EXCHANGE_KEY_NAME,
437 {
438 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
439 0,
440 VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
441 1,
442 MAX_UINTN
443 },
444 NULL
445 },
446 {
447 EFI_PLATFORM_KEY_NAME,
448 {
449 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
450 0,
451 VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
452 1,
453 MAX_UINTN
454 },
455 NULL
456 },
457 {
458 EFI_SIGNATURE_SUPPORT_NAME,
459 {
460 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
461 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
462 VARIABLE_ATTRIBUTE_BS_RT,
463 sizeof (EFI_GUID),
464 MAX_UINTN
465 },
466 InternalVarCheckSizeArray
467 },
468 {
469 EFI_SECURE_BOOT_MODE_NAME,
470 {
471 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
472 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
473 VARIABLE_ATTRIBUTE_BS_RT,
474 sizeof (UINT8),
475 sizeof (UINT8)
476 },
477 NULL
478 },
479 {
480 EFI_KEK_DEFAULT_VARIABLE_NAME,
481 {
482 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
483 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
484 VARIABLE_ATTRIBUTE_BS_RT,
485 1,
486 MAX_UINTN
487 },
488 NULL
489 },
490 {
491 EFI_PK_DEFAULT_VARIABLE_NAME,
492 {
493 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
494 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
495 VARIABLE_ATTRIBUTE_BS_RT,
496 1,
497 MAX_UINTN
498 },
499 NULL
500 },
501 {
502 EFI_DB_DEFAULT_VARIABLE_NAME,
503 {
504 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
505 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
506 VARIABLE_ATTRIBUTE_BS_RT,
507 1,
508 MAX_UINTN
509 },
510 NULL
511 },
512 {
513 EFI_DBX_DEFAULT_VARIABLE_NAME,
514 {
515 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
516 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
517 VARIABLE_ATTRIBUTE_BS_RT,
518 1,
519 MAX_UINTN
520 },
521 NULL
522 },
523 {
524 EFI_DBT_DEFAULT_VARIABLE_NAME,
525 {
526 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
527 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
528 VARIABLE_ATTRIBUTE_BS_RT,
529 1,
530 MAX_UINTN
531 },
532 NULL
533 },
534 {
535 EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME,
536 {
537 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
538 0,
539 VARIABLE_ATTRIBUTE_BS_RT,
540 sizeof (UINT64),
541 sizeof (UINT64)
542 },
543 NULL
544 },
545 {
546 EFI_OS_INDICATIONS_VARIABLE_NAME,
547 {
548 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
549 0,
550 VARIABLE_ATTRIBUTE_NV_BS_RT,
551 sizeof (UINT64),
552 sizeof (UINT64)
553 },
554 NULL
555 },
556 {
557 EFI_VENDOR_KEYS_VARIABLE_NAME,
558 {
559 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
560 VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
561 VARIABLE_ATTRIBUTE_BS_RT,
562 sizeof (UINT8),
563 sizeof (UINT8)
564 },
565 NULL
566 },
567};
568
569UEFI_DEFINED_VARIABLE_ENTRY mGlobalVariableList2[] = {
570 {
571 L"Boot####",
572 {
573 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
574 0,
575 VARIABLE_ATTRIBUTE_NV_BS_RT,
576 sizeof (UINT32) + sizeof (UINT16),
577 MAX_UINTN
578 },
579 InternalVarCheckLoadOption
580 },
581 {
582 L"Driver####",
583 {
584 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
585 0,
586 VARIABLE_ATTRIBUTE_NV_BS_RT,
587 sizeof (UINT32) + sizeof (UINT16),
588 MAX_UINTN
589 },
590 InternalVarCheckLoadOption
591 },
592 {
593 L"SysPrep####",
594 {
595 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
596 0,
597 VARIABLE_ATTRIBUTE_NV_BS_RT,
598 sizeof (UINT32) + sizeof (UINT16),
599 MAX_UINTN
600 },
601 InternalVarCheckLoadOption
602 },
603 {
604 L"Key####",
605 {
606 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
607 0,
608 VARIABLE_ATTRIBUTE_NV_BS_RT,
609 sizeof (EFI_KEY_OPTION),
610 sizeof (EFI_KEY_OPTION) + 3 * sizeof (EFI_INPUT_KEY)
611 },
612 InternalVarCheckKeyOption
613 },
614 {
615 L"PlatformRecovery####",
616 {
617 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
618 0,
619 VARIABLE_ATTRIBUTE_BS_RT,
620 sizeof (UINT32) + sizeof (UINT16),
621 MAX_UINTN
622 },
623 InternalVarCheckLoadOption
624 },
625};
626
627//
628// EFI_IMAGE_SECURITY_DATABASE_GUID
629//
630UEFI_DEFINED_VARIABLE_ENTRY mImageSecurityVariableList[] = {
631 {
632 EFI_IMAGE_SECURITY_DATABASE,
633 {
634 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
635 0,
636 VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
637 1,
638 MAX_UINTN
639 },
640 NULL
641 },
642 {
643 EFI_IMAGE_SECURITY_DATABASE1,
644 {
645 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
646 0,
647 VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
648 1,
649 MAX_UINTN
650 },
651 NULL
652 },
653 {
654 EFI_IMAGE_SECURITY_DATABASE2,
655 {
656 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
657 0,
658 VARIABLE_ATTRIBUTE_NV_BS_RT_AT,
659 1,
660 MAX_UINTN
661 },
662 NULL
663 },
664};
665
666//
667// EFI_HARDWARE_ERROR_VARIABLE
668//
669UEFI_DEFINED_VARIABLE_ENTRY mHwErrRecVariable = {
670 L"HwErrRec####",
671 {
672 VAR_CHECK_VARIABLE_PROPERTY_REVISION,
673 0,
674 VARIABLE_ATTRIBUTE_NV_BS_RT_HR,
675 1,
676 MAX_UINTN
677 },
678 NULL
679};
680
681EFI_GUID *mUefiDefinedGuid[] = {
682 &gEfiGlobalVariableGuid,
683 &gEfiImageSecurityDatabaseGuid,
684 &gEfiHardwareErrorVariableGuid
685};
686
687/**
688 Check if a Unicode character is an upper case hexadecimal character.
689
690 This function checks if a Unicode character is an upper case
691 hexadecimal character. The valid upper case hexadecimal character is
692 L'0' to L'9', or L'A' to L'F'.
693
694
695 @param[in] Char The character to check against.
696
697 @retval TRUE If the Char is an upper case hexadecmial character.
698 @retval FALSE If the Char is not an upper case hexadecmial character.
699
700**/
701BOOLEAN
702EFIAPI
703VarCheckUefiIsHexaDecimalDigitCharacter (
704 IN CHAR16 Char
705 )
706{
707 return (BOOLEAN)((Char >= L'0' && Char <= L'9') || (Char >= L'A' && Char <= L'F'));
708}
709
710/**
711
712 This code checks if variable is hardware error record variable or not.
713
714 According to UEFI spec, hardware error record variable should use the EFI_HARDWARE_ERROR_VARIABLE VendorGuid
715 and have the L"HwErrRec####" name convention, #### is a printed hex value and no 0x or h is included in the hex value.
716
717 @param[in] VariableName Pointer to variable name.
718 @param[in] VendorGuid Variable Vendor Guid.
719
720 @retval TRUE Variable is hardware error record variable.
721 @retval FALSE Variable is not hardware error record variable.
722
723**/
724BOOLEAN
725EFIAPI
726IsHwErrRecVariable (
727 IN CHAR16 *VariableName,
728 IN EFI_GUID *VendorGuid
729 )
730{
731 if (!CompareGuid (VendorGuid, &gEfiHardwareErrorVariableGuid) ||
732 (StrLen (VariableName) != StrLen (L"HwErrRec####")) ||
733 (StrnCmp (VariableName, L"HwErrRec", StrLen (L"HwErrRec")) != 0) ||
734 !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0x8]) ||
735 !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0x9]) ||
736 !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0xA]) ||
737 !VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[0xB]))
738 {
739 return FALSE;
740 }
741
742 return TRUE;
743}
744
745/**
746 Get UEFI defined var check function.
747
748 @param[in] VariableName Pointer to variable name.
749 @param[in] VendorGuid Pointer to variable vendor GUID.
750 @param[out] VariableProperty Pointer to variable property.
751
752 @return Internal var check function, NULL if no specific check function.
753
754**/
755INTERNAL_VAR_CHECK_FUNCTION
756GetUefiDefinedVarCheckFunction (
757 IN CHAR16 *VariableName,
758 IN EFI_GUID *VendorGuid,
759 OUT VAR_CHECK_VARIABLE_PROPERTY **VariableProperty
760 )
761{
762 UINTN Index;
763 UINTN NameLength;
764
765 if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid)) {
766 //
767 // Try list 1, exactly match.
768 //
769 for (Index = 0; Index < sizeof (mGlobalVariableList)/sizeof (mGlobalVariableList[0]); Index++) {
770 if (StrCmp (mGlobalVariableList[Index].Name, VariableName) == 0) {
771 *VariableProperty = &(mGlobalVariableList[Index].VariableProperty);
772 return mGlobalVariableList[Index].CheckFunction;
773 }
774 }
775
776 //
777 // Try list 2.
778 //
779 NameLength = StrLen (VariableName) - 4;
780 for (Index = 0; Index < sizeof (mGlobalVariableList2)/sizeof (mGlobalVariableList2[0]); Index++) {
781 if ((StrLen (VariableName) == StrLen (mGlobalVariableList2[Index].Name)) &&
782 (StrnCmp (VariableName, mGlobalVariableList2[Index].Name, NameLength) == 0) &&
783 VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength]) &&
784 VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength + 1]) &&
785 VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength + 2]) &&
786 VarCheckUefiIsHexaDecimalDigitCharacter (VariableName[NameLength + 3]))
787 {
788 *VariableProperty = &(mGlobalVariableList2[Index].VariableProperty);
789 return mGlobalVariableList2[Index].CheckFunction;
790 }
791 }
792 }
793
794 return NULL;
795}
796
797/**
798 SetVariable check handler UEFI defined.
799
800 @param[in] VariableName Name of Variable to set.
801 @param[in] VendorGuid Variable vendor GUID.
802 @param[in] Attributes Attribute value of the variable.
803 @param[in] DataSize Size of Data to set.
804 @param[in] Data Data pointer.
805
806 @retval EFI_SUCCESS The SetVariable check result was success.
807 @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, GUID,
808 DataSize and Data value was supplied.
809 @retval EFI_WRITE_PROTECTED The variable in question is read-only.
810
811**/
812EFI_STATUS
813EFIAPI
814SetVariableCheckHandlerUefiDefined (
815 IN CHAR16 *VariableName,
816 IN EFI_GUID *VendorGuid,
817 IN UINT32 Attributes,
818 IN UINTN DataSize,
819 IN VOID *Data
820 )
821{
822 EFI_STATUS Status;
823 UINTN Index;
824 VAR_CHECK_VARIABLE_PROPERTY Property;
825 VAR_CHECK_VARIABLE_PROPERTY *VarCheckProperty;
826 INTERNAL_VAR_CHECK_FUNCTION VarCheckFunction;
827
828 if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0)) {
829 //
830 // Do not check delete variable.
831 //
832 return EFI_SUCCESS;
833 }
834
835 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
836 if (!IsHwErrRecVariable (VariableName, VendorGuid)) {
837 return EFI_INVALID_PARAMETER;
838 }
839 }
840
841 for (Index = 0; Index < sizeof (mUefiDefinedGuid)/sizeof (mUefiDefinedGuid[0]); Index++) {
842 if (CompareGuid (VendorGuid, mUefiDefinedGuid[Index])) {
843 if (VarCheckLibVariablePropertyGet (VariableName, VendorGuid, &Property) == EFI_NOT_FOUND) {
844 //
845 // To prevent name collisions with possible future globally defined variables,
846 // other internal firmware data variables that are not defined here must be
847 // saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or
848 // any other GUID defined by the UEFI Specification. Implementations must
849 // only permit the creation of variables with a UEFI Specification-defined
850 // VendorGuid when these variables are documented in the UEFI Specification.
851 //
852 DEBUG ((DEBUG_INFO, "UEFI Variable Check fail %r - %s not in %g namespace\n", EFI_INVALID_PARAMETER, VariableName, VendorGuid));
853 return EFI_INVALID_PARAMETER;
854 }
855 }
856 }
857
858 if (DataSize == 0) {
859 return EFI_SUCCESS;
860 }
861
862 VarCheckProperty = NULL;
863 VarCheckFunction = GetUefiDefinedVarCheckFunction (VariableName, VendorGuid, &VarCheckProperty);
864 if (VarCheckFunction != NULL) {
865 Status = VarCheckFunction (
866 VarCheckProperty,
867 DataSize,
868 Data
869 );
870 if (EFI_ERROR (Status)) {
871 DEBUG ((DEBUG_INFO, "UEFI Variable Check function fail %r - %g:%s\n", Status, VendorGuid, VariableName));
872 return Status;
873 }
874 }
875
876 return EFI_SUCCESS;
877}
878
879/**
880 Variable property set for UEFI defined variables.
881
882**/
883VOID
884VariablePropertySetUefiDefined (
885 VOID
886 )
887{
888 UINTN Index;
889
890 //
891 // EFI_GLOBAL_VARIABLE
892 //
893 for (Index = 0; Index < sizeof (mGlobalVariableList)/sizeof (mGlobalVariableList[0]); Index++) {
894 VarCheckLibVariablePropertySet (
895 mGlobalVariableList[Index].Name,
896 &gEfiGlobalVariableGuid,
897 &mGlobalVariableList[Index].VariableProperty
898 );
899 }
900
901 for (Index = 0; Index < sizeof (mGlobalVariableList2)/sizeof (mGlobalVariableList2[0]); Index++) {
902 VarCheckLibVariablePropertySet (
903 mGlobalVariableList2[Index].Name,
904 &gEfiGlobalVariableGuid,
905 &mGlobalVariableList2[Index].VariableProperty
906 );
907 }
908
909 //
910 // EFI_IMAGE_SECURITY_DATABASE_GUID
911 //
912 for (Index = 0; Index < sizeof (mImageSecurityVariableList)/sizeof (mImageSecurityVariableList[0]); Index++) {
913 VarCheckLibVariablePropertySet (
914 mImageSecurityVariableList[Index].Name,
915 &gEfiImageSecurityDatabaseGuid,
916 &mImageSecurityVariableList[Index].VariableProperty
917 );
918 }
919
920 //
921 // EFI_HARDWARE_ERROR_VARIABLE
922 //
923 VarCheckLibVariablePropertySet (
924 mHwErrRecVariable.Name,
925 &gEfiHardwareErrorVariableGuid,
926 &mHwErrRecVariable.VariableProperty
927 );
928}
929
930/**
931 Constructor function of VarCheckUefiLib to set property and
932 register SetVariable check handler for UEFI defined variables.
933
934 @retval EFI_SUCCESS The constructor executed correctly.
935
936**/
937RETURN_STATUS
938EFIAPI
939VarCheckUefiLibNullClassConstructor (
940 VOID
941 )
942{
943 VariablePropertySetUefiDefined ();
944 VarCheckLibRegisterSetVariableCheckHandler (SetVariableCheckHandlerUefiDefined);
945
946 return RETURN_SUCCESS;
947}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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