EdkCompatibilityPkg/Sample/Tools/Source/HiiPack/IfrParse.c

   1 /*++
   2
   3 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   IfrParse.c
  15
  16 Abstract:
  17
  18   Routines for parsing and managing HII IFR packs.
  19
  20 --*/
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include "Tiano.h"
  27 #include "EfiUtilityMsgs.h"
  28 #include "EfiInternalFormRepresentation.h"
  29 #include "Hii.h"
  30 #include "IfrParse.h"
  31 #include "HiiPack.h"
  32
  33 typedef struct _VARIABLE_STORE_ENTRY {
  34   struct _VARIABLE_STORE_ENTRY  *Next;
  35   CHAR8                         VarName[MAX_VARIABLE_NAME];
  36   char                          *VarBuffer;
  37   int                           VarBufferSize;
  38   EFI_HII_VARIABLE_PACK         *VarPack;
  39   int                           VarPackSize;
  40 } VARIABLE_STORE_ENTRY;
  41
  42 typedef STATUS (*IFR_PARSE_FUNCTION) (IFR_PARSE_CONTEXT * Context);
  43
  44 typedef struct {
  45   INT8                *Name;
  46   INT32               Size;
  47   IFR_PARSE_FUNCTION  Parse;
  48 } IFR_PARSE_TABLE_ENTRY;
  49
  50 static
  51 STATUS
  52 IfrParse01 (
  53   IFR_PARSE_CONTEXT *Context
  54   );
  55 static
  56 STATUS
  57 IfrParse02 (
  58   IFR_PARSE_CONTEXT *Context
  59   );
  60 static
  61 STATUS
  62 IfrParse03 (
  63   IFR_PARSE_CONTEXT *Context
  64   );
  65 static
  66 STATUS
  67 IfrParse05 (
  68   IFR_PARSE_CONTEXT *Context
  69   );
  70 static
  71 STATUS
  72 IfrParse06 (
  73   IFR_PARSE_CONTEXT *Context
  74   );
  75 static
  76 STATUS
  77 IfrParse07 (
  78   IFR_PARSE_CONTEXT *Context
  79   );
  80 static
  81 STATUS
  82 IfrParse08 (
  83   IFR_PARSE_CONTEXT *Context
  84   );
  85 static
  86 STATUS
  87 IfrParse09 (
  88   IFR_PARSE_CONTEXT *Context
  89   );
  90 static
  91 STATUS
  92 IfrParse0A (
  93   IFR_PARSE_CONTEXT *Context
  94   );
  95 static
  96 STATUS
  97 IfrParse0B (
  98   IFR_PARSE_CONTEXT *Context
  99   );
 100 static
 101 STATUS
 102 IfrParse0C (
 103   IFR_PARSE_CONTEXT *Context
 104   );
 105 static
 106 STATUS
 107 IfrParse0D (
 108   IFR_PARSE_CONTEXT *Context
 109   );
 110 static
 111 STATUS
 112 IfrParse0E (
 113   IFR_PARSE_CONTEXT *Context
 114   );
 115 static
 116 STATUS
 117 IfrParse0F (
 118   IFR_PARSE_CONTEXT *Context
 119   );
 120 static
 121 STATUS
 122 IfrParse10 (
 123   IFR_PARSE_CONTEXT *Context
 124   );
 125 static
 126 STATUS
 127 IfrParse11 (
 128   IFR_PARSE_CONTEXT *Context
 129   );
 130 static
 131 STATUS
 132 IfrParse12 (
 133   IFR_PARSE_CONTEXT *Context
 134   );
 135 static
 136 STATUS
 137 IfrParse13 (
 138   IFR_PARSE_CONTEXT *Context
 139   );
 140 static
 141 STATUS
 142 IfrParse14 (
 143   IFR_PARSE_CONTEXT *Context
 144   );
 145 static
 146 STATUS
 147 IfrParse15 (
 148   IFR_PARSE_CONTEXT *Context
 149   );
 150 static
 151 STATUS
 152 IfrParse16 (
 153   IFR_PARSE_CONTEXT *Context
 154   );
 155 static
 156 STATUS
 157 IfrParse17 (
 158   IFR_PARSE_CONTEXT *Context
 159   );
 160 static
 161 STATUS
 162 IfrParse18 (
 163   IFR_PARSE_CONTEXT *Context
 164   );
 165 static
 166 STATUS
 167 IfrParse19 (
 168   IFR_PARSE_CONTEXT *Context
 169   );
 170 static
 171 STATUS
 172 IfrParse1A (
 173   IFR_PARSE_CONTEXT *Context
 174   );
 175 static
 176 STATUS
 177 IfrParse1B (
 178   IFR_PARSE_CONTEXT *Context
 179   );
 180 static
 181 STATUS
 182 IfrParse1C (
 183   IFR_PARSE_CONTEXT *Context
 184   );
 185 static
 186 STATUS
 187 IfrParse1D (
 188   IFR_PARSE_CONTEXT *Context
 189   );
 190 static
 191 STATUS
 192 IfrParse1E (
 193   IFR_PARSE_CONTEXT *Context
 194   );
 195 static
 196 STATUS
 197 IfrParse1F (
 198   IFR_PARSE_CONTEXT *Context
 199   );
 200 static
 201 STATUS
 202 IfrParse20 (
 203   IFR_PARSE_CONTEXT *Context
 204   );
 205 static
 206 STATUS
 207 IfrParse21 (
 208   IFR_PARSE_CONTEXT *Context
 209   );
 210 static
 211 STATUS
 212 IfrParse22 (
 213   IFR_PARSE_CONTEXT *Context
 214   );
 215 static
 216 STATUS
 217 IfrParse23 (
 218   IFR_PARSE_CONTEXT *Context
 219   );
 220 static
 221 STATUS
 222 IfrParse24 (
 223   IFR_PARSE_CONTEXT *Context
 224   );
 225 static
 226 STATUS
 227 IfrParse25 (
 228   IFR_PARSE_CONTEXT *Context
 229   );
 230 static
 231 STATUS
 232 IfrParse26 (
 233   IFR_PARSE_CONTEXT *Context
 234   );
 235 static
 236 STATUS
 237 IfrParse27 (
 238   IFR_PARSE_CONTEXT *Context
 239   );
 240 static
 241 STATUS
 242 IfrParse28 (
 243   IFR_PARSE_CONTEXT *Context
 244   );
 245 static
 246 STATUS
 247 IfrParse29 (
 248   IFR_PARSE_CONTEXT *Context
 249   );
 250 static
 251 STATUS
 252 IfrParse2A (
 253   IFR_PARSE_CONTEXT *Context
 254   );
 255
 256 static const IFR_PARSE_TABLE_ENTRY  mIfrParseTable[] = {
 257   {
 258     0,
 259     0,
 260     NULL
 261   },  // invalid
 262   {
 263     "EFI_IFR_FORM",
 264     sizeof (EFI_IFR_FORM),
 265     IfrParse01
 266   },
 267   {
 268     "EFI_IFR_SUBTITLE",
 269     sizeof (EFI_IFR_SUBTITLE),
 270     IfrParse02
 271   },
 272   {
 273     "EFI_IFR_TEXT",
 274     -6,
 275     IfrParse03
 276   },  // sizeof (EFI_IFR_TEXT) },
 277   {
 278     "unused 0x04 opcode",
 279     0,
 280     NULL
 281   },  // EFI_IFR_GRAPHIC_OP
 282   {
 283     "EFI_IFR_ONE_OF",
 284     sizeof (EFI_IFR_ONE_OF),
 285     IfrParse05
 286   },
 287   {
 288     "EFI_IFR_CHECK_BOX",
 289     sizeof (EFI_IFR_CHECK_BOX),
 290     IfrParse06
 291   },
 292   {
 293     "EFI_IFR_NUMERIC",
 294     sizeof (EFI_IFR_NUMERIC),
 295     IfrParse07
 296   },
 297   {
 298     "EFI_IFR_PASSWORD",
 299     sizeof (EFI_IFR_PASSWORD),
 300     IfrParse08
 301   },
 302   {
 303     "EFI_IFR_ONE_OF_OPTION",
 304     sizeof (EFI_IFR_ONE_OF_OPTION),
 305     IfrParse09
 306   },
 307   {
 308     "EFI_IFR_SUPPRESS",
 309     sizeof (EFI_IFR_SUPPRESS),
 310     IfrParse0A
 311   },
 312   {
 313     "EFI_IFR_END_FORM",
 314     sizeof (EFI_IFR_END_FORM),
 315     IfrParse0B
 316   },
 317   {
 318     "EFI_IFR_HIDDEN",
 319     sizeof (EFI_IFR_HIDDEN),
 320     IfrParse0C
 321   },
 322   {
 323     "EFI_IFR_END_FORM_SET",
 324     sizeof (EFI_IFR_END_FORM_SET),
 325     IfrParse0D
 326   },
 327   {
 328     "EFI_IFR_FORM_SET",
 329     sizeof (EFI_IFR_FORM_SET),
 330     IfrParse0E
 331   },
 332   {
 333     "EFI_IFR_REF",
 334     sizeof (EFI_IFR_REF),
 335     IfrParse0F
 336   },
 337   {
 338     "EFI_IFR_END_ONE_OF",
 339     sizeof (EFI_IFR_END_ONE_OF),
 340     IfrParse10
 341   },
 342   {
 343     "EFI_IFR_INCONSISTENT",
 344     sizeof (EFI_IFR_INCONSISTENT),
 345     IfrParse11
 346   },
 347   {
 348     "EFI_IFR_EQ_ID_VAL",
 349     sizeof (EFI_IFR_EQ_ID_VAL),
 350     IfrParse12
 351   },
 352   {
 353     "EFI_IFR_EQ_ID_ID",
 354     sizeof (EFI_IFR_EQ_ID_ID),
 355     IfrParse13
 356   },
 357   {
 358     "EFI_IFR_EQ_ID_LIST",
 359     -(int) (sizeof (EFI_IFR_EQ_ID_LIST)),
 360     IfrParse14
 361   },
 362   {
 363     "EFI_IFR_AND",
 364     sizeof (EFI_IFR_AND),
 365     IfrParse15
 366   },
 367   {
 368     "EFI_IFR_OR",
 369     sizeof (EFI_IFR_OR),
 370     IfrParse16
 371   },
 372   {
 373     "EFI_IFR_NOT",
 374     sizeof (EFI_IFR_NOT),
 375     IfrParse17
 376   },
 377   {
 378     "EFI_IFR_END_IF",
 379     sizeof (EFI_IFR_END_IF),
 380     IfrParse18
 381   },
 382   {
 383     "EFI_IFR_GRAYOUT",
 384     sizeof (EFI_IFR_GRAYOUT),
 385     IfrParse19
 386   },
 387   {
 388     "EFI_IFR_DATE",
 389     sizeof (EFI_IFR_DATE) / 3,
 390     IfrParse1A
 391   },
 392   {
 393     "EFI_IFR_TIME",
 394     sizeof (EFI_IFR_TIME) / 3,
 395     IfrParse1B
 396   },
 397   {
 398     "EFI_IFR_STRING",
 399     sizeof (EFI_IFR_STRING),
 400     IfrParse1C
 401   },
 402   {
 403     "EFI_IFR_LABEL",
 404     sizeof (EFI_IFR_LABEL),
 405     IfrParse1D
 406   },
 407   {
 408     "EFI_IFR_SAVE_DEFAULTS",
 409     sizeof (EFI_IFR_SAVE_DEFAULTS),
 410     IfrParse1E
 411   },
 412   {
 413     "EFI_IFR_RESTORE_DEFAULTS",
 414     sizeof (EFI_IFR_RESTORE_DEFAULTS),
 415     IfrParse1F
 416   },
 417   {
 418     "EFI_IFR_BANNER",
 419     sizeof (EFI_IFR_BANNER),
 420     IfrParse20
 421   },
 422   {
 423     "EFI_IFR_INVENTORY",
 424     sizeof (EFI_IFR_INVENTORY),
 425     IfrParse21
 426   },
 427   {
 428     "EFI_IFR_EQ_VAR_VAL_OP",
 429     sizeof (EFI_IFR_EQ_VAR_VAL),
 430     IfrParse22
 431   },
 432   {
 433     "EFI_IFR_ORDERED_LIST_OP",
 434     sizeof (EFI_IFR_ORDERED_LIST),
 435     IfrParse23
 436   },
 437   {
 438     "EFI_IFR_VARSTORE_OP",
 439     -(int) (sizeof (EFI_IFR_VARSTORE)),
 440     IfrParse24
 441   },
 442   {
 443     "EFI_IFR_VARSTORE_SELECT_OP",
 444     sizeof (EFI_IFR_VARSTORE_SELECT),
 445     IfrParse25
 446   },
 447   {
 448     "EFI_IFR_VARSTORE_SELECT_PAIR_OP",
 449     sizeof (EFI_IFR_VARSTORE_SELECT_PAIR),
 450     IfrParse26
 451   },
 452   {
 453     "EFI_IFR_TRUE",
 454     sizeof (EFI_IFR_TRUE),
 455     IfrParse27
 456   },
 457   {
 458     "EFI_IFR_FALSE",
 459     sizeof (EFI_IFR_FALSE),
 460     IfrParse28
 461   },
 462   {
 463     "EFI_IFR_GT",
 464     sizeof (EFI_IFR_GT),
 465     IfrParse29
 466   },
 467   {
 468     "EFI_IFR_GE",
 469     sizeof (EFI_IFR_GE),
 470     IfrParse2A
 471   },
 472 };
 473 #define PARSE_TABLE_ENTRIES (sizeof (mIfrParseTable) / sizeof (mIfrParseTable[0]))
 474
 475 static
 476 STATUS
 477 GetVarStoreInfo (
 478   IFR_PARSE_CONTEXT   *Context,
 479   UINT16              VarId,
 480   EFI_GUID            **VarStoreGuid,
 481   char                **VarStoreName
 482   );
 483
 484 static
 485 void
 486 FreeVarStores (
 487   VOID
 488   );
 489
 490 static
 491 STATUS
 492 CreateVarStore (
 493   EFI_GUID *VarGuid,
 494   CHAR8    *VarName,
 495   int      VarStoreSize
 496   );
 497
 498 static
 499 STATUS
 500 SetDefaults (
 501   IFR_PARSE_CONTEXT *Context,
 502   UINT32            MfgDefaults
 503   );
 504
 505 //
 506 // Globals
 507 //
 508 static IFR_PARSE_CONTEXT            *mParseContext    = NULL;
 509 static VARIABLE_STORE_ENTRY         *mVariableStores  = NULL;
 510 static int                          BreakOnOpcodeTag  = 0;
 511 static int                          OpcodeTag         = 1;
 512
 513 /*****************************************************************************/
 514 STATUS
 515 IfrParseCheck (
 516   char    *Buffer,
 517   long    BufferSize
 518   )
 519 /*++
 520
 521 Routine Description:
 522
 523   Check a buffer to ensure that is is parseable IFR
 524
 525 Arguments:
 526
 527   Buffer      - pointer to raw IFR bytes
 528   BufferSize  - size of IFR pointed to by Buffer
 529
 530 Returns:
 531
 532   STATUS_SUCCESS      if successful
 533   STATUS_ERROR        otherwise
 534
 535 --*/
 536 {
 537   char              *Start;
 538
 539   char              *End;
 540
 541   char              *Pos;
 542   EFI_IFR_OP_HEADER *OpHeader;
 543   char              *FileName;
 544   FileName = "";
 545   //
 546   // Walk the list of IFR statements in the IFR pack
 547   //
 548   Start = Buffer;
 549   Pos   = Buffer;
 550   End   = Start + BufferSize;
 551   while ((Pos >= Start) && (Pos < End)) {
 552     OpHeader = (EFI_IFR_OP_HEADER *) Pos;
 553     //
 554     // Check range on size
 555     //
 556     if (Pos + OpHeader->Length > End) {
 557       Error (NULL, 0, 0, FileName, "invalid IFR opcode size at offset 0x%X", (int) Pos - (int) Start);
 558       return STATUS_ERROR;
 559     }
 560
 561     if (OpHeader->Length == 0) {
 562       Error (NULL, 0, 0, FileName, "IFR opcode size=0 at offset 0x%X", (int) Pos - (int) Start);
 563       return STATUS_ERROR;
 564     }
 565     //
 566     // See if it's the END_FORMSET opcode
 567     //
 568     if (OpHeader->OpCode == EFI_IFR_END_FORM_SET_OP) {
 569       break;
 570     }
 571     //
 572     // Advance to next IFR statement/opcode
 573     //
 574     Pos += OpHeader->Length;
 575   }
 576
 577   return STATUS_SUCCESS;
 578 }
 579
 580 STATUS
 581 IfrParseInit (
 582   VOID
 583   )
 584 /*++
 585
 586 Routine Description:
 587
 588   Initialize this module for IFR pack parsing
 589
 590 Arguments:
 591
 592 Returns:
 593
 594   STATUS_SUCCESS      always
 595
 596 --*/
 597 {
 598   return STATUS_SUCCESS;
 599 }
 600
 601 STATUS
 602 IfrParseEnd (
 603   VOID
 604   )
 605 /*++
 606
 607 Routine Description:
 608
 609   Free up memory allocated during IFR pack parsing done by this module
 610
 611 Arguments:
 612   None
 613
 614 Returns:
 615
 616   STATUS_SUCCESS      always
 617
 618 --*/
 619 {
 620   IFR_PARSE_CONTEXT *NextContext;
 621   IFR_PARSE_ENTRY   *NextEntry;
 622   //
 623   // Free up the memory from our parse contexts
 624   //
 625   while (mParseContext != NULL) {
 626     while (mParseContext->Ifr != NULL) {
 627       NextEntry = mParseContext->Ifr->Next;
 628       //
 629       // We pointed directly into the user buffer, rather than make
 630       // a copy, so don't free up the bytes.
 631       //
 632       free (mParseContext->Ifr);
 633       mParseContext->Ifr = NextEntry;
 634     }
 635
 636     NextContext = mParseContext->Next;
 637     free (mParseContext->PackHeader);
 638     free (mParseContext);
 639     mParseContext = NextContext;
 640   }
 641
 642   return STATUS_SUCCESS;
 643 }
 644
 645 static
 646 void
 647 FreeVarStores (
 648   VOID
 649   )
 650 /*++
 651
 652 Routine Description:
 653
 654   GC_TODO: Add function description
 655
 656 Arguments:
 657
 658   None
 659
 660 Returns:
 661
 662   GC_TODO: add return values
 663
 664 --*/
 665 {
 666   VARIABLE_STORE_ENTRY  *NextVarStore;
 667   //
 668   // Free up memory from our variable stores
 669   //
 670   while (mVariableStores != NULL) {
 671     if (mVariableStores->VarPack != NULL) {
 672       free (mVariableStores->VarPack);
 673     }
 674
 675     NextVarStore = mVariableStores->Next;
 676     free (mVariableStores);
 677     mVariableStores = NextVarStore;
 678   }
 679 }
 680
 681 /******************************************************************************
 682   FUNCTION: IfrParsePack()
 683
 684   DESCRIPTION:  Given a pointer to an IFR pack, parse it to create a linked
 685     list of opcodes and relevant data required for later dumping.
 686
 687
 688 *******************************************************************************/
 689 STATUS
 690 IfrParsePack (
 691   int               Handle,
 692   EFI_HII_IFR_PACK  *PackHeader,
 693   EFI_GUID          *PackageGuid
 694   )
 695 /*++
 696
 697 Routine Description:
 698
 699   Given a pointer to an IFR pack, parse it to create a linked
 700   list of opcodes and relevant data required for later dumping.
 701
 702 Arguments:
 703
 704   Handle          - the handle number associated with this IFR pack. It
 705                     can be used later to retrieve more info on the particular
 706                     pack
 707   PackHeader      - pointer to IFR pack to parse
 708   PackageGuid     - on input, it comes from the HII data table entry for this pack.
 709                     On output, we'll return the IFR formset GUID.
 710
 711 Returns:
 712
 713   STATUS_SUCCESS      always
 714
 715 --*/
 716 {
 717   EFI_IFR_OP_HEADER *OpHeader;
 718   IFR_PARSE_CONTEXT *Context;
 719   IFR_PARSE_CONTEXT *TempContext;
 720   IFR_PARSE_ENTRY   *IfrEntry;
 721   //
 722   // Initialize our context
 723   //
 724   Context = (IFR_PARSE_CONTEXT *) malloc (sizeof (IFR_PARSE_CONTEXT));
 725   if (Context == NULL) {
 726     Error (NULL, 0, 0, "memory allocation failure", NULL);
 727     return STATUS_ERROR;
 728   }
 729
 730   memset ((void *) Context, 0, sizeof (IFR_PARSE_CONTEXT));
 731   //
 732   // Cache a copy of the input pack so the caller can free their copy
 733   //
 734   Context->PackHeader = (EFI_HII_IFR_PACK *) malloc (PackHeader->Header.Length);
 735   if (Context->PackHeader == NULL) {
 736     Error (NULL, 0, 0, "memory allocation failure", NULL);
 737     free (Context);
 738     return STATUS_ERROR;
 739   }
 740
 741   memcpy (Context->PackHeader, PackHeader, PackHeader->Header.Length);
 742   Context->IfrBufferStart = (char *) (Context->PackHeader + 1);
 743   Context->CurrentPos     = Context->IfrBufferStart;
 744   Context->IfrBufferLen   = PackHeader->Header.Length - sizeof (EFI_HII_IFR_PACK);
 745   Context->Handle         = Handle;
 746   Context->FormsetGuid    = &Context->NullGuid;
 747   Context->PackageGuid    = *PackageGuid;
 748   //
 749   // Add it to the end of our list
 750   //
 751   if (mParseContext == NULL) {
 752     mParseContext = Context;
 753   } else {
 754     TempContext = mParseContext;
 755     while (TempContext->Next != NULL) {
 756       TempContext = TempContext->Next;
 757     }
 758
 759     TempContext->Next = Context;
 760   }
 761   //
 762   // Walk the opcodes in the pack
 763   //
 764   while
 765   (
 766     (Context->CurrentPos >= Context->IfrBufferStart) &&
 767     (Context->CurrentPos < Context->IfrBufferStart + Context->IfrBufferLen)
 768   ) {
 769     OpHeader = (EFI_IFR_OP_HEADER *) Context->CurrentPos;
 770     //
 771     // Allocate a new IFR entry to put in our linked list, then
 772     // point directly to the caller's raw data.
 773     //
 774     IfrEntry = (IFR_PARSE_ENTRY *) malloc (sizeof (IFR_PARSE_ENTRY));
 775     if (IfrEntry == NULL) {
 776       Error (NULL, 0, 0, "memory allocation failure", NULL);
 777       free (Context->PackHeader);
 778       free (Context);
 779       return STATUS_ERROR;
 780     }
 781
 782     memset ((void *) IfrEntry, 0, sizeof (IFR_PARSE_ENTRY));
 783     IfrEntry->Tag = ++OpcodeTag;
 784     if (OpcodeTag == BreakOnOpcodeTag) {
 785       EFI_BREAKPOINT ();
 786     }
 787
 788     IfrEntry->RawIfrHeader = (EFI_IFR_OP_HEADER *) (Context->CurrentPos);
 789     //
 790     // Add this entry to our linked list. If it's not the first, then
 791     // forward the variable store settings from the previous entry.
 792     //
 793     if (Context->LastIfr != NULL) {
 794       IfrEntry->VarStoreGuid1 = Context->LastIfr->VarStoreGuid1;
 795       IfrEntry->VarStoreName1 = Context->LastIfr->VarStoreName1;
 796       IfrEntry->VarStoreGuid2 = Context->LastIfr->VarStoreGuid2;
 797       IfrEntry->VarStoreName2 = Context->LastIfr->VarStoreName2;
 798       Context->LastIfr->Next  = IfrEntry;
 799     } else {
 800       Context->Ifr = IfrEntry;
 801     }
 802
 803     Context->LastIfr = IfrEntry;
 804     //
 805     // Switch on the opcode to parse it
 806     //
 807     if (OpHeader->OpCode < PARSE_TABLE_ENTRIES) {
 808       if (mIfrParseTable[OpHeader->OpCode].Parse != NULL) {
 809         mIfrParseTable[OpHeader->OpCode].Parse (Context);
 810       }
 811     } else {
 812       Error (
 813         NULL,
 814         0,
 815         0,
 816         "invalid opcode found in IFR",
 817         "offset=0x%X opcode=0x%02X",
 818         (int) OpHeader - (int) Context->PackHeader,
 819         (int) OpHeader->OpCode
 820         );
 821       free (IfrEntry);
 822       free (Context->PackHeader);
 823       free (Context);
 824       return STATUS_ERROR;
 825     }
 826     //
 827     // If it's the END_FORMSET opcode, then we're done
 828     //
 829     if (OpHeader->OpCode == EFI_IFR_END_FORM_SET_OP) {
 830       break;
 831     }
 832     //
 833     // Advance to next IFR statement/opcode
 834     //
 835     if (OpHeader->Length == 0) {
 836       Error (NULL, 0, 0, "0-length IFR opcode encountered", NULL);
 837       free (IfrEntry);
 838       free (Context->PackHeader);
 839       free (Context);
 840       return STATUS_ERROR;
 841     }
 842
 843     Context->CurrentPos += OpHeader->Length;
 844   }
 845   //
 846   // Return the form GUID.
 847   //
 848   *PackageGuid = *Context->FormsetGuid;
 849   return STATUS_SUCCESS;
 850 }
 851
 852 /******************************************************************************
 853   FUNCTION:  GetVarStoreInfo()
 854
 855   DESCRIPTION:  IFR contains VARSTORE opcodes to specify where variable data
 856     for following opcodes is supposed to be stored. One VARSTORE statement
 857     allows you to specify the variable store GUID and a key, and another
 858     VARSTORE (select) allows you to specify the key of a VARSTORE statement.
 859     Given the key from a VARSTORE_SELECT statement, go find the corresponding
 860     VARSTORE statement with a matching key and return the varstore GUID and
 861     name. If key == 0, then the variable store is FormsetGuid."Setup"
 862 *******************************************************************************/
 863 static
 864 STATUS
 865 GetVarStoreInfo (
 866   IFR_PARSE_CONTEXT     *Context,
 867   UINT16                VarId,
 868   EFI_GUID              **VarStoreGuid,
 869   char                  **VarStoreName
 870   )
 871 /*++
 872
 873 Routine Description:
 874
 875   Get variable store information from an IFR pack for a given variable store ID.
 876
 877 Arguments:
 878
 879   Context       - pointer to IFR parse context
 880   VarId         - variable store ID referenced by IFR being parsed
 881   VarStoreGuid  - outgoing GUID of the variable store corresponding to VarId
 882   VarStoreName  - outgoing variable name of variable store corresponding to VarId
 883
 884 Returns:
 885
 886   STATUS_SUCCESS      - variable store with matching VarId found, and outoing GUID/Name are valid
 887   STATUS_ERROR        - otherwise
 888
 889 --*/
 890 {
 891   IFR_PARSE_ENTRY   *Ptr;
 892   EFI_IFR_VARSTORE  *VarStore;
 893   if (Context == NULL) {
 894     return STATUS_ERROR;
 895   }
 896
 897   //
 898   // Walk the entire IFR form and find a variable store opcode that
 899   // has a matching variable store ID.
 900   //
 901   for (Ptr = Context->Ifr; Ptr != NULL; Ptr = Ptr->Next) {
 902     if (Ptr->RawIfrHeader->OpCode == EFI_IFR_FORM_SET_OP) {
 903       if (VarId == 0) {
 904         *VarStoreGuid = &((EFI_IFR_FORM_SET *) (Ptr->RawIfrHeader))->Guid;
 905         *VarStoreName = DEFAULT_VARIABLE_NAME;
 906         return STATUS_SUCCESS;
 907       }
 908     } else if (Ptr->RawIfrHeader->OpCode == EFI_IFR_VARSTORE_OP) {
 909       //
 910       // See if it's a variable ID match
 911       //
 912       VarStore = (EFI_IFR_VARSTORE *) Ptr->RawIfrHeader;
 913       if (VarStore->VarId == VarId) {
 914         *VarStoreGuid = &VarStore->Guid;
 915         *VarStoreName = (char *) (VarStore + 1);
 916         return STATUS_SUCCESS;
 917       }
 918     }
 919   }
 920
 921   return STATUS_ERROR;
 922 }
 923
 924 STATUS
 925 IfrSetDefaults (
 926   int MfgDefaults
 927   )
 928 /*++
 929
 930 Routine Description:
 931
 932   Go through all the IFR forms we've parsed so far and create and set variable
 933   defaults.
 934
 935 Arguments:
 936
 937   MfgDefaults   - non-zero if manufacturing defaults are desired
 938
 939 Returns:
 940
 941   STATUS_SUCCESS      - always
 942
 943 --*/
 944 {
 945   IFR_PARSE_CONTEXT *Context;
 946   //
 947   // First free up any variable stores we've created so far.
 948   //
 949   FreeVarStores ();
 950   for (Context = mParseContext; Context != NULL; Context = Context->Next) {
 951     //
 952     // Call our internal function to handle it
 953     //
 954     SetDefaults (Context, MfgDefaults);
 955   }
 956
 957   return STATUS_SUCCESS;
 958
 959 }
 960
 961 /******************************************************************************/
 962 STATUS
 963 IfrGetIfrPack (
 964   int               Handle,
 965   EFI_HII_IFR_PACK  **PackHeader,
 966   EFI_GUID          *FormsetGuid
 967   )
 968 /*++
 969
 970 Routine Description:
 971
 972   GC_TODO: Add function description
 973
 974 Arguments:
 975
 976   Handle      - GC_TODO: add argument description
 977   PackHeader  - GC_TODO: add argument description
 978   FormsetGuid - GC_TODO: add argument description
 979
 980 Returns:
 981
 982   GC_TODO: add return values
 983
 984 --*/
 985 {
 986   IFR_PARSE_CONTEXT *Context;
 987
 988   for (Context = mParseContext; Context != NULL; Context = Context->Next) {
 989     if (Context->Handle == Handle) {
 990       *PackHeader = Context->PackHeader;
 991       memcpy (FormsetGuid, Context->FormsetGuid, sizeof (EFI_GUID));
 992       return STATUS_SUCCESS;
 993     }
 994   }
 995
 996   return STATUS_ERROR;
 997 }
 998
 999 STATUS
