MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiLibNullClass.c

   1 /** @file
   2   Var Check Hii handler.
   3
   4 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "VarCheckHii.h"
  16
  17 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mVarCheckHiiHex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  18
  19 /**
  20   Dump some hexadecimal data.
  21
  22   @param[in] Indent     How many spaces to indent the output.
  23   @param[in] Offset     The offset of the dump.
  24   @param[in] DataSize   The size in bytes of UserData.
  25   @param[in] UserData   The data to dump.
  26
  27 **/
  28 VOID
  29 VarCheckHiiInternalDumpHex (
  30   IN UINTN        Indent,
  31   IN UINTN        Offset,
  32   IN UINTN        DataSize,
  33   IN VOID         *UserData
  34   )
  35 {
  36   UINT8 *Data;
  37
  38   CHAR8 Val[50];
  39
  40   CHAR8 Str[20];
  41
  42   UINT8 TempByte;
  43   UINTN Size;
  44   UINTN Index;
  45
  46   Data = UserData;
  47   while (DataSize != 0) {
  48     Size = 16;
  49     if (Size > DataSize) {
  50       Size = DataSize;
  51     }
  52
  53     for (Index = 0; Index < Size; Index += 1) {
  54       TempByte            = Data[Index];
  55       Val[Index * 3 + 0]  = mVarCheckHiiHex[TempByte >> 4];
  56       Val[Index * 3 + 1]  = mVarCheckHiiHex[TempByte & 0xF];
  57       Val[Index * 3 + 2]  = (CHAR8) ((Index == 7) ? '-' : ' ');
  58       Str[Index]          = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
  59     }
  60
  61     Val[Index * 3]  = 0;
  62     Str[Index]      = 0;
  63     DEBUG ((DEBUG_INFO , "%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str));
  64
  65     Data += Size;
  66     Offset += Size;
  67     DataSize -= Size;
  68   }
  69 }
  70
  71 /**
  72   Var Check Hii Question.
  73
  74   @param[in] HiiQuestion    Pointer to Hii Question
  75   @param[in] Data           Data pointer.
  76   @param[in] DataSize       Size of Data to set.
  77
  78   @retval TRUE  Check pass
  79   @retval FALSE Check fail.
  80
  81 **/
  82 BOOLEAN
  83 VarCheckHiiQuestion (
  84   IN VAR_CHECK_HII_QUESTION_HEADER  *HiiQuestion,
  85   IN VOID                           *Data,
  86   IN UINTN                          DataSize
  87   )
  88 {
  89   UINT64   OneData;
  90   UINT64   Minimum;
  91   UINT64   Maximum;
  92   UINT64   OneValue;
  93   UINT8    *Ptr;
  94   UINT8    Index;
  95   UINT8    MaxContainers;
  96   UINT8    StartBit;
  97   UINT8    EndBit;
  98   UINT8    TotalBits;
  99   UINT16   VarOffsetByteLevel;
 100   UINT8    StorageWidthByteLevel;
 101
 102   if (HiiQuestion->BitFieldStore) {
 103     VarOffsetByteLevel    = HiiQuestion->VarOffset / 8;
 104     TotalBits             = HiiQuestion->VarOffset % 8 + HiiQuestion->StorageWidth;
 105     StorageWidthByteLevel = (TotalBits % 8 == 0 ? TotalBits / 8: TotalBits / 8 + 1);
 106   } else {
 107     VarOffsetByteLevel    = HiiQuestion->VarOffset;
 108     StorageWidthByteLevel = HiiQuestion->StorageWidth;
 109   }
 110
 111   if (((UINT32) VarOffsetByteLevel + StorageWidthByteLevel) > DataSize) {
 112     DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: (VarOffset(0x%04x) + StorageWidth(0x%02x)) > Size(0x%x)\n", VarOffsetByteLevel, StorageWidthByteLevel, DataSize));
 113     return FALSE;
 114   }
 115
 116   OneData = 0;
 117   CopyMem (&OneData, (UINT8 *) Data + VarOffsetByteLevel, StorageWidthByteLevel);
 118   if (HiiQuestion->BitFieldStore) {
 119     //
 120     // Get the value from the bit field.
 121     //
 122     StartBit = HiiQuestion->VarOffset % 8;
 123     EndBit   = StartBit + HiiQuestion->StorageWidth - 1;
 124     OneData  = BitFieldRead64 (OneData, StartBit, EndBit);
 125   }
 126
 127   switch (HiiQuestion->OpCode) {
 128     case EFI_IFR_ONE_OF_OP:
 129       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion + 1);
 130       while ((UINTN) Ptr < (UINTN) HiiQuestion + HiiQuestion->Length) {
 131         OneValue = 0;
 132         if (HiiQuestion->BitFieldStore) {
 133           //
 134           // For OneOf stored in bit field, the value of options are saved as UINT32 type.
 135           //
 136           CopyMem (&OneValue, Ptr, sizeof (UINT32));
 137         } else {
 138           CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);
 139         }
 140         if (OneData == OneValue) {
 141           //
 142           // Match
 143           //
 144           break;
 145         }
 146         if (HiiQuestion->BitFieldStore) {
 147           Ptr += sizeof (UINT32);
 148         } else {
 149           Ptr += HiiQuestion->StorageWidth;
 150         }
 151       }
 152       if ((UINTN) Ptr >= ((UINTN) HiiQuestion + HiiQuestion->Length)) {
 153         //
 154         // No match
 155         //
 156         DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: OneOf mismatch (0x%lx)\n", OneData));
 157         DEBUG_CODE (VarCheckHiiInternalDumpHex (2, 0, HiiQuestion->Length, (UINT8 *) HiiQuestion););
 158         return FALSE;
 159       }
 160       break;
 161
 162     case EFI_IFR_CHECKBOX_OP:
 163       if ((OneData != 0) && (OneData != 1)) {
 164         DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: CheckBox mismatch (0x%lx)\n", OneData));
 165         DEBUG_CODE (VarCheckHiiInternalDumpHex (2, 0, HiiQuestion->Length, (UINT8 *) HiiQuestion););
 166         return FALSE;
 167       }
 168       break;
 169
 170     case EFI_IFR_NUMERIC_OP:
 171       Minimum = 0;
 172       Maximum = 0;
 173       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion + 1);
 174       if (HiiQuestion->BitFieldStore) {
 175         //
 176         // For Numeric stored in bit field, the value of Maximum/Minimum are saved as UINT32 type.
 177         //
 178         CopyMem (&Minimum, Ptr, sizeof (UINT32));
 179         Ptr += sizeof (UINT32);
 180         CopyMem (&Maximum, Ptr, sizeof (UINT32));
 181         Ptr += sizeof (UINT32);
 182       } else {
 183         CopyMem (&Minimum, Ptr, HiiQuestion->StorageWidth);
 184         Ptr += HiiQuestion->StorageWidth;
 185         CopyMem (&Maximum, Ptr, HiiQuestion->StorageWidth);
 186         Ptr += HiiQuestion->StorageWidth;
 187       }
 188
 189       //
 190       // No need to check Step, because it is ONLY for UI.
 191       //
 192       if ((OneData < Minimum) || (OneData > Maximum)) {
 193         DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: Numeric mismatch (0x%lx)\n", OneData));
 194         DEBUG_CODE (VarCheckHiiInternalDumpHex (2, 0, HiiQuestion->Length, (UINT8 *) HiiQuestion););
 195         return FALSE;
 196       }
 197       break;
 198
 199     case EFI_IFR_ORDERED_LIST_OP:
 200       MaxContainers = ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion)->MaxContainers;
 201       if (((UINT32) HiiQuestion->VarOffset + HiiQuestion->StorageWidth * MaxContainers) > DataSize) {
 202         DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: (VarOffset(0x%04x) + StorageWidth(0x%02x) * MaxContainers(0x%02x)) > Size(0x%x)\n", HiiQuestion->VarOffset, HiiQuestion->StorageWidth, MaxContainers, DataSize));
 203         return FALSE;
 204       }
 205       for (Index = 0; Index < MaxContainers; Index++) {
 206         OneData = 0;
 207         CopyMem (&OneData, (UINT8 *) Data + HiiQuestion->VarOffset + HiiQuestion->StorageWidth * Index, HiiQuestion->StorageWidth);
 208         if (OneData == 0) {
 209           //
 210           // The value of 0 is used to determine if a particular "slot" in the array is empty.
 211           //
 212           continue;
 213         }
 214
 215         Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion + 1);
 216         while ((UINTN) Ptr < ((UINTN) HiiQuestion + HiiQuestion->Length)) {
 217           OneValue = 0;
 218           CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);
 219           if (OneData == OneValue) {
 220             //
 221             // Match
 222             //
 223             break;
 224           }
 225           Ptr += HiiQuestion->StorageWidth;
 226         }
 227         if ((UINTN) Ptr >= ((UINTN) HiiQuestion + HiiQuestion->Length)) {
 228           //
 229           // No match
 230           //
 231           DEBUG ((DEBUG_INFO , "VarCheckHiiQuestion fail: OrderedList mismatch\n"));
 232           DEBUG_CODE (VarCheckHiiInternalDumpHex (2, 0, HiiQuestion->StorageWidth * MaxContainers, (UINT8 *) Data + HiiQuestion->VarOffset););
 233           DEBUG_CODE (VarCheckHiiInternalDumpHex (2, 0, HiiQuestion->Length, (UINT8 *) HiiQuestion););
 234           return FALSE;
 235         }
 236       }
 237       break;
 238
 239     default:
 240       ASSERT (FALSE);
 241       break;
 242   }
 243
 244   return TRUE;
 245 }
 246
 247 VAR_CHECK_HII_VARIABLE_HEADER   *mVarCheckHiiBin = NULL;
 248 UINTN                           mVarCheckHiiBinSize = 0;
 249
 250 /**
 251   SetVariable check handler HII.
 252
 253   @param[in] VariableName       Name of Variable to set.
 254   @param[in] VendorGuid         Variable vendor GUID.
 255   @param[in] Attributes         Attribute value of the variable.
 256   @param[in] DataSize           Size of Data to set.
 257   @param[in] Data               Data pointer.
 258
 259   @retval EFI_SUCCESS               The SetVariable check result was success.
 260   @retval EFI_SECURITY_VIOLATION    Check fail.
 261
 262 **/
 263 EFI_STATUS
 264 EFIAPI
 265 SetVariableCheckHandlerHii (
 266   IN CHAR16     *VariableName,
 267   IN EFI_GUID   *VendorGuid,
 268   IN UINT32     Attributes,
 269   IN UINTN      DataSize,
 270   IN VOID       *Data
 271   )
 272 {
 273   VAR_CHECK_HII_VARIABLE_HEADER     *HiiVariable;
 274   VAR_CHECK_HII_QUESTION_HEADER     *HiiQuestion;
 275
 276   if (mVarCheckHiiBin == NULL) {
 277     return EFI_SUCCESS;
 278   }
 279
 280   if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0)) {
 281     //
 282     // Do not check delete variable.
 283     //
 284     return EFI_SUCCESS;
 285   }
 286
 287   //
 288   // For Hii Variable header align.
 289   //
 290   HiiVariable = (VAR_CHECK_HII_VARIABLE_HEADER *) HEADER_ALIGN (mVarCheckHiiBin);
 291   while ((UINTN) HiiVariable < ((UINTN) mVarCheckHiiBin + mVarCheckHiiBinSize)) {
 292     if ((StrCmp ((CHAR16 *) (HiiVariable + 1), VariableName) == 0) &&
 293         (CompareGuid (&HiiVariable->Guid, VendorGuid))) {
 294       //
 295       // Found the Hii Variable that could be used to do check.
 296       //
 297       DEBUG ((DEBUG_INFO , "VarCheckHiiVariable - %s:%g with Attributes = 0x%08x Size = 0x%x\n", VariableName, VendorGuid, Attributes, DataSize));
 298       if (HiiVariable->Attributes != Attributes) {
 299         DEBUG ((DEBUG_INFO, "VarCheckHiiVariable fail for Attributes - 0x%08x\n", HiiVariable->Attributes));
 300         return EFI_SECURITY_VIOLATION;
 301       }
 302
 303       if (DataSize == 0) {
 304         DEBUG ((DEBUG_INFO, "VarCheckHiiVariable - CHECK PASS with DataSize == 0 !\n"));
 305         return EFI_SUCCESS;
 306       }
 307
 308       if (HiiVariable->Size != DataSize) {
 309         DEBUG ((DEBUG_INFO, "VarCheckHiiVariable fail for Size - 0x%x\n", HiiVariable->Size));
 310         return EFI_SECURITY_VIOLATION;
 311       }
 312
 313       //
 314       // Do the check.
 315       // For Hii Question header align.
 316       //
 317       HiiQuestion = (VAR_CHECK_HII_QUESTION_HEADER *) HEADER_ALIGN (((UINTN) HiiVariable + HiiVariable->HeaderLength));
 318       while ((UINTN) HiiQuestion < ((UINTN) HiiVariable + HiiVariable->Length)) {
 319         if (!VarCheckHiiQuestion (HiiQuestion, Data, DataSize)) {
 320           return EFI_SECURITY_VIOLATION;
 321         }
 322         //
 323         // For Hii Question header align.
 324         //
 325         HiiQuestion = (VAR_CHECK_HII_QUESTION_HEADER *) HEADER_ALIGN (((UINTN) HiiQuestion + HiiQuestion->Length));
 326       }
 327
 328       DEBUG ((DEBUG_INFO, "VarCheckHiiVariable - ALL CHECK PASS!\n"));
 329       return EFI_SUCCESS;
 330     }
 331     //
 332     // For Hii Variable header align.
 333     //
 334     HiiVariable = (VAR_CHECK_HII_VARIABLE_HEADER *) HEADER_ALIGN (((UINTN) HiiVariable + HiiVariable->Length));
 335   }
 336
 337   // Not found, so pass.
 338   return EFI_SUCCESS;
 339 }
 340
 341 #ifdef DUMP_VAR_CHECK_HII
 342 GLOBAL_REMOVE_IF_UNREFERENCED VAR_CHECK_HII_OPCODE_STRING   mHiiOpCodeStringTable[] = {
 343   {EFI_IFR_VARSTORE_EFI_OP,     "EfiVarStore"},
 344   {EFI_IFR_ONE_OF_OP,           "OneOf"},
 345   {EFI_IFR_CHECKBOX_OP,         "CheckBox"},
 346   {EFI_IFR_NUMERIC_OP,          "Numeric"},
 347   {EFI_IFR_ORDERED_LIST_OP,     "OrderedList"},
 348 };
 349
 350 /**
 351   HII opcode to string.
 352
 353   @param[in] HiiOpCode  Hii OpCode.
 354
 355   @return Pointer to string.
 356
 357 **/
 358 CHAR8 *
 359 HiiOpCodeToStr (
 360   IN UINT8  HiiOpCode
 361   )
 362 {
 363   UINTN     Index;
 364   for (Index = 0; Index < ARRAY_SIZE (mHiiOpCodeStringTable); Index++) {
 365     if (mHiiOpCodeStringTable[Index].HiiOpCode == HiiOpCode) {
 366       return mHiiOpCodeStringTable[Index].HiiOpCodeStr;
 367     }
 368   }
 369
 370   return "<UnknownHiiOpCode>";
 371 }
 372
 373 /**
 374   Dump Hii Question.
 375
 376   @param[in] HiiQuestion    Pointer to Hii Question.
 377
 378 **/
 379 VOID
 380 DumpHiiQuestion (
 381   IN VAR_CHECK_HII_QUESTION_HEADER  *HiiQuestion
 382   )
 383 {
 384   UINT64    Minimum;
 385   UINT64    Maximum;
 386   UINT64    OneValue;
 387   UINT8     *Ptr;
 388
 389   DEBUG ((DEBUG_INFO, "  VAR_CHECK_HII_QUESTION_HEADER\n"));
 390   DEBUG ((DEBUG_INFO, "    OpCode        - 0x%02x (%a) (%a)\n", HiiQuestion->OpCode, HiiOpCodeToStr (HiiQuestion->OpCode), (HiiQuestion->BitFieldStore? "bit level": "byte level")));
 391   DEBUG ((DEBUG_INFO, "    Length        - 0x%02x\n", HiiQuestion->Length));
 392   DEBUG ((DEBUG_INFO, "    VarOffset     - 0x%04x (%a)\n", HiiQuestion->VarOffset, (HiiQuestion->BitFieldStore? "bit level": "byte level")));
 393   DEBUG ((DEBUG_INFO, "    StorageWidth  - 0x%02x (%a)\n", HiiQuestion->StorageWidth, (HiiQuestion->BitFieldStore? "bit level": "byte level")));
 394
 395   switch (HiiQuestion->OpCode) {
 396     case EFI_IFR_ONE_OF_OP:
 397       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion + 1);
 398       while ((UINTN) Ptr < ((UINTN) HiiQuestion + HiiQuestion->Length)) {
 399         OneValue = 0;
 400         if (HiiQuestion->BitFieldStore) {
 401           //
 402           // For OneOf stored in bit field, the value of options are saved as UINT32 type.
 403           //
 404           CopyMem (&OneValue, Ptr, sizeof (UINT32));
 405           DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%08x\n", OneValue));
 406         } else {
 407           CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);
 408           switch (HiiQuestion->StorageWidth) {
 409             case sizeof (UINT8):
 410               DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%02x\n", OneValue));
 411               break;
 412             case sizeof (UINT16):
 413               DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%04x\n", OneValue));
 414               break;
 415             case sizeof (UINT32):
 416               DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%08x\n", OneValue));
 417               break;
 418             case sizeof (UINT64):
 419               DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%016lx\n", OneValue));
 420               break;
 421             default:
 422               ASSERT (FALSE);
 423               break;
 424           }
 425         }
 426         if (HiiQuestion->BitFieldStore) {
 427           Ptr += sizeof (UINT32);
 428         } else {
 429           Ptr += HiiQuestion->StorageWidth;
 430         }
 431       }
 432       break;
 433
 434     case EFI_IFR_CHECKBOX_OP:
 435       break;
 436
 437     case EFI_IFR_NUMERIC_OP:
 438       Minimum = 0;
 439       Maximum = 0;
 440       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion + 1);
 441       if(HiiQuestion->BitFieldStore) {
 442         //
 443         // For Numeric stored in bit field, the value of Maximum/Minimum are saved as UINT32 type.
 444         //
 445         CopyMem (&Minimum, Ptr, sizeof (UINT32));
 446         Ptr += sizeof (UINT32);
 447         CopyMem (&Maximum, Ptr, sizeof (UINT32));
 448         Ptr += sizeof (UINT32);
 449
 450         DEBUG ((DEBUG_INFO, "    Minimum       - 0x%08x\n", Minimum));
 451         DEBUG ((DEBUG_INFO, "    Maximum       - 0x%08x\n", Maximum));
 452       } else {
 453         CopyMem (&Minimum, Ptr, HiiQuestion->StorageWidth);
 454         Ptr += HiiQuestion->StorageWidth;
 455         CopyMem (&Maximum, Ptr, HiiQuestion->StorageWidth);
 456         Ptr += HiiQuestion->StorageWidth;
 457
 458         switch (HiiQuestion->StorageWidth) {
 459           case sizeof (UINT8):
 460             DEBUG ((DEBUG_INFO, "    Minimum       - 0x%02x\n", Minimum));
 461             DEBUG ((DEBUG_INFO, "    Maximum       - 0x%02x\n", Maximum));
 462             break;
 463           case sizeof (UINT16):
 464             DEBUG ((DEBUG_INFO, "    Minimum       - 0x%04x\n", Minimum));
 465             DEBUG ((DEBUG_INFO, "    Maximum       - 0x%04x\n", Maximum));
 466             break;
 467           case sizeof (UINT32):
 468             DEBUG ((DEBUG_INFO, "    Minimum       - 0x%08x\n", Minimum));
 469             DEBUG ((DEBUG_INFO, "    Maximum       - 0x%08x\n", Maximum));
 470             break;
 471           case sizeof (UINT64):
 472             DEBUG ((DEBUG_INFO, "    Minimum       - 0x%016lx\n", Minimum));
 473             DEBUG ((DEBUG_INFO, "    Maximum       - 0x%016lx\n", Maximum));
 474             break;
 475           default:
 476             ASSERT (FALSE);
 477             break;
 478         }
 479       }
 480       break;
 481
 482     case EFI_IFR_ORDERED_LIST_OP:
 483       DEBUG ((DEBUG_INFO, "    MaxContainers - 0x%02x\n", ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion)->MaxContainers));
 484       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion + 1);
 485       while ((UINTN) Ptr < ((UINTN) HiiQuestion + HiiQuestion->Length)) {
 486         OneValue = 0;
 487         CopyMem (&OneValue, Ptr, HiiQuestion->StorageWidth);
 488         switch (HiiQuestion->StorageWidth) {
 489           case sizeof (UINT8):
 490             DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%02x\n", OneValue));
 491             break;
 492           case sizeof (UINT16):
 493             DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%04x\n", OneValue));
 494             break;
 495           case sizeof (UINT32):
 496             DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%08x\n", OneValue));
 497             break;
 498           case sizeof (UINT64):
 499             DEBUG ((DEBUG_INFO, "    OneOfOption   - 0x%016lx\n", OneValue));
 500             break;
 501           default:
 502             ASSERT (FALSE);
 503             break;
 504         }
 505         Ptr += HiiQuestion->StorageWidth;
 506       }
 507       break;
 508
 509     default:
 510       ASSERT (FALSE);
 511       break;
 512   }
 513 }
 514
 515 /**
 516   Dump Hii Variable.
 517
 518   @param[in] HiiVariable    Pointer to Hii Variable.
 519
 520 **/
 521 VOID
 522 DumpHiiVariable (
 523   IN VAR_CHECK_HII_VARIABLE_HEADER  *HiiVariable
 524   )
 525 {
 526   VAR_CHECK_HII_QUESTION_HEADER *HiiQuestion;
 527
 528   DEBUG ((DEBUG_INFO, "VAR_CHECK_HII_VARIABLE_HEADER\n"));
 529   DEBUG ((DEBUG_INFO, "  Revision        - 0x%04x\n", HiiVariable->Revision));
 530   DEBUG ((DEBUG_INFO, "  HeaderLength    - 0x%04x\n", HiiVariable->HeaderLength));
 531   DEBUG ((DEBUG_INFO, "  Length          - 0x%08x\n", HiiVariable->Length));
 532   DEBUG ((DEBUG_INFO, "  OpCode          - 0x%02x (%a)\n", HiiVariable->OpCode, HiiOpCodeToStr (HiiVariable->OpCode)));
 533   DEBUG ((DEBUG_INFO, "  Size            - 0x%04x\n", HiiVariable->Size));
 534   DEBUG ((DEBUG_INFO, "  Attributes      - 0x%08x\n", HiiVariable->Attributes));
 535   DEBUG ((DEBUG_INFO, "  Guid            - %g\n", &HiiVariable->Guid));
 536   DEBUG ((DEBUG_INFO, "  Name            - %s\n", HiiVariable + 1));
 537
 538   //
 539   // For Hii Question header align.
 540   //
 541   HiiQuestion = (VAR_CHECK_HII_QUESTION_HEADER *) HEADER_ALIGN (((UINTN) HiiVariable + HiiVariable->HeaderLength));
 542   while ((UINTN) HiiQuestion < ((UINTN) HiiVariable + HiiVariable->Length)) {
 543     //
 544     // Dump Hii Question related to the Hii Variable.
 545     //
 546     DumpHiiQuestion (HiiQuestion);
 547     //
 548     // For Hii Question header align.
 549     //
 550     HiiQuestion = (VAR_CHECK_HII_QUESTION_HEADER *) HEADER_ALIGN (((UINTN) HiiQuestion + HiiQuestion->Length));
 551   }
 552 }
 553
 554 /**
 555   Dump Var Check HII.
 556
 557   @param[in] VarCheckHiiBin     Pointer to VarCheckHiiBin.
 558   @param[in] VarCheckHiiBinSize VarCheckHiiBin size.
 559
 560 **/
 561 VOID
 562 DumpVarCheckHii (
 563   IN VOID   *VarCheckHiiBin,
 564   IN UINTN  VarCheckHiiBinSize
 565   )
 566 {
 567   VAR_CHECK_HII_VARIABLE_HEADER     *HiiVariable;
 568
 569   DEBUG ((DEBUG_INFO, "DumpVarCheckHii\n"));
 570
 571   //
 572   // For Hii Variable header align.
 573   //
 574   HiiVariable = (VAR_CHECK_HII_VARIABLE_HEADER *) HEADER_ALIGN (VarCheckHiiBin);
 575   while ((UINTN) HiiVariable < ((UINTN) VarCheckHiiBin + VarCheckHiiBinSize)) {
 576     DumpHiiVariable (HiiVariable);
 577     //
 578     // For Hii Variable header align.
 579     //
 580     HiiVariable = (VAR_CHECK_HII_VARIABLE_HEADER *) HEADER_ALIGN (((UINTN) HiiVariable + HiiVariable->Length));
 581   }
 582 }
 583 #endif
 584
 585 /**
 586   Constructor function of VarCheckHiiLib to register var check HII handler.
 587
 588   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 589   @param[in] SystemTable    A pointer to the EFI System Table.
 590
 591   @retval EFI_SUCCESS       The constructor executed correctly.
 592
 593 **/
 594 EFI_STATUS
 595 EFIAPI
 596 VarCheckHiiLibNullClassConstructor (
 597   IN EFI_HANDLE             ImageHandle,
 598   IN EFI_SYSTEM_TABLE       *SystemTable
 599   )
 600 {
 601   VarCheckLibRegisterEndOfDxeCallback (VarCheckHiiGen);
 602   VarCheckLibRegisterAddressPointer ((VOID **) &mVarCheckHiiBin);
 603   VarCheckLibRegisterSetVariableCheckHandler (SetVariableCheckHandlerHii);
 604
 605   return EFI_SUCCESS;
 606 }
 607