VirtualBox

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

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

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

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