1000 IfrReferencesVarPack (
1001   int                   IfrHandle,
1002   EFI_HII_VARIABLE_PACK *VarPack
1003   )
1004 /*++
1005
1006 Routine Description:
1007
1008   Given an HII handle number (which corrresponds to a handle number passed
1009   in to IfrParsePack()), see if the IFR references the specified variable
1010   pack.
1011
1012 Arguments:
1013
1014   IfrHandle   - handle number for the IFR pack to check (passed to IfrParsePack())
1015   VarPack     - variable pack to check to see if the IFR references
1016
1017 Returns:
1018
1019   STATUS_SUCCESS      if the IFR on the given handle references the variable pack
1020   STATUS_WARNING      the IFR does not reference the variable pack
1021   STATUS_ERROR        invalid IFR handle
1022
1023 --*/
1024 {
1025   IFR_PARSE_CONTEXT *Context;
1026   char              VarName[MAX_VARIABLE_NAME];
1027   IFR_PARSE_ENTRY   *ParseEntry;
1028
1029   for (Context = mParseContext; Context != NULL; Context = Context->Next) {
1030     if (Context->Handle == IfrHandle) {
1031       //
1032       // Create an ASCII version of the variable name, since that's what is
1033       // referenced in IFR.
1034       //
1035       sprintf (VarName, "%S", (CHAR16 *) (VarPack + 1));
1036       //
1037       // Walk all the opcodes and see if the IFR references this variable pack
1038       //
1039       for (ParseEntry = Context->Ifr; ParseEntry != NULL; ParseEntry = ParseEntry->Next) {
1040         //
1041         // Check for Name.Guid match for primary IFR variable store
1042         //
1043         if ((strcmp (VarName, ParseEntry->VarStoreName1) == 0) &&
1044             (memcmp (&VarPack->VariableGuid, ParseEntry->VarStoreGuid1, sizeof (EFI_GUID)) == 0)
1045             ) {
1046           return STATUS_SUCCESS;
1047         }
1048         //
1049         // Check for Name.Guid match for secondary IFR variable store
1050         //
1051         if ((ParseEntry->VarStoreName2 != NULL) &&
1052             (strcmp (VarName, ParseEntry->VarStoreName2) == 0) &&
1053             (memcmp (&VarPack->VariableGuid, ParseEntry->VarStoreGuid2, sizeof (EFI_GUID)) == 0)
1054             ) {
1055           return STATUS_SUCCESS;
1056         }
1057       }
1058
1059       return STATUS_WARNING;
1060     }
1061   }
1062
1063   return STATUS_ERROR;
1064 }
1065
1066 STATUS
1067 IfrGetVarPack (
1068   int                     VarIndex,
1069   EFI_HII_VARIABLE_PACK   **VarPack
1070   )
1071 /*++
1072
1073 Routine Description:
1074
1075   Get the variable defaults. It is expected that the caller
1076   called IfrSetDefaults() previously to walk all the IFR forms we know about
1077   and create and initialize default values.
1078
1079 Arguments:
1080
1081   VarIndex - a 0-based index into all the variable stores we know about
1082   VarPack  - outgoing pointer to a variable pack
1083
1084 Returns:
1085
1086   STATUS_ERROR    - VarIndex exceeds the number of variable packs we know of
1087   STATUS_SUCCESS  - otherwise
1088
1089 --*/
1090 {
1091   VARIABLE_STORE_ENTRY  *Entry;
1092   //
1093   // Initialize outgoing parameters
1094   //
1095   *VarPack = NULL;
1096   for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {
1097     if (VarIndex == 0) {
1098       *VarPack = Entry->VarPack;
1099       return STATUS_SUCCESS;
1100     }
1101
1102     VarIndex--;
1103   }
1104
1105   return STATUS_ERROR;
1106 }
1107
1108 static
1109 STATUS
1110 SetVariableValue (
1111   EFI_GUID    *VarGuid,
1112   char        *VarName,
1113   int         VarOffset,
1114   int         VarSize,
1115   void        *VarValue
1116   )
1117 /*++
1118
1119 Routine Description:
1120
1121   Given a variable GUID.Name, offset, size, and value, set the bytes in
1122   the variable to the provided value.
1123
1124 Arguments:
1125   VarGuid           - GUID of variable to set
1126   VarName           - name of variable to set
1127   VarOffset         - byte offset into the variable store
1128   VarSize           - size of the value in the variable store (in bytes)
1129   VarValue          - pointer to buffer containing the value to set
1130
1131 Returns:
1132
1133
1134 --*/
1135 {
1136   VARIABLE_STORE_ENTRY  *Entry;
1137   char                  *Src;
1138   char                  *Dest;
1139   //
1140   // Go through our list of variable stores to find the match
1141   //
1142   for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {
1143     if (memcmp (VarGuid, &Entry->VarPack->VariableGuid, sizeof (EFI_GUID)) == 0) {
1144       if (strcmp (VarName, Entry->VarName) == 0) {
1145         //
1146         // Found match -- check offset. If it's beyond the size of the variable store
1147         // buffer, then return a warning. Note that date-time can be beyond the
1148         // end of the varstore, which is ok.
1149         //
1150         if (VarOffset + VarSize <= Entry->VarBufferSize) {
1151           //
1152           // Stuff the data
1153           //
1154           Dest  = Entry->VarBuffer + VarOffset;
1155           Src   = (char *) VarValue;
1156           while (VarSize > 0) {
1157             *Dest = *Src;
1158             Src++;
1159             Dest++;
1160             VarSize--;
1161           }
1162
1163           return STATUS_SUCCESS;
1164         }
1165
1166         return STATUS_WARNING;
1167       }
1168     }
1169   }
1170
1171   return STATUS_ERROR;
1172 }
1173
1174 static
1175 STATUS
1176 SetDefaults (
1177   IFR_PARSE_CONTEXT *Context,
1178   UINT32            MfgDefaults
1179   )
1180 /*++
1181
1182 Routine Description:
1183
1184   Set variable defaults by walking a single IFR form.
1185
1186 Arguments:
1187
1188   Context     - Pointer to the IFR context.
1189   MfgDefaults - Number of Mfg defaults
1190
1191 Returns:
1192
1193   EFI_INVALID_PARAMETER - arguments to function are invalid
1194   STATUS_SUCCESS        - function executed successfully
1195
1196 --*/
1197 {
1198   int                   Size;
1199   int                   CachedVarOffset;
1200   int                   CachedVarSize;
1201   int                   OrderedList;
1202   IFR_PARSE_ENTRY       *SavedParseEntry;
1203   EFI_IFR_CHECK_BOX     *IfrCheckBox;
1204   EFI_IFR_ONE_OF_OPTION *IfrOneOfOption;
1205   EFI_IFR_NUMERIC       *IfrNumeric;
1206   STATUS                Status;
1207   char                  ZeroByte;
1208
1209   //
1210   // Walk the opcodes to set default values and stuff them into the variable stores
1211   //
1212
1213   if (Context == NULL) {
1214     return EFI_INVALID_PARAMETER;
1215   }
1216   Status              = STATUS_SUCCESS;
1217   Context->CurrentIfr = Context->Ifr;
1218   SavedParseEntry     = NULL;
1219   OrderedList         = 0;
1220   CachedVarOffset     = 0;
1221   CachedVarSize       = 0;
1222   ZeroByte            = 0;
1223
1224   while (Context->CurrentIfr != NULL) {
1225     if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_FORM_SET_OP) {
1226       //
1227       // Formset opcode -- create a variable pack
1228       //
1229       Status = CreateVarStore (
1230                 &((EFI_IFR_FORM_SET *) (Context->CurrentIfr->RawIfrHeader))->Guid,
1231                 DEFAULT_VARIABLE_NAME,
1232                 ((EFI_IFR_FORM_SET *) (Context->CurrentIfr->RawIfrHeader))->NvDataSize
1233                 );
1234     } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_VARSTORE_OP) {
1235       //
1236       // Variable store opcode -- create a variable pack
1237       //
1238       Status = CreateVarStore (
1239                 &((EFI_IFR_VARSTORE *) (Context->CurrentIfr->RawIfrHeader))->Guid,
1240                 (char *) Context->CurrentIfr->RawIfrHeader + sizeof (EFI_IFR_VARSTORE),
1241                 ((EFI_IFR_VARSTORE *) (Context->CurrentIfr->RawIfrHeader))->Size
1242                 );
1243     } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ONE_OF_OP) {
1244       //
1245       // Need this parse context later when we find the default ONE_OF_OPTION.
1246       // Clear out the variable store first, so that we're covered if someone
1247       // has two one-of opcode that operate on the same data.
1248       // So "last one wins" is the behavior.
1249       //
1250       OrderedList     = 0;
1251       SavedParseEntry = Context->CurrentIfr;
1252       CachedVarOffset = ((EFI_IFR_ONE_OF *) Context->CurrentIfr->RawIfrHeader)->QuestionId;
1253       CachedVarSize   = ((EFI_IFR_ONE_OF *) Context->CurrentIfr->RawIfrHeader)->Width;
1254     } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ORDERED_LIST_OP) {
1255       //
1256       // Need this parse context later as we parse the ONE_OF_OP's in the ordered list
1257       //
1258       OrderedList     = 1;
1259       SavedParseEntry = Context->CurrentIfr;
1260       CachedVarOffset = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->QuestionId;
1261       CachedVarSize   = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->MaxEntries;
1262
1263       while (CachedVarSize > 0) {
1264         Status = SetVariableValue (
1265                   SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
1266                   SavedParseEntry->VarStoreName1, // name of variable store to write
1267                   CachedVarOffset,                // offset into variable store
1268                   1,                              // variable data size
1269                   (void *) &ZeroByte
1270                   );
1271         //
1272         // variable value
1273         //
1274         CachedVarSize--;
1275         CachedVarOffset++;
1276       }
1277
1278       CachedVarOffset = ((EFI_IFR_ORDERED_LIST *) Context->CurrentIfr->RawIfrHeader)->QuestionId;
1279       CachedVarSize   = 1;
1280       //
1281       // ((EFI_IFR_ORDERED_LIST *)Context->CurrentIfr->RawIfrHeader)->Width;
1282       //
1283     } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_ONE_OF_OPTION_OP) {
1284       IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *) Context->CurrentIfr->RawIfrHeader;
1285       //
1286       // If we're in an ordered list, then copy the value to the data store
1287       //
1288       if (OrderedList) {
1289         Status = SetVariableValue (
1290                   SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
1291                   SavedParseEntry->VarStoreName1, // name of variable store to write
1292                   CachedVarOffset,                // offset into variable store
1293                   1,                              // variable data size
1294                   (void *) &IfrOneOfOption->Value
1295                   );
1296         //
1297         // variable value
1298         //
1299         // Advance the offset for the next ordered list item
1300         //
1301         CachedVarOffset += CachedVarSize;
1302       } else {
1303         //
1304         // ONE-OF list. See if the default flag is set (provided we're not doing mfg defaults)
1305         //
1306         if (!MfgDefaults) {
1307           if (IfrOneOfOption->Flags & EFI_IFR_FLAG_DEFAULT) {
1308             Status = SetVariableValue (
1309                       SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
1310                       SavedParseEntry->VarStoreName1, // name of variable store to write
1311                       CachedVarOffset,                // offset into variable store
1312                       CachedVarSize,                  // variable data size
1313                       &IfrOneOfOption->Value
1314                       );
1315             //
1316             // variable value
1317             //
1318           }
1319         } else {
1320           if (IfrOneOfOption->Flags & EFI_IFR_FLAG_MANUFACTURING) {
1321             Status = SetVariableValue (
1322                       SavedParseEntry->VarStoreGuid1, // GUID of variable store to write
1323                       SavedParseEntry->VarStoreName1, // name of variable store to write
1324                       CachedVarOffset,                // offset into variable store
1325                       CachedVarSize,                  // variable data size
1326                       &IfrOneOfOption->Value
1327                       );
1328             //
1329             // variable value
1330             //
1331           }
1332         }
1333       }
1334     } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_CHECKBOX_OP) {
1335       //
1336       // If we're saving defaults, and the default flag is set, or we're saving
1337       // manufacturing defaults and the manufacturing flag is set, then save a 1.
1338       // By default the varstore buffer is cleared, so we don't need to save a 0 ever.
1339       //
1340       IfrCheckBox = (EFI_IFR_CHECK_BOX *) Context->CurrentIfr->RawIfrHeader;
1341       if (((MfgDefaults == 0) && (IfrCheckBox->Flags & EFI_IFR_FLAG_DEFAULT)) ||
1342           ((MfgDefaults != 0) && (IfrCheckBox->Flags & EFI_IFR_FLAG_MANUFACTURING))
1343           ) {
1344         Size = 1;
1345         Status = SetVariableValue (
1346                   Context->CurrentIfr->VarStoreGuid1, // GUID of variable store to write
1347                   Context->CurrentIfr->VarStoreName1, // name of variable store to write
1348                   IfrCheckBox->QuestionId,            // offset into variable store
1349                   IfrCheckBox->Width,                 // variable data size
1350                   (void *) &Size
1351                   );
1352         //
1353         // variable value
1354         //
1355       }
1356     } else if (Context->CurrentIfr->RawIfrHeader->OpCode == EFI_IFR_NUMERIC_OP) {
1357       IfrNumeric = (EFI_IFR_NUMERIC *) Context->CurrentIfr->RawIfrHeader;
1358       Status = SetVariableValue (
1359                 Context->CurrentIfr->VarStoreGuid1, // GUID of variable store to write
1360                 Context->CurrentIfr->VarStoreName1, // name of variable store to write
1361                 IfrNumeric->QuestionId,             // offset into variable store
1362                 IfrNumeric->Width,                  // variable data size
1363                 (void *) &IfrNumeric->Default
1364                 );
1365       //
1366       // variable value
1367       //
1368     }
1369
1370     Context->CurrentIfr = Context->CurrentIfr->Next;
1371   }
1372
1373   return STATUS_SUCCESS;
1374 }
1375
1376 static
1377 STATUS
1378 CreateVarStore (
1379   EFI_GUID  *VarGuid,
1380   CHAR8     *VarName,
1381   int       VarStoreSize
1382   )
1383 /*++
1384
1385 Routine Description:
1386
1387   Given a variable GUID.Name and the size of the variable store, allocate
1388   storage for maintaining the variable value.
1389
1390 Arguments:
1391
1392   VarGuid - GUID for a variable
1393   VarName - Name of the variable
1394   VarStoreSize - size of the variable store
1395
1396 Returns:
1397
1398   STATUS_ERROR   - problem with storage allocation
1399   STATUS_SUCCESS - function executed successfully
1400
1401 --*/
1402 {
1403   VARIABLE_STORE_ENTRY  *Entry;
1404
1405   VARIABLE_STORE_ENTRY  *TempEntry;
1406   int                   PackSize;
1407   int                   VarNameLen;
1408   //
1409   // If the variable store size is zero, then do nothing. This could be valid
1410   // if variable steering is used in the IFR such that FormsetGUID."Setup" variable
1411   // store is never used.
1412   //
1413   // OPEN: What about a form that only has a time/date question? Then if some other
1414   // function called SetDefaults(), attempting to set time/date would result in an
1415   // error in the SetVarValue() function.
1416   //
1417    if (VarStoreSize == 0) {
1418     return STATUS_SUCCESS;
1419    }
1420   //
1421   // Go through our list of variable stores and see if we've already created one
1422   // for this Guid.Name. If so, check the size and return. Otherwise create
1423   // one and add it to the list.
1424   //
1425   for (Entry = mVariableStores; Entry != NULL; Entry = Entry->Next) {
1426     if (memcmp (VarGuid, &Entry->VarPack->VariableGuid, sizeof (EFI_GUID)) == 0) {
1427       if (strcmp (VarName, Entry->VarName) == 0) {
1428         //
1429         // Already have one. Check size.
1430         //
1431         if (Entry->VarBufferSize != VarStoreSize) {
1432           Error (NULL, 0, 0, "mismatched variable store size between two formsets", VarName);
1433           return STATUS_ERROR;
1434         }
1435
1436         return STATUS_SUCCESS;
1437       }
1438     }
1439   }
1440   //
1441   // Create a new one.
1442   //
1443   Entry = (VARIABLE_STORE_ENTRY *) malloc (sizeof (VARIABLE_STORE_ENTRY));
1444   if (Entry == NULL) {
1445     Error (NULL, 0, 0, "memory allocation failure", NULL);
1446     return STATUS_ERROR;
1447   }
1448
1449   memset ((void *) Entry, 0, sizeof (VARIABLE_STORE_ENTRY));
1450   //
1451   // Compute size of the varpack
1452   //
1453   VarNameLen      = strlen (VarName) + 1;
1454   PackSize        = sizeof (EFI_HII_VARIABLE_PACK) + VarNameLen * sizeof (CHAR16) + VarStoreSize;
1455   Entry->VarPack  = (EFI_HII_VARIABLE_PACK *) malloc (PackSize);
1456   if (Entry->VarPack == NULL) {
1457     Error (NULL, 0, 0, "memory allocation failure", NULL);
1458     free (Entry);
1459     return STATUS_ERROR;
1460   }
1461
1462   Entry->VarPack->Header.Length       = PackSize;
1463   Entry->VarPack->Header.Type         = EFI_HII_VARIABLE;
1464   Entry->VarPack->VariableNameLength  = VarNameLen * sizeof (CHAR16);
1465   Entry->VarName[MAX_VARIABLE_NAME - 1] = 0;
1466   strncpy (Entry->VarName, VarName, MAX_VARIABLE_NAME - 1);
1467 #ifdef USE_VC8
1468   swprintf ((CHAR16 *) (Entry->VarPack + 1), (strlen (VarName) + 1) * sizeof (CHAR16), L"%S", VarName);
1469 #else
1470   swprintf ((CHAR16 *) (Entry->VarPack + 1), L"%S", VarName);
1471 #endif
1472   memcpy (&Entry->VarPack->VariableGuid, VarGuid, sizeof (EFI_GUID));
1473   //
1474   // Point VarBuffer into the allocated buffer (for convenience)
1475   //
1476   Entry->VarBuffer = (char *) Entry->VarPack + sizeof (EFI_HII_VARIABLE_PACK) + VarNameLen * sizeof (CHAR16);
1477   memset ((void *) Entry->VarBuffer, 0, VarStoreSize);
1478   Entry->VarBufferSize = VarStoreSize;
1479   //
1480   // Add this new varstore to our list
1481   //
1482   if (mVariableStores == NULL) {
1483     mVariableStores = Entry;
1484   } else {
1485     for (TempEntry = mVariableStores; TempEntry->Next != NULL; TempEntry = TempEntry->Next)
1486       ;
1487     TempEntry->Next = Entry;
1488   }
1489   return STATUS_SUCCESS;
1490 }
1491
1492 /******************************************************************************/
1493
1494 /*++
1495
1496 Routine Description:
1497
1498   The following IfrParseXX() functions are used to parse an IFR opcode numbered
1499   XX via a dispatch table.
1500
1501 Arguments:
1502
1503   Context - IFR parsing context into which pertinent data for the
1504             current opcode can be saved. Context->LastIfr->RawIfrHeader points to
1505             the raw IFR bytes currently being parsed.
1506
1507 Returns:
1508
1509   STATUS_SUCCESS  - always
1510
1511 --*/
1512
1513 /*******************************************************************************/
1514 static
1515 STATUS
1516 IfrParse01 (
1517   IFR_PARSE_CONTEXT *Context
1518   )
1519 /*++
1520
1521 Routine Description:
1522
1523   GC_TODO: Add function description
1524
1525 Arguments:
1526
1527   Context - GC_TODO: add argument description
1528
1529 Returns:
1530
1531   GC_TODO: add return values
1532
1533 --*/
1534 {
1535   return STATUS_SUCCESS;
1536 }
1537
1538 static
1539 STATUS
1540 IfrParse02 (
1541   IFR_PARSE_CONTEXT *Context
1542   )
1543 /*++
1544
1545 Routine Description:
1546
1547   GC_TODO: Add function description
1548
1549 Arguments:
1550
1551   Context - GC_TODO: add argument description
1552
1553 Returns:
1554
1555   GC_TODO: add return values
1556
1557 --*/
1558 {
1559   return STATUS_SUCCESS;
1560 }
1561
1562 static
1563 STATUS
1564 IfrParse03 (
1565   IFR_PARSE_CONTEXT *Context
1566   )
1567 /*++
1568
1569 Routine Description:
1570
1571   GC_TODO: Add function description
1572
1573 Arguments:
1574
1575   Context - GC_TODO: add argument description
1576
1577 Returns:
1578
1579   GC_TODO: add return values
1580
1581 --*/
1582 {
1583   return STATUS_SUCCESS;
1584 }
1585 //
1586 // Parse the IFR EFI_IFR_ONE_OF opcode.
1587 //
1588 static
1589 STATUS
1590 IfrParse05 (
1591   IFR_PARSE_CONTEXT *Context
1592   )
1593 /*++
1594
1595 Routine Description:
1596
1597   GC_TODO: Add function description
1598
1599 Arguments:
1600
1601   Context - GC_TODO: add argument description
1602
1603 Returns:
1604
1605   GC_TODO: add return values
1606
1607 --*/
1608 {
1609   return STATUS_SUCCESS;
1610 }
1611
1612 static
1613 STATUS
1614 IfrParse06 (
1615   IFR_PARSE_CONTEXT *Context
1616   )
1617 /*++
1618
1619 Routine Description:
1620
1621   GC_TODO: Add function description
1622
1623 Arguments:
1624
1625   Context - GC_TODO: add argument description
1626
1627 Returns:
1628
1629   GC_TODO: add return values
1630
1631 --*/
1632 {
1633   return STATUS_SUCCESS;
1634 }
1635
1636 static
1637 STATUS
1638 IfrParse07 (
1639   IFR_PARSE_CONTEXT *Context
1640   )
1641 /*++
1642
1643 Routine Description:
1644
1645   GC_TODO: Add function description
1646
1647 Arguments:
1648
1649   Context - GC_TODO: add argument description
1650
1651 Returns:
1652
1653   GC_TODO: add return values
1654
1655 --*/
1656 {
1657   return STATUS_SUCCESS;
1658 }
1659
1660 static
1661 STATUS
1662 IfrParse08 (
1663   IFR_PARSE_CONTEXT *Context
1664   )
1665 /*++
1666
1667 Routine Description:
1668
1669   GC_TODO: Add function description
1670
1671 Arguments:
1672
1673   Context - GC_TODO: add argument description
1674
1675 Returns:
1676
1677   GC_TODO: add return values
1678
1679 --*/
1680 {
1681   return STATUS_SUCCESS;
1682 }
1683
1684 static
1685 STATUS
1686 IfrParse09 (
1687   IFR_PARSE_CONTEXT *Context
1688   )
1689 /*++
1690
1691 Routine Description:
1692
1693   GC_TODO: Add function description
1694
1695 Arguments:
1696
1697   Context - GC_TODO: add argument description
1698
1699 Returns:
1700
1701   GC_TODO: add return values
1702
1703 --*/
1704 {
1705   return STATUS_SUCCESS;
1706 }
1707
1708 static
1709 STATUS
1710 IfrParse0A (
1711   IFR_PARSE_CONTEXT *Context
1712   )
1713 /*++
1714
1715 Routine Description:
1716
1717   GC_TODO: Add function description
1718
1719 Arguments:
1720
1721   Context - GC_TODO: add argument description
1722
1723 Returns:
1724
1725   GC_TODO: add return values
1726
1727 --*/
1728 {
1729   return STATUS_SUCCESS;
1730 }
1731
1732 static
1733 STATUS
1734 IfrParse0B (
1735   IFR_PARSE_CONTEXT *Context
1736   )
1737 /*++
1738
1739 Routine Description:
1740
1741   GC_TODO: Add function description
1742
1743 Arguments:
1744
1745   Context - GC_TODO: add argument description
1746
1747 Returns:
1748
1749   GC_TODO: add return values
1750
1751 --*/
1752 {
1753   return STATUS_SUCCESS;
1754 }
1755
1756 static
1757 STATUS
1758 IfrParse0C (
1759   IFR_PARSE_CONTEXT *Context
1760   )
1761 /*++
1762
1763 Routine Description:
1764
1765   GC_TODO: Add function description
1766
1767 Arguments:
1768
1769   Context - GC_TODO: add argument description
1770
1771 Returns:
1772
1773   GC_TODO: add return values
1774
1775 --*/
1776 {
1777   return STATUS_SUCCESS;
1778 }
1779
1780 static
1781 STATUS
1782 IfrParse0D (
1783   IFR_PARSE_CONTEXT *Context
1784   )
1785 /*++
1786
1787 Routine Description:
1788
1789   GC_TODO: Add function description
1790
1791 Arguments:
1792
1793   Context - GC_TODO: add argument description
1794
1795 Returns:
1796
1797   GC_TODO: add return values
1798
1799 --*/
1800 {
1801   return STATUS_SUCCESS;
1802 }
1803
1804 static
1805 STATUS
1806 IfrParse0E (
1807   IFR_PARSE_CONTEXT *Context
1808   )
1809 /*++
1810
1811 Routine Description:
1812
1813   GC_TODO: Add function description
1814
1815 Arguments:
1816
1817   Context - GC_TODO: add argument description
1818
1819 Returns:
1820
1821   GC_TODO: add return values
1822
1823 --*/
1824 {
1825   EFI_IFR_FORM_SET  *Op;
1826   Op  = (EFI_IFR_FORM_SET *) Context->LastIfr->RawIfrHeader;
1827   Context->LastIfr->VarStoreGuid1 = &Op->Guid;
1828   Context->LastIfr->VarStoreName1 = "Setup";
1829   Context->FormsetGuid            = &Op->Guid;
1830   return STATUS_SUCCESS;
1831 }
1832
1833 static
1834 STATUS
1835 IfrParse0F (
1836   IFR_PARSE_CONTEXT *Context
1837   )
1838 /*++
1839
1840 Routine Description:
1841
1842   GC_TODO: Add function description
1843
1844 Arguments:
1845
1846   Context - GC_TODO: add argument description
1847
1848 Returns:
1849
1850   GC_TODO: add return values
1851
1852 --*/
1853 {
1854   return STATUS_SUCCESS;
1855 }
1856
1857 static
1858 STATUS
1859 IfrParse10 (
1860   IFR_PARSE_CONTEXT *Context
1861   )
1862 /*++
1863
1864 Routine Description:
1865
1866   GC_TODO: Add function description
1867
1868 Arguments:
1869
1870   Context - GC_TODO: add argument description
1871
1872 Returns:
1873
1874   GC_TODO: add return values
1875
1876 --*/
1877 {
1878   return STATUS_SUCCESS;
1879 }
1880
1881 static
1882 STATUS
1883 IfrParse11 (
1884   IFR_PARSE_CONTEXT *Context
1885   )
1886 /*++
1887
1888 Routine Description:
1889
1890   GC_TODO: Add function description
1891
1892 Arguments:
1893
1894   Context - GC_TODO: add argument description
1895
1896 Returns:
1897
1898   GC_TODO: add return values
1899
1900 --*/
1901 {
1902   return STATUS_SUCCESS;
1903 }
1904
1905 static
1906 STATUS
1907 IfrParse12 (
1908   IFR_PARSE_CONTEXT *Context
1909   )
1910 /*++
1911
1912 Routine Description:
1913
1914   GC_TODO: Add function description
1915
1916 Arguments:
1917
1918   Context - GC_TODO: add argument description
1919
1920 Returns:
1921
1922   GC_TODO: add return values
1923
1924 --*/
1925 {
1926   return STATUS_SUCCESS;
1927 }
1928
1929 static
1930 STATUS
1931 IfrParse13 (
1932   IFR_PARSE_CONTEXT *Context
1933   )
1934 /*++
1935
1936 Routine Description:
1937
1938   GC_TODO: Add function description
1939
1940 Arguments:
1941
1942   Context - GC_TODO: add argument description
1943
1944 Returns:
1945
1946   GC_TODO: add return values
1947
1948 --*/
1949 {
1950   return STATUS_SUCCESS;
1951 }
1952
1953 static
1954 STATUS
1955 IfrParse14 (
1956   IFR_PARSE_CONTEXT *Context
1957   )
1958 /*++
1959
1960 Routine Description:
1961
1962   GC_TODO: Add function description
1963
1964 Arguments:
1965
1966   Context - GC_TODO: add argument description
1967
1968 Returns:
1969
1970   GC_TODO: add return values
1971
1972 --*/
1973 {
1974   return STATUS_SUCCESS;
1975 }
1976
1977 static
1978 STATUS
1979 IfrParse15 (
1980   IFR_PARSE_CONTEXT *Context
1981   )
1982 /*++
1983
1984 Routine Description:
1985
1986   GC_TODO: Add function description
1987
1988 Arguments:
1989
1990   Context - GC_TODO: add argument description
1991
1992 Returns:
1993
1994   GC_TODO: add return values
1995
1996 --*/
1997 {
1998   return STATUS_SUCCESS;
1999 }
2000
2001 static
2002 STATUS
2003 IfrParse16 (
2004   IFR_PARSE_CONTEXT *Context
2005   )
2006 /*++
2007
2008 Routine Description:
2009
2010   GC_TODO: Add function description
2011
2012 Arguments:
2013
2014   Context - GC_TODO: add argument description
2015
2016 Returns:
2017
2018   GC_TODO: add return values
2019
2020 --*/
2021 {
2022   return STATUS_SUCCESS;
2023 }
2024
2025 static
2026 STATUS
2027 IfrParse17 (
2028   IFR_PARSE_CONTEXT *Context
2029   )
2030 /*++
2031
2032 Routine Description:
2033
2034   GC_TODO: Add function description
2035
2036 Arguments:
2037
2038   Context - GC_TODO: add argument description
2039
2040 Returns:
2041
2042   GC_TODO: add return values
2043
2044 --*/
2045 {
2046   return STATUS_SUCCESS;
2047 }
2048
2049 static
2050 STATUS
2051 IfrParse18 (
2052   IFR_PARSE_CONTEXT *Context
2053   )
2054 /*++
2055
2056 Routine Description:
2057
2058   GC_TODO: Add function description
2059
2060 Arguments:
2061
2062   Context - GC_TODO: add argument description
2063
2064 Returns:
2065
2066   GC_TODO: add return values
2067
2068 --*/
2069 {
2070   return STATUS_SUCCESS;
2071 }
2072
2073 static
2074 STATUS
2075 IfrParse19 (
2076   IFR_PARSE_CONTEXT *Context
2077   )
2078 /*++
2079
2080 Routine Description:
2081
2082   GC_TODO: Add function description
2083
2084 Arguments:
2085
2086   Context - GC_TODO: add argument description
2087
2088 Returns:
2089
2090   GC_TODO: add return values
2091
2092 --*/
2093 {
2094   return STATUS_SUCCESS;
2095 }
2096
2097 static
2098 STATUS
2099 IfrParse1A (
2100   IFR_PARSE_CONTEXT *Context
2101   )
2102 /*++
2103
2104 Routine Description:
2105
2106   GC_TODO: Add function description
2107
2108 Arguments:
2109
2110   Context - GC_TODO: add argument description
2111
2112 Returns:
2113
2114   GC_TODO: add return values
2115
2116 --*/
2117 {
2118   return STATUS_SUCCESS;
2119 }
2120
2121 static
2122 STATUS
2123 IfrParse1B (
2124   IFR_PARSE_CONTEXT *Context
2125   )
2126 /*++
2127
2128 Routine Description:
2129
2130   GC_TODO: Add function description
2131
2132 Arguments:
2133
2134   Context - GC_TODO: add argument description
2135
2136 Returns:
2137
2138   GC_TODO: add return values
2139
2140 --*/
2141 {
2142   return STATUS_SUCCESS;
2143 }
2144
2145 static
2146 STATUS
2147 IfrParse1C (
2148   IFR_PARSE_CONTEXT *Context
2149   )
2150 /*++
2151
2152 Routine Description:
2153
2154   GC_TODO: Add function description
2155
2156 Arguments:
2157
2158   Context - GC_TODO: add argument description
2159
2160 Returns:
2161
2162   GC_TODO: add return values
2163
2164 --*/
2165 {
2166   return STATUS_SUCCESS;
2167 }
2168
2169 static
2170 STATUS
2171 IfrParse1D (
2172   IFR_PARSE_CONTEXT *Context
2173   )
2174 /*++
2175
2176 Routine Description:
2177
2178   GC_TODO: Add function description
2179
2180 Arguments:
2181
2182   Context - GC_TODO: add argument description
2183
2184 Returns:
2185
2186   GC_TODO: add return values
2187
2188 --*/
2189 {
2190   return STATUS_SUCCESS;
2191 }
2192
2193 static
2194 STATUS
2195 IfrParse1E (
2196   IFR_PARSE_CONTEXT *Context
2197   )
2198 /*++
2199
2200 Routine Description:
2201
2202   GC_TODO: Add function description
2203
2204 Arguments:
2205
2206   Context - GC_TODO: add argument description
2207
2208 Returns:
2209
2210   GC_TODO: add return values
2211
2212 --*/
2213 {
2214   return STATUS_SUCCESS;
2215 }
2216
2217 static
2218 STATUS
2219 IfrParse1F (
2220   IFR_PARSE_CONTEXT *Context
2221   )
2222 /*++
2223
2224 Routine Description:
2225
2226   GC_TODO: Add function description
2227
2228 Arguments:
2229
2230   Context - GC_TODO: add argument description
2231
2232 Returns:
2233
2234   GC_TODO: add return values
2235
2236 --*/
2237 {
2238   return STATUS_SUCCESS;
2239 }
2240
2241 static
2242 STATUS
2243 IfrParse20 (
2244   IFR_PARSE_CONTEXT *Context
2245   )
2246 /*++
2247
2248 Routine Description:
2249
2250   GC_TODO: Add function description
2251
2252 Arguments:
2253
2254   Context - GC_TODO: add argument description
2255
2256 Returns:
2257
2258   GC_TODO: add return values
2259
2260 --*/
2261 {
2262   return STATUS_SUCCESS;
2263 }
2264
2265 static
2266 STATUS
2267 IfrParse21 (
2268   IFR_PARSE_CONTEXT *Context
2269   )
2270 /*++
2271
2272 Routine Description:
2273
2274   GC_TODO: Add function description
2275
2276 Arguments:
2277
2278   Context - GC_TODO: add argument description
2279
2280 Returns:
2281
2282   GC_TODO: add return values
2283
2284 --*/
2285 {
2286   return STATUS_SUCCESS;
2287 }
2288
2289 static
2290 STATUS
2291 IfrParse22 (
2292   IFR_PARSE_CONTEXT *Context
2293   )
2294 /*++
2295
2296 Routine Description:
2297
2298   GC_TODO: Add function description
2299
2300 Arguments:
2301
2302   Context - GC_TODO: add argument description
2303
2304 Returns:
2305
2306   GC_TODO: add return values
2307
2308 --*/
2309 {
2310   return STATUS_SUCCESS;
2311 }
2312
2313 static
2314 STATUS
2315 IfrParse23 (
2316   IFR_PARSE_CONTEXT *Context
2317   )
2318 /*++
2319
2320 Routine Description:
2321
2322   GC_TODO: Add function description
2323
2324 Arguments:
2325
2326   Context - GC_TODO: add argument description
2327
2328 Returns:
2329
2330   GC_TODO: add return values
2331
2332 --*/
2333 {
2334   return STATUS_SUCCESS;
2335 }
2336 //
2337 // EFI_IFR_VARSTORE
2338 //
2339 static
2340 STATUS
2341 IfrParse24 (
2342   IFR_PARSE_CONTEXT *Context
2343   )
2344 /*++
2345
2346 Routine Description:
2347
2348   GC_TODO: Add function description
2349
2350 Arguments:
2351
2352   Context - GC_TODO: add argument description
2353
2354 Returns:
2355
2356   GC_TODO: add return values
2357
2358 --*/
2359 {
2360   EFI_IFR_VARSTORE  *Op;
2361   Op = (EFI_IFR_VARSTORE *) Context->LastIfr->RawIfrHeader;
2362   return STATUS_SUCCESS;
2363 }
2364 //
2365 // VARSTORE_SELECT
2366 //
2367 static
2368 STATUS
2369 IfrParse25 (
2370   IFR_PARSE_CONTEXT *Context
2371   )
2372 /*++
2373
2374 Routine Description:
2375
2376   GC_TODO: Add function description
2377
2378 Arguments:
2379
2380   Context - GC_TODO: add argument description
2381
2382 Returns:
2383
2384   GC_TODO: add return values
2385
2386 --*/
2387 {
2388   STATUS                  Status;
2389   EFI_IFR_VARSTORE_SELECT *Op;
2390   Op      = (EFI_IFR_VARSTORE_SELECT *) Context->LastIfr->RawIfrHeader;
2391   Status  = GetVarStoreInfo (Context, Op->VarId, &Context->LastIfr->VarStoreGuid1, &Context->LastIfr->VarStoreName1);
2392   //
2393   // VARSTORE_SELECT sets both
2394   //
2395   Context->LastIfr->VarStoreGuid2 = Context->LastIfr->VarStoreGuid1;
2396   Context->LastIfr->VarStoreName2 = Context->LastIfr->VarStoreName1;
2397   return Status;
2398 }
2399 //
2400 // VARSTORE_SELECT_PAIR
2401 //
2402 static
2403 STATUS
2404 IfrParse26 (
2405   IFR_PARSE_CONTEXT *Context
2406   )
2407 /*++
2408
2409 Routine Description:
2410
2411   GC_TODO: Add function description
2412
2413 Arguments:
2414
2415   Context - GC_TODO: add argument description
2416
2417 Returns:
2418
2419   GC_TODO: add return values
2420
2421 --*/
2422 {
2423   STATUS                        Status;
2424   EFI_IFR_VARSTORE_SELECT_PAIR  *Op;
2425
2426   Op      = (EFI_IFR_VARSTORE_SELECT_PAIR *) Context->LastIfr->RawIfrHeader;
2427   Status  = GetVarStoreInfo (Context, Op->VarId, &Context->LastIfr->VarStoreGuid1, &Context->LastIfr->VarStoreName1);
2428   Status = GetVarStoreInfo (
2429             Context,
2430             Op->SecondaryVarId,
2431             &Context->LastIfr->VarStoreGuid2,
2432             &Context->LastIfr->VarStoreName2
2433             );
2434   return Status;
2435 }
2436 //
2437 // TRUE
2438 //
2439 static
2440 STATUS
2441 IfrParse27 (
2442   IFR_PARSE_CONTEXT *Context
2443   )
2444 /*++
2445
2446 Routine Description:
2447
2448   GC_TODO: Add function description
2449
2450 Arguments:
2451
2452   Context - GC_TODO: add argument description
2453
2454 Returns:
2455
2456   GC_TODO: add return values
2457
2458 --*/
2459 {
2460   return STATUS_SUCCESS;
2461 }
2462 //
2463 // FALSe
2464 //
2465 static
2466 STATUS
2467 IfrParse28 (
2468   IFR_PARSE_CONTEXT *Context
2469   )
2470 /*++
2471
2472 Routine Description:
2473
2474   GC_TODO: Add function description
2475
2476 Arguments:
2477
2478   Context - GC_TODO: add argument description
2479
2480 Returns:
2481
2482   GC_TODO: add return values
2483
2484 --*/
2485 {
2486   return STATUS_SUCCESS;
2487 }
2488 static
2489 STATUS
2490 IfrParse29 (
2491   IFR_PARSE_CONTEXT *Context
2492   )
2493 /*++
2494
2495 Routine Description:
2496
2497   GC_TODO: Add function description
2498
2499 Arguments:
2500
2501   Context - GC_TODO: add argument description
2502
2503 Returns:
2504
2505   GC_TODO: add return values
2506
2507 --*/
2508 {
2509   return STATUS_SUCCESS;
2510 }
2511 static
2512 STATUS
2513 IfrParse2A (
2514   IFR_PARSE_CONTEXT *Context
2515   )
2516 /*++
2517
2518 Routine Description:
2519
2520   GC_TODO: Add function description
2521
2522 Arguments:
2523
2524   Context - GC_TODO: add argument description
2525
2526 Returns:
2527
2528   GC_TODO: add return values
2529
2530 --*/
2531 {
2532   return STATUS_SUCCESS;
2533 }