MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiGen.c

   1 /** @file
   2   Var Check Hii bin generation.
   3
   4 Copyright (c) 2015 - 2016, 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 "VarCheckHiiGen.h"
  16
  17 LIST_ENTRY mVarCheckHiiList = INITIALIZE_LIST_HEAD_VARIABLE (mVarCheckHiiList);
  18
  19 #define VAR_CHECK_HII_VARIABLE_NODE_SIGNATURE   SIGNATURE_32 ('V', 'C', 'H', 'V')
  20
  21 typedef struct {
  22   UINTN                         Signature;
  23   LIST_ENTRY                    Link;
  24   VAR_CHECK_HII_VARIABLE_HEADER *HiiVariable;
  25   EFI_VARSTORE_ID               VarStoreId;
  26
  27   VAR_CHECK_HII_QUESTION_HEADER **HiiQuestionArray;
  28 } VAR_CHECK_HII_VARIABLE_NODE;
  29
  30 #define VAR_CHECK_HII_VARIABLE_FROM_LINK(a) CR (a, VAR_CHECK_HII_VARIABLE_NODE, Link, VAR_CHECK_HII_VARIABLE_NODE_SIGNATURE)
  31
  32 CHAR16 *mVarName = NULL;
  33 UINTN  mMaxVarNameSize = 0;
  34
  35 #ifdef DUMP_HII_DATA
  36 GLOBAL_REMOVE_IF_UNREFERENCED VAR_CHECK_HII_OPCODE_STRING   mIfrOpCodeStringTable[] = {
  37   {EFI_IFR_VARSTORE_OP,             "EFI_IFR_VARSTORE_OP"},
  38   {EFI_IFR_VARSTORE_EFI_OP,         "EFI_IFR_VARSTORE_EFI_OP"},
  39   {EFI_IFR_ONE_OF_OP,               "EFI_IFR_ONE_OF_OP"},
  40   {EFI_IFR_CHECKBOX_OP,             "EFI_IFR_CHECKBOX_OP"},
  41   {EFI_IFR_NUMERIC_OP,              "EFI_IFR_NUMERIC_OP"},
  42   {EFI_IFR_ORDERED_LIST_OP,         "EFI_IFR_ORDERED_LIST_OP"},
  43   {EFI_IFR_ONE_OF_OPTION_OP,        "EFI_IFR_ONE_OF_OPTION_OP"},
  44 };
  45
  46 /**
  47   Ifr opcode to string.
  48
  49   @param[in] IfrOpCode  Ifr OpCode.
  50
  51   @return Pointer to string.
  52
  53 **/
  54 CHAR8 *
  55 IfrOpCodeToStr (
  56   IN UINT8  IfrOpCode
  57   )
  58 {
  59   UINTN  Index;
  60   for (Index = 0; Index < ARRAY_SIZE (mIfrOpCodeStringTable); Index++) {
  61     if (mIfrOpCodeStringTable[Index].HiiOpCode == IfrOpCode) {
  62       return mIfrOpCodeStringTable[Index].HiiOpCodeStr;
  63     }
  64   }
  65
  66   return "<UnknownIfrOpCode>";
  67 }
  68
  69 GLOBAL_REMOVE_IF_UNREFERENCED VAR_CHECK_HII_PACKAGE_TYPE_STRING  mPackageTypeStringTable[] = {
  70   {EFI_HII_PACKAGE_TYPE_ALL,            "EFI_HII_PACKAGE_TYPE_ALL"},
  71   {EFI_HII_PACKAGE_TYPE_GUID,           "EFI_HII_PACKAGE_TYPE_GUID"},
  72   {EFI_HII_PACKAGE_FORMS,               "EFI_HII_PACKAGE_FORMS"},
  73   {EFI_HII_PACKAGE_STRINGS,             "EFI_HII_PACKAGE_STRINGS"},
  74   {EFI_HII_PACKAGE_FONTS,               "EFI_HII_PACKAGE_FONTS"},
  75   {EFI_HII_PACKAGE_IMAGES,              "EFI_HII_PACKAGE_IMAGES"},
  76   {EFI_HII_PACKAGE_SIMPLE_FONTS,        "EFI_HII_PACKAGE_SIMPLE_FONTS"},
  77   {EFI_HII_PACKAGE_DEVICE_PATH,         "EFI_HII_PACKAGE_DEVICE_PATH"},
  78   {EFI_HII_PACKAGE_KEYBOARD_LAYOUT,     "EFI_HII_PACKAGE_KEYBOARD_LAYOUT"},
  79   {EFI_HII_PACKAGE_ANIMATIONS,          "EFI_HII_PACKAGE_ANIMATIONS"},
  80   {EFI_HII_PACKAGE_END,                 "EFI_HII_PACKAGE_END"},
  81   {EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN,   "EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN"},
  82   {EFI_HII_PACKAGE_TYPE_SYSTEM_END,     "EFI_HII_PACKAGE_TYPE_SYSTEM_END"},
  83 };
  84
  85 /**
  86   Hii Package type to string.
  87
  88   @param[in] PackageType    Package Type
  89
  90   @return Pointer to string.
  91
  92 **/
  93 CHAR8 *
  94 HiiPackageTypeToStr (
  95   IN UINT8  PackageType
  96   )
  97 {
  98   UINTN     Index;
  99   for (Index = 0; Index < ARRAY_SIZE (mPackageTypeStringTable); Index++) {
 100     if (mPackageTypeStringTable[Index].PackageType == PackageType) {
 101       return mPackageTypeStringTable[Index].PackageTypeStr;
 102     }
 103   }
 104
 105   return "<UnknownPackageType>";
 106 }
 107
 108 /**
 109   Dump Hii Package.
 110
 111   @param[in] HiiPackage         Pointer to Hii Package.
 112
 113 **/
 114 VOID
 115 DumpHiiPackage (
 116   IN VOID       *HiiPackage
 117   )
 118 {
 119   EFI_HII_PACKAGE_HEADER        *HiiPackageHeader;
 120   EFI_IFR_OP_HEADER             *IfrOpCodeHeader;
 121   EFI_IFR_VARSTORE              *IfrVarStore;
 122   EFI_IFR_VARSTORE_EFI          *IfrEfiVarStore;
 123
 124   HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiPackage;
 125
 126   DEBUG ((DEBUG_INFO, "  HiiPackageHeader->Type   - 0x%02x (%a)\n", HiiPackageHeader->Type, HiiPackageTypeToStr ((UINT8) HiiPackageHeader->Type)));
 127   DEBUG ((DEBUG_INFO, "  HiiPackageHeader->Length - 0x%06x\n", HiiPackageHeader->Length));
 128
 129   switch (HiiPackageHeader->Type) {
 130     case EFI_HII_PACKAGE_FORMS:
 131       IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) (HiiPackageHeader + 1);
 132
 133       while ((UINTN) IfrOpCodeHeader < ((UINTN) HiiPackageHeader + HiiPackageHeader->Length)) {
 134         switch (IfrOpCodeHeader->OpCode) {
 135           case EFI_IFR_VARSTORE_OP:
 136             IfrVarStore = (EFI_IFR_VARSTORE *) IfrOpCodeHeader;
 137             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->OpCode - 0x%02x (%a)\n", IfrOpCodeHeader->OpCode, IfrOpCodeToStr (IfrOpCodeHeader->OpCode)));
 138             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Length - 0x%02x\n", IfrOpCodeHeader->Length));
 139             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Scope  - 0x%02x\n", IfrOpCodeHeader->Scope));
 140             DEBUG ((DEBUG_INFO, "      Guid       - %g\n", &IfrVarStore->Guid));
 141             DEBUG ((DEBUG_INFO, "      VarStoreId - 0x%04x\n", IfrVarStore->VarStoreId));
 142             DEBUG ((DEBUG_INFO, "      Size       - 0x%04x\n", IfrVarStore->Size));
 143             DEBUG ((DEBUG_INFO, "      Name       - %a\n", IfrVarStore->Name));
 144             break;
 145
 146           case EFI_IFR_VARSTORE_EFI_OP:
 147             IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpCodeHeader;
 148             if (IfrEfiVarStore->Header.Length >= sizeof (EFI_IFR_VARSTORE_EFI)) {
 149               DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->OpCode - 0x%02x (%a)\n", IfrOpCodeHeader->OpCode, IfrOpCodeToStr (IfrOpCodeHeader->OpCode)));
 150               DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Length - 0x%02x\n", IfrOpCodeHeader->Length));
 151               DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Scope  - 0x%02x\n", IfrOpCodeHeader->Scope));
 152               DEBUG ((DEBUG_INFO, "      Guid       - %g\n", &IfrEfiVarStore->Guid));
 153               DEBUG ((DEBUG_INFO, "      VarStoreId - 0x%04x\n", IfrEfiVarStore->VarStoreId));
 154               DEBUG ((DEBUG_INFO, "      Size       - 0x%04x\n", IfrEfiVarStore->Size));
 155               DEBUG ((DEBUG_INFO, "      Attributes - 0x%08x\n", IfrEfiVarStore->Attributes));
 156               DEBUG ((DEBUG_INFO, "      Name       - %a\n", IfrEfiVarStore->Name));
 157             }
 158             break;
 159
 160           case EFI_IFR_ONE_OF_OP:
 161           case EFI_IFR_CHECKBOX_OP:
 162           case EFI_IFR_NUMERIC_OP:
 163           case EFI_IFR_ORDERED_LIST_OP:
 164             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->OpCode - 0x%02x (%a)\n", IfrOpCodeHeader->OpCode, IfrOpCodeToStr (IfrOpCodeHeader->OpCode)));
 165             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Length - 0x%02x\n", IfrOpCodeHeader->Length));
 166             DEBUG ((DEBUG_INFO, "    IfrOpCodeHeader->Scope  - 0x%02x\n", IfrOpCodeHeader->Scope));
 167             DEBUG ((DEBUG_INFO, "      Prompt       - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.Header.Prompt));
 168             DEBUG ((DEBUG_INFO, "      Help         - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.Header.Help));
 169             DEBUG ((DEBUG_INFO, "      QuestionId   - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.QuestionId));
 170             DEBUG ((DEBUG_INFO, "      VarStoreId   - 0x%04x\n", ((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.VarStoreId));
 171             DEBUG ((DEBUG_INFO, "      VarStoreInfo - 0x%04x\n", ((EFI_IFR_ONE_OF * )IfrOpCodeHeader)->Question.VarStoreInfo.VarOffset));
 172             {
 173               EFI_IFR_ONE_OF            *IfrOneOf;
 174               EFI_IFR_CHECKBOX          *IfrCheckBox;
 175               EFI_IFR_NUMERIC           *IfrNumeric;
 176               EFI_IFR_ORDERED_LIST      *IfrOrderedList;
 177
 178               switch (IfrOpCodeHeader->OpCode) {
 179                 case EFI_IFR_ONE_OF_OP:
 180                   IfrOneOf = (EFI_IFR_ONE_OF *) IfrOpCodeHeader;
 181                   DEBUG ((DEBUG_INFO, "      Flags         - 0x%02x\n", IfrOneOf->Flags));
 182                   switch (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE) {
 183                   case EFI_IFR_NUMERIC_SIZE_1:
 184                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%02x\n", IfrOneOf->data.u8.MinValue));
 185                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%02x\n", IfrOneOf->data.u8.MaxValue));
 186                     DEBUG ((DEBUG_INFO, "      Step          - 0x%02x\n", IfrOneOf->data.u8.Step));
 187                     break;
 188                   case EFI_IFR_NUMERIC_SIZE_2:
 189                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%04x\n", IfrOneOf->data.u16.MinValue));
 190                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%04x\n", IfrOneOf->data.u16.MaxValue));
 191                     DEBUG ((DEBUG_INFO, "      Step          - 0x%04x\n", IfrOneOf->data.u16.Step));
 192                     break;
 193                   case EFI_IFR_NUMERIC_SIZE_4:
 194                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%08x\n", IfrOneOf->data.u32.MinValue));
 195                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%08x\n", IfrOneOf->data.u32.MaxValue));
 196                     DEBUG ((DEBUG_INFO, "      Step          - 0x%08x\n", IfrOneOf->data.u32.Step));
 197                     break;
 198                   case EFI_IFR_NUMERIC_SIZE_8:
 199                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%016lx\n", IfrOneOf->data.u64.MinValue));
 200                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%016lx\n", IfrOneOf->data.u64.MaxValue));
 201                     DEBUG ((DEBUG_INFO, "      Step          - 0x%016lx\n", IfrOneOf->data.u64.Step));
 202                     break;
 203                   }
 204                   break;
 205                 case EFI_IFR_CHECKBOX_OP:
 206                   IfrCheckBox = (EFI_IFR_CHECKBOX *) IfrOpCodeHeader;
 207                   DEBUG ((DEBUG_INFO, "      Flags         - 0x%02x\n", IfrCheckBox->Flags));
 208                   break;
 209                 case EFI_IFR_NUMERIC_OP:
 210                   IfrNumeric = (EFI_IFR_NUMERIC *) IfrOpCodeHeader;
 211                   DEBUG ((DEBUG_INFO, "      Flags         - 0x%02x\n", IfrNumeric->Flags));
 212                   switch (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE) {
 213                   case EFI_IFR_NUMERIC_SIZE_1:
 214                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%02x\n", IfrNumeric->data.u8.MinValue));
 215                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%02x\n", IfrNumeric->data.u8.MaxValue));
 216                     DEBUG ((DEBUG_INFO, "      Step          - 0x%02x\n", IfrNumeric->data.u8.Step));
 217                     break;
 218                   case EFI_IFR_NUMERIC_SIZE_2:
 219                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%04x\n", IfrNumeric->data.u16.MinValue));
 220                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%04x\n", IfrNumeric->data.u16.MaxValue));
 221                     DEBUG ((DEBUG_INFO, "      Step          - 0x%04x\n", IfrNumeric->data.u16.Step));
 222                     break;
 223                   case EFI_IFR_NUMERIC_SIZE_4:
 224                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%08x\n", IfrNumeric->data.u32.MinValue));
 225                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%08x\n", IfrNumeric->data.u32.MaxValue));
 226                     DEBUG ((DEBUG_INFO, "      Step          - 0x%08x\n", IfrNumeric->data.u32.Step));
 227                     break;
 228                   case EFI_IFR_NUMERIC_SIZE_8:
 229                     DEBUG ((DEBUG_INFO, "      MinValue      - 0x%016lx\n", IfrNumeric->data.u64.MinValue));
 230                     DEBUG ((DEBUG_INFO, "      MaxValue      - 0x%016lx\n", IfrNumeric->data.u64.MaxValue));
 231                     DEBUG ((DEBUG_INFO, "      Step          - 0x%016lx\n", IfrNumeric->data.u64.Step));
 232                     break;
 233                   }
 234                   break;
 235                 case EFI_IFR_ORDERED_LIST_OP:
 236                   IfrOrderedList = (EFI_IFR_ORDERED_LIST *) IfrOpCodeHeader;
 237                   DEBUG ((DEBUG_INFO, "      MaxContainers - 0x%02x\n", IfrOrderedList->MaxContainers));
 238                   DEBUG ((DEBUG_INFO, "      Flags         - 0x%02x\n", IfrOrderedList->Flags));
 239                   break;
 240                 default:
 241                   break;
 242               }
 243
 244               if (IfrOpCodeHeader->Scope != 0) {
 245                 UINTN                       Scope;
 246                 EFI_IFR_ONE_OF_OPTION       *IfrOneOfOption;
 247
 248                 IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
 249                 Scope = 1;
 250                 while (Scope != 0) {
 251                   switch (IfrOpCodeHeader->OpCode) {
 252                     case EFI_IFR_ONE_OF_OPTION_OP:
 253                       IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *)IfrOpCodeHeader;
 254                       DEBUG ((DEBUG_INFO, "!!!!    IfrOpCodeHeader->OpCode - 0x%02x (%a)\n", (UINTN)IfrOpCodeHeader->OpCode, IfrOpCodeToStr (IfrOpCodeHeader->OpCode)));
 255                       DEBUG ((DEBUG_INFO, "!!!!    IfrOpCodeHeader->Scope  - 0x%02x\n", IfrOpCodeHeader->Scope));
 256                       DEBUG ((DEBUG_INFO, "!!!!      Option                - 0x%04x\n", IfrOneOfOption->Option));
 257                       DEBUG ((DEBUG_INFO, "!!!!      Flags                 - 0x%02x\n", IfrOneOfOption->Flags));
 258                       DEBUG ((DEBUG_INFO, "!!!!      Type                  - 0x%02x\n", IfrOneOfOption->Type));
 259                       switch (IfrOneOfOption->Type) {
 260                         case EFI_IFR_TYPE_NUM_SIZE_8:
 261                           DEBUG ((DEBUG_INFO, "!!!!      Value                 - 0x%02x\n", IfrOneOfOption->Value.u8));
 262                           break;
 263                         case EFI_IFR_TYPE_NUM_SIZE_16:
 264                           DEBUG ((DEBUG_INFO, "!!!!      Value                 - 0x%04x\n", IfrOneOfOption->Value.u16));
 265                           break;
 266                         case EFI_IFR_TYPE_NUM_SIZE_32:
 267                           DEBUG ((DEBUG_INFO, "!!!!      Value                 - 0x%08x\n", IfrOneOfOption->Value.u32));
 268                           break;
 269                         case EFI_IFR_TYPE_NUM_SIZE_64:
 270                           DEBUG ((DEBUG_INFO, "!!!!      Value                 - 0x%016lx\n", IfrOneOfOption->Value.u64));
 271                           break;
 272                         case EFI_IFR_TYPE_BOOLEAN:
 273                           DEBUG ((DEBUG_INFO, "!!!!      Value                 - 0x%02x\n", IfrOneOfOption->Value.b));
 274                           break;
 275                         default:
 276                           break;
 277                       }
 278                       break;
 279                   }
 280
 281                   if (IfrOpCodeHeader->OpCode == EFI_IFR_END_OP) {
 282                     ASSERT (Scope > 0);
 283                     Scope--;
 284                     if (Scope == 0) {
 285                       break;
 286                     }
 287                   } else if (IfrOpCodeHeader->Scope != 0) {
 288                     Scope++;
 289                   }
 290                   IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
 291                 }
 292               }
 293             }
 294           default:
 295             break;
 296         }
 297         IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
 298       }
 299       break;
 300     default:
 301       break;
 302   }
 303 }
 304
 305 /**
 306   Dump Hii Database.
 307
 308   @param[in] HiiDatabase        Pointer to Hii Database.
 309   @param[in] HiiDatabaseSize    Hii Database size.
 310
 311 **/
 312 VOID
 313 DumpHiiDatabase (
 314   IN VOID       *HiiDatabase,
 315   IN UINTN      HiiDatabaseSize
 316   )
 317 {
 318   EFI_HII_PACKAGE_LIST_HEADER   *HiiPackageListHeader;
 319   EFI_HII_PACKAGE_HEADER        *HiiPackageHeader;
 320
 321   DEBUG ((DEBUG_INFO, "HiiDatabaseSize - 0x%x\n", HiiDatabaseSize));
 322   HiiPackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *) HiiDatabase;
 323
 324   while ((UINTN) HiiPackageListHeader < ((UINTN) HiiDatabase + HiiDatabaseSize)) {
 325     DEBUG ((DEBUG_INFO, "HiiPackageListHeader->PackageListGuid - %g\n", &HiiPackageListHeader->PackageListGuid));
 326     DEBUG ((DEBUG_INFO, "HiiPackageListHeader->PackageLength   - 0x%x\n", (UINTN)HiiPackageListHeader->PackageLength));
 327     HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *)(HiiPackageListHeader + 1);
 328
 329     while ((UINTN) HiiPackageHeader < (UINTN) HiiPackageListHeader + HiiPackageListHeader->PackageLength) {
 330
 331       DumpHiiPackage (HiiPackageHeader);
 332
 333       HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) ((UINTN) HiiPackageHeader + HiiPackageHeader->Length);
 334     }
 335
 336     HiiPackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *) ((UINTN) HiiPackageListHeader + HiiPackageListHeader->PackageLength);
 337   }
 338
 339   return ;
 340 }
 341 #endif
 342
 343 /**
 344   Allocates a buffer of a certain pool type.
 345
 346   Allocates the number bytes specified by AllocationSize of a certain pool type and returns a
 347   pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
 348   returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
 349
 350   @param  MemoryType            The type of memory to allocate.
 351   @param  AllocationSize        The number of bytes to allocate.
 352
 353   @return A pointer to the allocated buffer or NULL if allocation fails.
 354
 355 **/
 356 VOID *
 357 InternalVarCheckAllocatePool (
 358   IN EFI_MEMORY_TYPE  MemoryType,
 359   IN UINTN            AllocationSize
 360   )
 361 {
 362   EFI_STATUS  Status;
 363   VOID        *Memory;
 364
 365   Status = gBS->AllocatePool (MemoryType, AllocationSize, &Memory);
 366   if (EFI_ERROR (Status)) {
 367     Memory = NULL;
 368   }
 369   return Memory;
 370 }
 371
 372 /**
 373   Allocates and zeros a buffer of type EfiBootServicesData.
 374
 375   Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
 376   buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
 377   valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
 378   request, then NULL is returned.
 379
 380   @param  AllocationSize        The number of bytes to allocate and zero.
 381
 382   @return A pointer to the allocated buffer or NULL if allocation fails.
 383
 384 **/
 385 VOID *
 386 InternalVarCheckAllocateZeroPool (
 387   IN UINTN            AllocationSize
 388   )
 389 {
 390   VOID  *Memory;
 391
 392   Memory = InternalVarCheckAllocatePool (EfiBootServicesData, AllocationSize);
 393   if (Memory != NULL) {
 394     Memory = ZeroMem (Memory, AllocationSize);
 395   }
 396   return Memory;
 397 }
 398
 399 /**
 400   Frees a buffer that was previously allocated with one of the pool allocation functions in the
 401   Memory Allocation Library.
 402
 403   Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the
 404   pool allocation services of the Memory Allocation Library.  If it is not possible to free pool
 405   resources, then this function will perform no actions.
 406
 407   If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
 408   then ASSERT().
 409
 410   @param  Buffer                The pointer to the buffer to free.
 411
 412 **/
 413 VOID
 414 EFIAPI
 415 InternalVarCheckFreePool (
 416   IN VOID   *Buffer
 417   )
 418 {
 419   EFI_STATUS    Status;
 420
 421   Status = gBS->FreePool (Buffer);
 422   ASSERT_EFI_ERROR (Status);
 423 }
 424
 425 /**
 426   Reallocates a buffer of type EfiBootServicesData.
 427
 428   Allocates and zeros the number bytes specified by NewSize from memory of type
 429   EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
 430   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
 431   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
 432   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
 433   enough memory remaining to satisfy the request, then NULL is returned.
 434
 435   If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
 436   is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
 437
 438   @param  OldSize        The size, in bytes, of OldBuffer.
 439   @param  NewSize        The size, in bytes, of the buffer to reallocate.
 440   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
 441                          parameter that may be NULL.
 442
 443   @return A pointer to the allocated buffer or NULL if allocation fails.
 444
 445 **/
 446 VOID *
 447 InternalVarCheckReallocatePool (
 448   IN UINTN            OldSize,
 449   IN UINTN            NewSize,
 450   IN VOID             *OldBuffer  OPTIONAL
 451   )
 452 {
 453   VOID  *NewBuffer;
 454
 455   NewBuffer = InternalVarCheckAllocateZeroPool (NewSize);
 456   if (NewBuffer != NULL && OldBuffer != NULL) {
 457     CopyMem (NewBuffer, OldBuffer, MIN (OldSize, NewSize));
 458     InternalVarCheckFreePool (OldBuffer);
 459   }
 460   return NewBuffer;
 461 }
 462
 463 /**
 464   Merge Hii Question.
 465
 466   @param[in, out] HiiVariableNode   Pointer to Hii Variable node.
 467   @param[in]      HiiQuestion       Pointer to Hii Question.
 468   @param[in]      FromFv            Hii Question from FV.
 469
 470 **/
 471 VOID
 472 MergeHiiQuestion (
 473   IN OUT VAR_CHECK_HII_VARIABLE_NODE    *HiiVariableNode,
 474   IN VAR_CHECK_HII_QUESTION_HEADER      *HiiQuestion,
 475   IN BOOLEAN                            FromFv
 476   )
 477 {
 478   VAR_CHECK_HII_QUESTION_HEADER     *HiiQuestion1;
 479   VAR_CHECK_HII_QUESTION_HEADER     *HiiQuestion2;
 480   VAR_CHECK_HII_QUESTION_HEADER     *NewHiiQuestion;
 481   UINT8                             NewLength;
 482   UINT64                            Minimum1;
 483   UINT64                            Maximum1;
 484   UINT64                            OneValue1;
 485   UINT64                            Minimum2;
 486   UINT64                            Maximum2;
 487   UINT64                            OneValue2;
 488   UINT8                             *Ptr;
 489   UINT8                             *Ptr1;
 490   UINT8                             *Ptr2;
 491
 492   //
 493   // Hii Question from Hii Database has high priority.
 494   // Do not to merge Hii Question from Fv to Hii Question from Hii Database.
 495   //
 496   if (FromFv) {
 497     InternalVarCheckFreePool (HiiQuestion);
 498     return;
 499   }
 500
 501   HiiQuestion1 = HiiVariableNode->HiiQuestionArray[HiiQuestion->VarOffset];
 502   HiiQuestion2 = HiiQuestion;
 503
 504   ASSERT ((HiiQuestion1->OpCode == HiiQuestion2->OpCode) && (HiiQuestion1->StorageWidth == HiiQuestion2->StorageWidth));
 505
 506   switch (HiiQuestion1->OpCode) {
 507     case EFI_IFR_ONE_OF_OP:
 508       DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_ONE_OF_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));
 509       //
 510       // Get the length of Hii Question 1.
 511       //
 512       NewLength = HiiQuestion1->Length;
 513
 514       //
 515       // Check if the one of options in Hii Question 2 have been in Hii Question 1.
 516       //
 517       Ptr2 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion2 + 1);
 518       while ((UINTN) Ptr2 < (UINTN) HiiQuestion2 + HiiQuestion2->Length) {
 519         OneValue2 = 0;
 520         CopyMem (&OneValue2, Ptr2, HiiQuestion2->StorageWidth);
 521
 522         Ptr1 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion1 + 1);
 523         while ((UINTN) Ptr1 < (UINTN) HiiQuestion1 + HiiQuestion1->Length) {
 524           OneValue1 = 0;
 525           CopyMem (&OneValue1, Ptr1, HiiQuestion1->StorageWidth);
 526           if (OneValue2 == OneValue1) {
 527             //
 528             // Match
 529             //
 530             break;
 531           }
 532           Ptr1 += HiiQuestion1->StorageWidth;
 533         }
 534         if ((UINTN) Ptr1 >= ((UINTN) HiiQuestion1 + HiiQuestion1->Length)) {
 535           //
 536           // No match
 537           //
 538           NewLength = (UINT8) (NewLength + HiiQuestion1->StorageWidth);
 539         }
 540         Ptr2 += HiiQuestion2->StorageWidth;
 541       }
 542
 543       if (NewLength > HiiQuestion1->Length) {
 544         //
 545         // Merge the one of options of Hii Question 2 and Hii Question 1.
 546         //
 547         NewHiiQuestion = InternalVarCheckAllocateZeroPool (NewLength);
 548         ASSERT (NewHiiQuestion != NULL);
 549         CopyMem (NewHiiQuestion, HiiQuestion1, HiiQuestion1->Length);
 550         //
 551         // Use the new length.
 552         //
 553         NewHiiQuestion->Length = NewLength;
 554         Ptr = (UINT8 *) NewHiiQuestion + HiiQuestion1->Length;
 555
 556         Ptr2 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion2 + 1);
 557         while ((UINTN) Ptr2 < (UINTN) HiiQuestion2 + HiiQuestion2->Length) {
 558           OneValue2 = 0;
 559           CopyMem (&OneValue2, Ptr2, HiiQuestion2->StorageWidth);
 560
 561           Ptr1 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ONEOF *) HiiQuestion1 + 1);
 562           while ((UINTN) Ptr1 < (UINTN) HiiQuestion1 + HiiQuestion1->Length) {
 563             OneValue1 = 0;
 564             CopyMem (&OneValue1, Ptr1, HiiQuestion1->StorageWidth);
 565             if (OneValue2 == OneValue1) {
 566               //
 567               // Match
 568               //
 569               break;
 570             }
 571             Ptr1 += HiiQuestion1->StorageWidth;
 572           }
 573           if ((UINTN) Ptr1 >= ((UINTN) HiiQuestion1 + HiiQuestion1->Length)) {
 574             //
 575             // No match
 576             //
 577             CopyMem (Ptr, &OneValue2, HiiQuestion1->StorageWidth);
 578             Ptr += HiiQuestion1->StorageWidth;
 579           }
 580           Ptr2 += HiiQuestion2->StorageWidth;
 581         }
 582
 583         HiiVariableNode->HiiQuestionArray[HiiQuestion1->VarOffset] = NewHiiQuestion;
 584         InternalVarCheckFreePool (HiiQuestion1);
 585       }
 586       break;
 587
 588     case EFI_IFR_CHECKBOX_OP:
 589       DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_CHECKBOX_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));
 590       break;
 591
 592     case EFI_IFR_NUMERIC_OP:
 593       DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_NUMERIC_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));
 594       //
 595       // Get minimum and maximum of Hii Question 1.
 596       //
 597       Minimum1 = 0;
 598       Maximum1 = 0;
 599       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion1 + 1);
 600       CopyMem (&Minimum1, Ptr, HiiQuestion1->StorageWidth);
 601       Ptr += HiiQuestion1->StorageWidth;
 602       CopyMem (&Maximum1, Ptr, HiiQuestion1->StorageWidth);
 603
 604       //
 605       // Get minimum and maximum of Hii Question 2.
 606       //
 607       Minimum2 = 0;
 608       Maximum2 = 0;
 609       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion2 + 1);
 610       CopyMem (&Minimum2, Ptr, HiiQuestion2->StorageWidth);
 611       Ptr += HiiQuestion2->StorageWidth;
 612       CopyMem (&Maximum2, Ptr, HiiQuestion2->StorageWidth);
 613
 614       //
 615       // Update minimum.
 616       //
 617       Ptr = (UINT8 *) ((VAR_CHECK_HII_QUESTION_NUMERIC *) HiiQuestion1 + 1);
 618       if (Minimum2 < Minimum1) {
 619         Minimum1 = Minimum2;
 620         CopyMem (Ptr, &Minimum1, HiiQuestion1->StorageWidth);
 621       }
 622       //
 623       // Update maximum.
 624       //
 625       Ptr += HiiQuestion1->StorageWidth;
 626       if (Maximum2 > Maximum1) {
 627         Maximum1 = Maximum2;
 628         CopyMem (Ptr, &Maximum1, HiiQuestion1->StorageWidth);
 629       }
 630       break;
 631
 632     case EFI_IFR_ORDERED_LIST_OP:
 633       DEBUG ((DEBUG_INFO, "MergeHiiQuestion - EFI_IFR_ORDERED_LIST_OP VarOffset = 0x%04x\n", HiiQuestion1->VarOffset));
 634       //
 635       // Get the length of Hii Question 1.
 636       //
 637       NewLength = HiiQuestion1->Length;
 638
 639       //
 640       // Check if the one of options in Hii Question 2 have been in Hii Question 1.
 641       //
 642       Ptr2 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion2 + 1);
 643       while ((UINTN) Ptr2 < (UINTN) HiiQuestion2 + HiiQuestion2->Length) {
 644         OneValue2 = 0;
 645         CopyMem (&OneValue2, Ptr2, HiiQuestion2->StorageWidth);
 646
 647         Ptr1 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion1 + 1);
 648         while ((UINTN) Ptr1 < (UINTN) HiiQuestion1 + HiiQuestion1->Length) {
 649           OneValue1 = 0;
 650           CopyMem (&OneValue1, Ptr1, HiiQuestion1->StorageWidth);
 651           if (OneValue2 == OneValue1) {
 652             //
 653             // Match
 654             //
 655             break;
 656           }
 657           Ptr1 += HiiQuestion1->StorageWidth;
 658         }
 659         if ((UINTN) Ptr1 >= ((UINTN) HiiQuestion1 + HiiQuestion1->Length)) {
 660           //
 661           // No match
 662           //
 663           NewLength = (UINT8) (NewLength + HiiQuestion1->StorageWidth);
 664         }
 665         Ptr2 += HiiQuestion2->StorageWidth;
 666       }
 667
 668       if (NewLength > HiiQuestion1->Length) {
 669         //
 670         // Merge the one of options of Hii Question 2 and Hii Question 1.
 671         //
 672         NewHiiQuestion = InternalVarCheckAllocateZeroPool (NewLength);
 673         ASSERT (NewHiiQuestion != NULL);
 674         CopyMem (NewHiiQuestion, HiiQuestion1, HiiQuestion1->Length);
 675         //
 676         // Use the new length.
 677         //
 678         NewHiiQuestion->Length = NewLength;
 679         Ptr = (UINT8 *) NewHiiQuestion + HiiQuestion1->Length;
 680
 681         Ptr2 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion2 + 1);
 682         while ((UINTN) Ptr2 < (UINTN) HiiQuestion2 + HiiQuestion2->Length) {
 683           OneValue2 = 0;
 684           CopyMem (&OneValue2, Ptr2, HiiQuestion2->StorageWidth);
 685
 686           Ptr1 = (UINT8 *) ((VAR_CHECK_HII_QUESTION_ORDEREDLIST *) HiiQuestion1 + 1);
 687           while ((UINTN) Ptr1 < (UINTN) HiiQuestion1 + HiiQuestion1->Length) {
 688             OneValue1 = 0;
 689             CopyMem (&OneValue1, Ptr1, HiiQuestion1->StorageWidth);
 690             if (OneValue2 == OneValue1) {
 691               //
 692               // Match
 693               //
 694               break;
 695             }
 696             Ptr1 += HiiQuestion1->StorageWidth;
 697           }
 698           if ((UINTN) Ptr1 >= ((UINTN) HiiQuestion1 + HiiQuestion1->Length)) {
 699             //
 700             // No match
 701             //
 702             CopyMem (Ptr, &OneValue2, HiiQuestion1->StorageWidth);
 703             Ptr += HiiQuestion1->StorageWidth;
 704           }
 705           Ptr2 += HiiQuestion2->StorageWidth;
 706         }
 707
 708         HiiVariableNode->HiiQuestionArray[HiiQuestion1->VarOffset] = NewHiiQuestion;
 709         InternalVarCheckFreePool (HiiQuestion1);
 710       }
 711       break;
 712
 713     default:
 714       ASSERT (FALSE);
 715       return;
 716       break;
 717   }
 718
 719   //
 720   //
 721   // Hii Question 2 has been merged with Hii Question 1.
 722   //
 723   InternalVarCheckFreePool (HiiQuestion2);
 724 }
 725
 726 /**
 727   Get OneOf option data.
 728
 729   @param[in]  IfrOpCodeHeader   Pointer to Ifr OpCode header.
 730   @param[out] Count             Pointer to option count.
 731   @param[out] Width             Pointer to option width.
 732   @param[out] OptionBuffer      Pointer to option buffer.
 733
 734 **/
 735 VOID
 736 GetOneOfOption (
 737   IN  EFI_IFR_OP_HEADER     *IfrOpCodeHeader,
 738   OUT UINTN                 *Count,
 739   OUT UINT8                 *Width,
 740   OUT VOID                  *OptionBuffer OPTIONAL
 741   )
 742 {
 743   UINTN                     Scope;
 744   EFI_IFR_ONE_OF_OPTION     *IfrOneOfOption;
 745
 746   //
 747   // Assume all OPTION has same Width.
 748   //
 749   *Count = 0;
 750
 751   if (IfrOpCodeHeader->Scope != 0) {
 752     //
 753     // Nested OpCode.
 754     //
 755     Scope = 1;
 756     IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
 757     while (Scope != 0) {
 758       switch (IfrOpCodeHeader->OpCode) {
 759         case EFI_IFR_ONE_OF_OPTION_OP:
 760           IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *) IfrOpCodeHeader;
 761           switch (IfrOneOfOption->Type) {
 762             case EFI_IFR_TYPE_NUM_SIZE_8:
 763               *Count = *Count + 1;
 764               *Width = sizeof (UINT8);
 765               if (OptionBuffer != NULL) {
 766                 CopyMem (OptionBuffer, &IfrOneOfOption->Value.u8, sizeof (UINT8));
 767                 OptionBuffer = (UINT8 *) OptionBuffer + 1;
 768               }
 769               break;
 770             case EFI_IFR_TYPE_NUM_SIZE_16:
 771               *Count = *Count + 1;
 772               *Width = sizeof (UINT16);
 773               if (OptionBuffer != NULL) {
 774                 CopyMem (OptionBuffer, &IfrOneOfOption->Value.u16, sizeof (UINT16));
 775                 OptionBuffer = (UINT16 *) OptionBuffer + 1;
 776               }
 777               break;
 778             case EFI_IFR_TYPE_NUM_SIZE_32:
 779               *Count = *Count + 1;
 780               *Width = sizeof (UINT32);
 781               if (OptionBuffer != NULL) {
 782                 CopyMem (OptionBuffer, &IfrOneOfOption->Value.u32, sizeof (UINT32));
 783                 OptionBuffer = (UINT32 *) OptionBuffer + 1;
 784               }
 785               break;
 786             case EFI_IFR_TYPE_NUM_SIZE_64:
 787               *Count = *Count + 1;
 788               *Width = sizeof (UINT64);
 789               if (OptionBuffer != NULL) {
 790                 CopyMem (OptionBuffer, &IfrOneOfOption->Value.u64, sizeof (UINT64));
 791                 OptionBuffer = (UINT64 *) OptionBuffer + 1;
 792               }
 793               break;
 794             case EFI_IFR_TYPE_BOOLEAN:
 795               *Count = *Count + 1;
 796               *Width = sizeof (BOOLEAN);
 797               if (OptionBuffer != NULL) {
 798                 CopyMem (OptionBuffer, &IfrOneOfOption->Value.b, sizeof (BOOLEAN));
 799                 OptionBuffer = (BOOLEAN *) OptionBuffer + 1;
 800               }
 801               break;
 802             default:
 803               break;
 804           }
 805           break;
 806       }
 807
 808       //
 809       // Until End OpCode.
 810       //
 811       if (IfrOpCodeHeader->OpCode == EFI_IFR_END_OP) {
 812         ASSERT (Scope > 0);
 813         Scope--;
 814         if (Scope == 0) {
 815           break;
 816         }
 817       } else if (IfrOpCodeHeader->Scope != 0) {
 818         //
 819         // Nested OpCode.
 820         //
 821         Scope++;
 822       }
 823       IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
 824     }
 825   }
 826
 827   return ;
 828 }
 829
 830 /**
 831   Parse Hii Question Oneof.
 832
 833   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.
 834
 835   return Pointer to Hii Question.
 836
 837 **/
 838 VAR_CHECK_HII_QUESTION_HEADER *
 839 ParseHiiQuestionOneOf (
 840   IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader
 841   )
 842 {
 843   EFI_IFR_ONE_OF                *IfrOneOf;
 844   VAR_CHECK_HII_QUESTION_ONEOF  *OneOf;
 845   UINTN                         Length;
 846   UINT8                         Width;
 847   UINTN                         OptionCount;
 848   UINT8                         OptionWidth;
 849
 850   IfrOneOf = (EFI_IFR_ONE_OF *) IfrOpCodeHeader;
 851
 852   Width = (UINT8) (1 << (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE));
 853
 854   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, NULL);
 855   ASSERT (Width == OptionWidth);
 856
 857   Length = sizeof (*OneOf) + OptionCount * Width;
 858
 859   OneOf = InternalVarCheckAllocateZeroPool (Length);
 860   ASSERT (OneOf != NULL);
 861   OneOf->OpCode       = EFI_IFR_ONE_OF_OP;
 862   OneOf->Length       = (UINT8) Length;
 863   OneOf->VarOffset    = IfrOneOf->Question.VarStoreInfo.VarOffset;
 864   OneOf->StorageWidth = Width;
 865
 866   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, OneOf + 1);
 867
 868   return (VAR_CHECK_HII_QUESTION_HEADER *) OneOf;
 869 }
 870
 871 /**
 872   Parse Hii Question CheckBox.
 873
 874   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.
 875
 876   return Pointer to Hii Question.
 877
 878 **/
 879 VAR_CHECK_HII_QUESTION_HEADER *
 880 ParseHiiQuestionCheckBox (
 881   IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader
 882   )
 883 {
 884   EFI_IFR_CHECKBOX                  *IfrCheckBox;
 885   VAR_CHECK_HII_QUESTION_CHECKBOX   *CheckBox;
 886
 887   IfrCheckBox = (EFI_IFR_CHECKBOX *) IfrOpCodeHeader;
 888
 889   CheckBox = InternalVarCheckAllocateZeroPool (sizeof (*CheckBox));
 890   ASSERT (CheckBox != NULL);
 891   CheckBox->OpCode       = EFI_IFR_CHECKBOX_OP;
 892   CheckBox->Length       = (UINT8) sizeof (*CheckBox);;
 893   CheckBox->VarOffset    = IfrCheckBox->Question.VarStoreInfo.VarOffset;
 894   CheckBox->StorageWidth = (UINT8) sizeof (BOOLEAN);
 895
 896   return (VAR_CHECK_HII_QUESTION_HEADER *) CheckBox;
 897 }
 898
 899 /**
 900   Parse Hii Question Numeric.
 901
 902   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.
 903
 904   return Pointer to Hii Question.
 905
 906 **/
 907 VAR_CHECK_HII_QUESTION_HEADER *
 908 ParseHiiQuestionNumeric (
 909   IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader
 910   )
 911 {
 912   EFI_IFR_NUMERIC                   *IfrNumeric;
 913   VAR_CHECK_HII_QUESTION_NUMERIC    *Numeric;
 914   UINT8                             Width;
 915
 916   IfrNumeric = (EFI_IFR_NUMERIC *) IfrOpCodeHeader;
 917
 918   Numeric = InternalVarCheckAllocateZeroPool (sizeof (VAR_CHECK_HII_QUESTION_NUMERIC) + 2 * sizeof (UINT64));
 919   ASSERT (Numeric != NULL);
 920
 921   Width = (UINT8) (1 << (IfrNumeric->Flags & EFI_IFR_NUMERIC_SIZE));
 922
 923   Numeric->OpCode       = EFI_IFR_NUMERIC_OP;
 924   Numeric->Length       = (UINT8) (sizeof (VAR_CHECK_HII_QUESTION_NUMERIC) + 2 * Width);
 925   Numeric->VarOffset    = IfrNumeric->Question.VarStoreInfo.VarOffset;
 926   Numeric->StorageWidth = Width;
 927
 928   CopyMem (Numeric + 1, &IfrNumeric->data, Width * 2);
 929
 930   return (VAR_CHECK_HII_QUESTION_HEADER *) Numeric;
 931 }
 932
 933 /**
 934   Parse Hii Question OrderedList.
 935
 936   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.
 937
 938   return Pointer to Hii Question.
 939
 940 **/
 941 VAR_CHECK_HII_QUESTION_HEADER *
 942 ParseHiiQuestionOrderedList (
 943   IN EFI_IFR_OP_HEADER  *IfrOpCodeHeader
 944   )
 945 {
 946   EFI_IFR_ORDERED_LIST                  *IfrOrderedList;
 947   VAR_CHECK_HII_QUESTION_ORDEREDLIST    *OrderedList;
 948   UINTN                                 Length;
 949   UINTN                                 OptionCount;
 950   UINT8                                 OptionWidth;
 951
 952   IfrOrderedList = (EFI_IFR_ORDERED_LIST *) IfrOpCodeHeader;
 953
 954   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, NULL);
 955
 956   Length = sizeof (*OrderedList) + OptionCount * OptionWidth;
 957
 958   OrderedList = InternalVarCheckAllocateZeroPool (Length);
 959   ASSERT (OrderedList != NULL);
 960   OrderedList->OpCode        = EFI_IFR_ORDERED_LIST_OP;
 961   OrderedList->Length        = (UINT8) Length;
 962   OrderedList->VarOffset     = IfrOrderedList->Question.VarStoreInfo.VarOffset;
 963   OrderedList->StorageWidth  = OptionWidth;
 964   OrderedList->MaxContainers = IfrOrderedList->MaxContainers;
 965
 966   GetOneOfOption (IfrOpCodeHeader, &OptionCount, &OptionWidth, OrderedList + 1);
 967
 968   return (VAR_CHECK_HII_QUESTION_HEADER *) OrderedList;
 969 }
 970
 971 /**
 972   Parse and create Hii Question node.
 973
 974   @param[in] HiiVariableNode    Pointer to Hii Variable node.
 975   @param[in] IfrOpCodeHeader    Pointer to Ifr OpCode header.
 976   @param[in] FromFv             Hii Question from FV.
 977
 978 **/
 979 VOID
 980 ParseHiiQuestion (
 981   IN VAR_CHECK_HII_VARIABLE_NODE    *HiiVariableNode,
 982   IN  EFI_IFR_OP_HEADER             *IfrOpCodeHeader,
 983   IN BOOLEAN                        FromFv
 984   )
 985 {
 986   VAR_CHECK_HII_QUESTION_HEADER *HiiQuestion;
 987
 988   switch (IfrOpCodeHeader->OpCode) {
 989     case EFI_IFR_ONE_OF_OP:
 990       HiiQuestion = ParseHiiQuestionOneOf (IfrOpCodeHeader);
 991       break;
 992
 993     case EFI_IFR_CHECKBOX_OP:
 994       HiiQuestion = ParseHiiQuestionCheckBox (IfrOpCodeHeader);
 995       break;
 996
 997     case EFI_IFR_NUMERIC_OP:
 998       HiiQuestion = ParseHiiQuestionNumeric (IfrOpCodeHeader);
 999       break;
1000
1001     case EFI_IFR_ORDERED_LIST_OP:
1002       HiiQuestion = ParseHiiQuestionOrderedList (IfrOpCodeHeader);
1003       break;
1004
1005     default:
1006       ASSERT (FALSE);
1007       return;
1008       break;
1009   }
1010
1011   if (HiiVariableNode->HiiQuestionArray[HiiQuestion->VarOffset] != NULL) {
1012     MergeHiiQuestion (HiiVariableNode, HiiQuestion, FromFv);
1013   } else {
1014     HiiVariableNode->HiiQuestionArray[HiiQuestion->VarOffset] = HiiQuestion;
1015   }
1016 }
1017
1018 /**
1019   Find Hii variable node by name and GUID.
1020
1021   @param[in] Name   Pointer to variable name.
1022   @param[in] Guid   Pointer to vendor GUID.
1023
1024   @return Pointer to Hii Variable node.
1025
1026 **/
1027 VAR_CHECK_HII_VARIABLE_NODE *
1028 FindHiiVariableNode (
1029   IN CHAR16     *Name,
1030   IN EFI_GUID   *Guid
1031   )
1032 {
1033   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1034   LIST_ENTRY                    *Link;
1035
1036   for (Link = mVarCheckHiiList.ForwardLink
1037       ;Link != &mVarCheckHiiList
1038       ;Link = Link->ForwardLink) {
1039     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (Link);
1040
1041     if ((StrCmp (Name, (CHAR16 *) (HiiVariableNode->HiiVariable + 1)) == 0) &&
1042         CompareGuid (Guid, &HiiVariableNode->HiiVariable->Guid)) {
1043       return HiiVariableNode;
1044     }
1045   }
1046
1047   return NULL;
1048 }
1049
1050 /**
1051   Find Hii variable node by var store id.
1052
1053   @param[in] VarStoreId         Var store id.
1054
1055   @return Pointer to Hii Variable node.
1056
1057 **/
1058 VAR_CHECK_HII_VARIABLE_NODE *
1059 FindHiiVariableNodeByVarStoreId (
1060   IN EFI_VARSTORE_ID            VarStoreId
1061   )
1062 {
1063   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1064   LIST_ENTRY                    *Link;
1065
1066   if (VarStoreId == 0) {
1067     //
1068     // The variable store identifier, which is unique within the current form set.
1069     // A value of zero is invalid.
1070     //
1071     return NULL;
1072   }
1073
1074   for (Link = mVarCheckHiiList.ForwardLink
1075       ;Link != &mVarCheckHiiList
1076       ;Link = Link->ForwardLink) {
1077     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (Link);
1078     //
1079     // The variable store identifier, which is unique within the current form set.
1080     //
1081     if (VarStoreId == HiiVariableNode->VarStoreId) {
1082       return HiiVariableNode;
1083     }
1084   }
1085
1086   return NULL;
1087 }
1088
1089 /**
1090   Destroy var store id in the Hii Variable node after parsing one Hii Package.
1091
1092 **/
1093 VOID
1094 DestroyVarStoreId (
1095   VOID
1096   )
1097 {
1098   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1099   LIST_ENTRY                    *Link;
1100
1101   for (Link = mVarCheckHiiList.ForwardLink
1102       ;Link != &mVarCheckHiiList
1103       ;Link = Link->ForwardLink) {
1104     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (Link);
1105     //
1106     // The variable store identifier, which is unique within the current form set.
1107     // A value of zero is invalid.
1108     //
1109     HiiVariableNode->VarStoreId = 0;
1110   }
1111 }
1112
1113 /**
1114   Create Hii Variable node.
1115
1116   @param[in] IfrEfiVarStore  Pointer to EFI VARSTORE.
1117
1118 **/
1119 VOID
1120 CreateHiiVariableNode (
1121   IN EFI_IFR_VARSTORE_EFI   *IfrEfiVarStore
1122   )
1123 {
1124   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1125   VAR_CHECK_HII_VARIABLE_HEADER *HiiVariable;
1126   UINTN                         HeaderLength;
1127   CHAR16                        *VarName;
1128   UINTN                         VarNameSize;
1129
1130   //
1131   // Get variable name.
1132   //
1133   VarNameSize = AsciiStrSize ((CHAR8 *) IfrEfiVarStore->Name) * sizeof (CHAR16);
1134   if (VarNameSize > mMaxVarNameSize) {
1135     mVarName = InternalVarCheckReallocatePool (mMaxVarNameSize, VarNameSize, mVarName);
1136     ASSERT (mVarName != NULL);
1137     mMaxVarNameSize = VarNameSize;
1138   }
1139   AsciiStrToUnicodeStrS ((CHAR8 *) IfrEfiVarStore->Name, mVarName, mMaxVarNameSize / sizeof (CHAR16));
1140   VarName = mVarName;
1141
1142   HiiVariableNode = FindHiiVariableNode (
1143                       VarName,
1144                       &IfrEfiVarStore->Guid
1145                       );
1146   if (HiiVariableNode == NULL) {
1147     //
1148     // Not found, then create new.
1149     //
1150     HeaderLength = sizeof (*HiiVariable) + VarNameSize;
1151     HiiVariable = InternalVarCheckAllocateZeroPool (HeaderLength);
1152     ASSERT (HiiVariable != NULL);
1153     HiiVariable->Revision = VAR_CHECK_HII_REVISION;
1154     HiiVariable->OpCode = EFI_IFR_VARSTORE_EFI_OP;
1155     HiiVariable->HeaderLength = (UINT16) HeaderLength;
1156     HiiVariable->Size = IfrEfiVarStore->Size;
1157     HiiVariable->Attributes = IfrEfiVarStore->Attributes;
1158     CopyGuid (&HiiVariable->Guid, &IfrEfiVarStore->Guid);
1159     StrCpyS ((CHAR16 *) (HiiVariable + 1), VarNameSize / sizeof (CHAR16), VarName);
1160
1161     HiiVariableNode = InternalVarCheckAllocateZeroPool (sizeof (*HiiVariableNode));
1162     ASSERT (HiiVariableNode != NULL);
1163     HiiVariableNode->Signature = VAR_CHECK_HII_VARIABLE_NODE_SIGNATURE;
1164     HiiVariableNode->HiiVariable = HiiVariable;
1165     //
1166     // The variable store identifier, which is unique within the current form set.
1167     //
1168     HiiVariableNode->VarStoreId = IfrEfiVarStore->VarStoreId;
1169     HiiVariableNode->HiiQuestionArray = InternalVarCheckAllocateZeroPool (IfrEfiVarStore->Size * sizeof (VAR_CHECK_HII_QUESTION_HEADER *));
1170
1171     InsertTailList (&mVarCheckHiiList, &HiiVariableNode->Link);
1172   } else {
1173     HiiVariableNode->VarStoreId = IfrEfiVarStore->VarStoreId;
1174   }
1175 }
1176
1177 /**
1178   Parse and create Hii Variable node list.
1179
1180   @param[in] HiiPackage         Pointer to Hii Package.
1181
1182 **/
1183 VOID
1184 ParseHiiVariable (
1185   IN VOID       *HiiPackage
1186   )
1187 {
1188   EFI_HII_PACKAGE_HEADER    *HiiPackageHeader;
1189   EFI_IFR_OP_HEADER         *IfrOpCodeHeader;
1190   EFI_IFR_VARSTORE_EFI      *IfrEfiVarStore;
1191
1192   HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiPackage;
1193
1194   switch (HiiPackageHeader->Type) {
1195     case EFI_HII_PACKAGE_FORMS:
1196       IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) (HiiPackageHeader + 1);
1197
1198       while ((UINTN) IfrOpCodeHeader < (UINTN) HiiPackageHeader + HiiPackageHeader->Length) {
1199         switch (IfrOpCodeHeader->OpCode) {
1200           case EFI_IFR_VARSTORE_EFI_OP:
1201             //
1202             // Come to EFI VARSTORE in Form Package.
1203             //
1204             IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpCodeHeader;
1205             if ((IfrEfiVarStore->Header.Length >= sizeof (EFI_IFR_VARSTORE_EFI)) &&
1206                 ((IfrEfiVarStore->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0)) {
1207               //
1208               // Only create node list for Hii Variable with NV attribute.
1209               //
1210               CreateHiiVariableNode (IfrEfiVarStore);
1211             }
1212             break;
1213
1214           default:
1215             break;
1216         }
1217       IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
1218       }
1219       break;
1220
1221     default:
1222       break;
1223   }
1224 }
1225
1226 /**
1227   Var Check Parse Hii Package.
1228
1229   @param[in] HiiPackage         Pointer to Hii Package.
1230   @param[in] FromFv             Hii Package from FV.
1231
1232 **/
1233 VOID
1234 VarCheckParseHiiPackage (
1235   IN VOID       *HiiPackage,
1236   IN BOOLEAN    FromFv
1237   )
1238 {
1239   EFI_HII_PACKAGE_HEADER        *HiiPackageHeader;
1240   EFI_IFR_OP_HEADER             *IfrOpCodeHeader;
1241   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1242
1243   //
1244   // Parse and create Hii Variable node list for this Hii Package.
1245   //
1246   ParseHiiVariable (HiiPackage);
1247
1248   HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiPackage;
1249
1250   switch (HiiPackageHeader->Type) {
1251     case EFI_HII_PACKAGE_FORMS:
1252       IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) (HiiPackageHeader + 1);
1253
1254       while ((UINTN) IfrOpCodeHeader < (UINTN) HiiPackageHeader + HiiPackageHeader->Length) {
1255         switch (IfrOpCodeHeader->OpCode) {
1256           case EFI_IFR_ONE_OF_OP:
1257           case EFI_IFR_CHECKBOX_OP:
1258           case EFI_IFR_NUMERIC_OP:
1259           case EFI_IFR_ORDERED_LIST_OP:
1260             HiiVariableNode = FindHiiVariableNodeByVarStoreId (((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.VarStoreId);
1261             if ((HiiVariableNode == NULL) ||
1262                 //
1263                 // No related Hii Variable node found.
1264                 //
1265                 ((((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.Header.Prompt == 0) && (((EFI_IFR_ONE_OF *) IfrOpCodeHeader)->Question.Header.Help == 0))) {
1266                 //
1267                 // meanless IFR item introduced by ECP.
1268                 //
1269             } else {
1270               //
1271               // Normal IFR
1272               //
1273               ParseHiiQuestion (HiiVariableNode, IfrOpCodeHeader, FromFv);
1274             }
1275           default:
1276             break;
1277         }
1278         IfrOpCodeHeader = (EFI_IFR_OP_HEADER *) ((UINTN) IfrOpCodeHeader + IfrOpCodeHeader->Length);
1279       }
1280       break;
1281
1282     default:
1283       break;
1284   }
1285   DestroyVarStoreId ();
1286 }
1287
1288 /**
1289   Var Check Parse Hii Database.
1290
1291   @param[in] HiiDatabase        Pointer to Hii Database.
1292   @param[in] HiiDatabaseSize    Hii Database size.
1293
1294 **/
1295 VOID
1296 VarCheckParseHiiDatabase (
1297   IN VOID       *HiiDatabase,
1298   IN UINTN      HiiDatabaseSize
1299   )
1300 {
1301   EFI_HII_PACKAGE_LIST_HEADER   *HiiPackageListHeader;
1302   EFI_HII_PACKAGE_HEADER        *HiiPackageHeader;
1303
1304   HiiPackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *) HiiDatabase;
1305
1306   while ((UINTN) HiiPackageListHeader < ((UINTN) HiiDatabase + HiiDatabaseSize)) {
1307     HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) (HiiPackageListHeader + 1);
1308
1309     while ((UINTN) HiiPackageHeader < ((UINTN) HiiPackageListHeader + HiiPackageListHeader->PackageLength)) {
1310       //
1311       // Parse Hii Package.
1312       //
1313       VarCheckParseHiiPackage (HiiPackageHeader, FALSE);
1314
1315       HiiPackageHeader = (EFI_HII_PACKAGE_HEADER *) ((UINTN) HiiPackageHeader + HiiPackageHeader->Length);
1316     }
1317
1318     HiiPackageListHeader = (EFI_HII_PACKAGE_LIST_HEADER *) ((UINTN) HiiPackageListHeader + HiiPackageListHeader->PackageLength);
1319   }
1320 }
1321
1322 /**
1323   Destroy Hii Variable node.
1324
1325 **/
1326 VOID
1327 DestroyHiiVariableNode (
1328   VOID
1329   )
1330 {
1331   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1332   LIST_ENTRY                    *HiiVariableLink;
1333   UINTN                         Index;
1334
1335   while (mVarCheckHiiList.ForwardLink != &mVarCheckHiiList) {
1336     HiiVariableLink = mVarCheckHiiList.ForwardLink;
1337     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (HiiVariableLink);
1338
1339     RemoveEntryList (&HiiVariableNode->Link);
1340
1341     //
1342     // Free the allocated buffer.
1343     //
1344     for (Index = 0; Index < HiiVariableNode->HiiVariable->Size; Index++) {
1345       if (HiiVariableNode->HiiQuestionArray[Index] != NULL) {
1346         InternalVarCheckFreePool (HiiVariableNode->HiiQuestionArray[Index]);
1347       }
1348     }
1349     InternalVarCheckFreePool (HiiVariableNode->HiiQuestionArray);
1350     InternalVarCheckFreePool (HiiVariableNode->HiiVariable);
1351     InternalVarCheckFreePool (HiiVariableNode);
1352   }
1353 }
1354
1355 /**
1356   Build VarCheckHiiBin.
1357
1358   @param[out] Size      Pointer to VarCheckHii size.
1359
1360   @return Pointer to VarCheckHiiBin.
1361
1362 **/
1363 VOID *
1364 BuildVarCheckHiiBin (
1365   OUT UINTN  *Size
1366   )
1367 {
1368   VAR_CHECK_HII_VARIABLE_NODE   *HiiVariableNode;
1369   LIST_ENTRY                    *HiiVariableLink;
1370   UINTN                         Index;
1371   VOID                          *Data;
1372   UINT8                         *Ptr;
1373   UINT32                        BinSize;
1374   UINT32                        HiiVariableLength;
1375
1376   //
1377   // Get Size
1378   //
1379   BinSize = 0;
1380
1381   for (HiiVariableLink = mVarCheckHiiList.ForwardLink
1382       ;HiiVariableLink != &mVarCheckHiiList
1383       ;HiiVariableLink = HiiVariableLink->ForwardLink) {
1384     //
1385     // For Hii Variable header align.
1386     //
1387     BinSize = (UINT32) HEADER_ALIGN (BinSize);
1388
1389     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (HiiVariableLink);
1390     HiiVariableLength = HiiVariableNode->HiiVariable->HeaderLength;
1391
1392     for (Index = 0; Index < HiiVariableNode->HiiVariable->Size; Index++) {
1393       if (HiiVariableNode->HiiQuestionArray[Index] != NULL) {
1394         //
1395         // For Hii Question header align.
1396         //
1397         HiiVariableLength = (UINT32) HEADER_ALIGN (HiiVariableLength);
1398         HiiVariableLength += HiiVariableNode->HiiQuestionArray[Index]->Length;
1399       }
1400     }
1401
1402     HiiVariableNode->HiiVariable->Length = HiiVariableLength;
1403     BinSize += HiiVariableLength;
1404   }
1405
1406   DEBUG ((DEBUG_INFO, "VarCheckHiiBin - size = 0x%x\n", BinSize));
1407   if (BinSize == 0) {
1408     *Size = BinSize;
1409     return NULL;
1410   }
1411
1412   //
1413   // AllocatePages () and AllocatePool () from gBS are used for the process of VarCheckHiiBin generation.
1414   // Only here AllocateRuntimeZeroPool () from MemoryAllocateLib is used for runtime access
1415   // in SetVariable check handler.
1416   //
1417   Data = AllocateRuntimeZeroPool (BinSize);
1418   ASSERT (Data != NULL);
1419   DEBUG ((DEBUG_INFO, "VarCheckHiiBin - built at 0x%x\n", Data));
1420
1421   //
1422   // Gen Data
1423   //
1424   Ptr = Data;
1425   for (HiiVariableLink = mVarCheckHiiList.ForwardLink
1426       ;HiiVariableLink != &mVarCheckHiiList
1427       ;HiiVariableLink = HiiVariableLink->ForwardLink) {
1428     //
1429     // For Hii Variable header align.
1430     //
1431     Ptr = (UINT8 *) HEADER_ALIGN (Ptr);
1432
1433     HiiVariableNode = VAR_CHECK_HII_VARIABLE_FROM_LINK (HiiVariableLink);
1434     CopyMem (Ptr, HiiVariableNode->HiiVariable, HiiVariableNode->HiiVariable->HeaderLength);
1435     Ptr += HiiVariableNode->HiiVariable->HeaderLength;
1436
1437     for (Index = 0; Index < HiiVariableNode->HiiVariable->Size; Index++) {
1438       if (HiiVariableNode->HiiQuestionArray[Index] != NULL) {
1439         //
1440         // For Hii Question header align.
1441         //
1442         Ptr = (UINT8 *) HEADER_ALIGN (Ptr);
1443         CopyMem (Ptr, HiiVariableNode->HiiQuestionArray[Index], HiiVariableNode->HiiQuestionArray[Index]->Length);
1444         Ptr += HiiVariableNode->HiiQuestionArray[Index]->Length;
1445       }
1446     }
1447   }
1448
1449   *Size = BinSize;
1450   return Data;
1451 }
1452
1453 /**
1454   Generate VarCheckHiiBin from Hii Database and FV.
1455
1456 **/
1457 VOID
1458 EFIAPI
1459 VarCheckHiiGen (
1460   VOID
1461   )
1462 {
1463   VarCheckHiiGenFromHiiDatabase ();
1464   VarCheckHiiGenFromFv ();
1465
1466   mVarCheckHiiBin = BuildVarCheckHiiBin (&mVarCheckHiiBinSize);
1467   if (mVarCheckHiiBin == NULL) {
1468     DEBUG ((DEBUG_INFO, "[VarCheckHii] This driver could be removed from *.dsc and *.fdf\n"));
1469     return;
1470   }
1471
1472   DestroyHiiVariableNode ();
1473   if (mVarName != NULL) {
1474     InternalVarCheckFreePool (mVarName);
1475   }
1476
1477 #ifdef DUMP_VAR_CHECK_HII
1478   DEBUG_CODE (
1479     DumpVarCheckHii (mVarCheckHiiBin, mVarCheckHiiBinSize);
1480   );
1481 #endif
1482 }
1483