MdeModulePkg/Library/UefiIfrSupportLib/UefiIfrForm.c

   1 /** @file
   2 Utility functions which helps in opcode creation, HII configuration string manipulations,
   3 pop up window creations, setup browser persistence data set and get.
   4
   5 Copyright (c) 2007- 2008, Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "UefiIfrLibraryInternal.h"
  17
  18 CONST EFI_FORM_BROWSER2_PROTOCOL      *mFormBrowser2     = NULL;
  19 CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *mIfrSupportLibHiiConfigRouting = NULL;
  20 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mIfrSupportLibHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  21
  22 //
  23 // Fake <ConfigHdr>
  24 //
  25 GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT16 mFakeConfigHdr[] = L"GUID=00000000000000000000000000000000&NAME=0000&PATH=0";
  26
  27 /**
  28   This function locate FormBrowser2 protocols for later usage.
  29
  30   @return Status the status to locate protocol.
  31 **/
  32 EFI_STATUS
  33 LocateFormBrowser2Protocols (
  34   VOID
  35   )
  36 {
  37   EFI_STATUS Status;
  38   //
  39   // Locate protocols for later usage
  40   //
  41   if (mFormBrowser2 == NULL) {
  42     Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &mFormBrowser2);
  43     if (EFI_ERROR (Status)) {
  44       return Status;
  45     }
  46   }
  47
  48   if (mIfrSupportLibHiiConfigRouting == NULL) {
  49     Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &mIfrSupportLibHiiConfigRouting);
  50     if (EFI_ERROR (Status)) {
  51       return Status;
  52     }
  53   }
  54
  55   return EFI_SUCCESS;
  56 }
  57
  58 /**
  59   Draw a dialog and return the selected key.
  60
  61   @param  NumberOfLines          The number of lines for the dialog box
  62   @param  KeyValue               The EFI_KEY value returned if HotKey is TRUE..
  63   @param  String                 The first String to be displayed in the Pop-Up.
  64   @param  Marker                 A series of (quantity == NumberOfLines - 1) text
  65                                  strings which will be used to construct the dialog
  66                                  box
  67
  68   @retval EFI_SUCCESS            Displayed dialog and received user interaction
  69   @retval EFI_INVALID_PARAMETER  One of the parameters was invalid.
  70   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
  71
  72 **/
  73 EFI_STATUS
  74 EFIAPI
  75 IfrLibCreatePopUp2 (
  76   IN  UINTN                       NumberOfLines,
  77   OUT EFI_INPUT_KEY               *KeyValue,
  78   IN  CHAR16                      *String,
  79   IN  VA_LIST                     Marker
  80   )
  81 {
  82   UINTN                         Index;
  83   UINTN                         Count;
  84   UINTN                         Start;
  85   UINTN                         Top;
  86   CHAR16                        *StringPtr;
  87   UINTN                         LeftColumn;
  88   UINTN                         RightColumn;
  89   UINTN                         TopRow;
  90   UINTN                         BottomRow;
  91   UINTN                         DimensionsWidth;
  92   UINTN                         DimensionsHeight;
  93   EFI_INPUT_KEY                 Key;
  94   UINTN                         LargestString;
  95   CHAR16                        *StackString;
  96   EFI_STATUS                    Status;
  97   UINTN                         StringLen;
  98   CHAR16                        *LineBuffer;
  99   CHAR16                        **StringArray;
 100   EFI_EVENT                     TimerEvent;
 101   EFI_EVENT                     WaitList[2];
 102   UINTN                         CurrentAttribute;
 103   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 104
 105   if ((KeyValue == NULL) || (String == NULL)) {
 106     return EFI_INVALID_PARAMETER;
 107   }
 108
 109   TopRow      = 0;
 110   BottomRow   = 0;
 111   LeftColumn  = 0;
 112   RightColumn = 0;
 113
 114   ConOut = gST->ConOut;
 115   ConOut->QueryMode (ConOut, ConOut->Mode->Mode, &RightColumn, &BottomRow);
 116
 117   DimensionsWidth  = RightColumn - LeftColumn;
 118   DimensionsHeight = BottomRow - TopRow;
 119
 120   CurrentAttribute = ConOut->Mode->Attribute;
 121
 122   LineBuffer = AllocateZeroPool (DimensionsWidth * sizeof (CHAR16));
 123   if (LineBuffer == NULL) {
 124     return EFI_OUT_OF_RESOURCES;
 125   }
 126
 127   //
 128   // Determine the largest string in the dialog box
 129   // Notice we are starting with 1 since String is the first string
 130   //
 131   StringArray = AllocateZeroPool (NumberOfLines * sizeof (CHAR16 *));
 132   if (StringArray == NULL) {
 133     FreePool (LineBuffer);
 134     return EFI_OUT_OF_RESOURCES;
 135   }
 136   LargestString = StrLen (String);
 137   StringArray[0] = String;
 138
 139   for (Index = 1; Index < NumberOfLines; Index++) {
 140     StackString = VA_ARG (Marker, CHAR16 *);
 141
 142     if (StackString == NULL) {
 143       FreePool (LineBuffer);
 144       FreePool (StringArray);
 145       return EFI_INVALID_PARAMETER;
 146     }
 147
 148     StringArray[Index] = StackString;
 149     StringLen = StrLen (StackString);
 150     if (StringLen > LargestString) {
 151       LargestString = StringLen;
 152     }
 153   }
 154
 155   if ((LargestString + 2) > DimensionsWidth) {
 156     LargestString = DimensionsWidth - 2;
 157   }
 158
 159   //
 160   // Subtract the PopUp width from total Columns, allow for one space extra on
 161   // each end plus a border.
 162   //
 163   Start     = (DimensionsWidth - LargestString - 2) / 2 + LeftColumn + 1;
 164
 165   Top       = ((DimensionsHeight - NumberOfLines - 2) / 2) + TopRow - 1;
 166
 167   //
 168   // Disable cursor
 169   //
 170   ConOut->EnableCursor (ConOut, FALSE);
 171   ConOut->SetAttribute (ConOut, EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE);
 172
 173   StringPtr = &LineBuffer[0];
 174   *StringPtr++ = BOXDRAW_DOWN_RIGHT;
 175   for (Index = 0; Index < LargestString; Index++) {
 176     *StringPtr++ = BOXDRAW_HORIZONTAL;
 177   }
 178   *StringPtr++ = BOXDRAW_DOWN_LEFT;
 179   *StringPtr = L'\0';
 180
 181   ConOut->SetCursorPosition (ConOut, Start, Top);
 182   ConOut->OutputString (ConOut, LineBuffer);
 183
 184   for (Index = 0; Index < NumberOfLines; Index++) {
 185     StringPtr = &LineBuffer[0];
 186     *StringPtr++ = BOXDRAW_VERTICAL;
 187
 188     for (Count = 0; Count < LargestString; Count++) {
 189       StringPtr[Count] = L' ';
 190     }
 191
 192     StringLen = StrLen (StringArray[Index]);
 193     if (StringLen > LargestString) {
 194       StringLen = LargestString;
 195     }
 196     CopyMem (
 197       StringPtr + ((LargestString - StringLen) / 2),
 198       StringArray[Index],
 199       StringLen * sizeof (CHAR16)
 200       );
 201     StringPtr += LargestString;
 202
 203     *StringPtr++ = BOXDRAW_VERTICAL;
 204     *StringPtr = L'\0';
 205
 206     ConOut->SetCursorPosition (ConOut, Start, Top + 1 + Index);
 207     ConOut->OutputString (ConOut, LineBuffer);
 208   }
 209
 210   StringPtr = &LineBuffer[0];
 211   *StringPtr++ = BOXDRAW_UP_RIGHT;
 212   for (Index = 0; Index < LargestString; Index++) {
 213     *StringPtr++ = BOXDRAW_HORIZONTAL;
 214   }
 215   *StringPtr++ = BOXDRAW_UP_LEFT;
 216   *StringPtr = L'\0';
 217
 218   ConOut->SetCursorPosition (ConOut, Start, Top + NumberOfLines + 1);
 219   ConOut->OutputString (ConOut, LineBuffer);
 220
 221   do {
 222     Status = gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);
 223
 224     //
 225     // Set a timer event of 1 second expiration
 226     //
 227     gBS->SetTimer (
 228           TimerEvent,
 229           TimerRelative,
 230           10000000
 231           );
 232
 233     //
 234     // Wait for the keystroke event or the timer
 235     //
 236     WaitList[0] = gST->ConIn->WaitForKey;
 237     WaitList[1] = TimerEvent;
 238     Status      = gBS->WaitForEvent (2, WaitList, &Index);
 239
 240     //
 241     // Check for the timer expiration
 242     //
 243     if (!EFI_ERROR (Status) && Index == 1) {
 244       Status = EFI_TIMEOUT;
 245     }
 246
 247     gBS->CloseEvent (TimerEvent);
 248   } while (Status == EFI_TIMEOUT);
 249
 250   Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 251   CopyMem (KeyValue, &Key, sizeof (EFI_INPUT_KEY));
 252
 253   ConOut->SetAttribute (ConOut, CurrentAttribute);
 254   ConOut->EnableCursor (ConOut, TRUE);
 255
 256   FreePool (LineBuffer);
 257   FreePool (StringArray);
 258
 259   return Status;
 260 }
 261
 262
 263 /**
 264   Draw a dialog and return the selected key.
 265
 266   @param  NumberOfLines          The number of lines for the dialog box
 267   @param  KeyValue               The EFI_KEY value returned if HotKey is TRUE..
 268   @param  String                 Pointer to the first string in the list
 269   @param  ...                    A series of (quantity == NumberOfLines - 1) text
 270                                  strings which will be used to construct the dialog
 271                                  box
 272
 273   @retval EFI_SUCCESS            Displayed dialog and received user interaction
 274   @retval EFI_INVALID_PARAMETER  One of the parameters was invalid.
 275
 276 **/
 277 EFI_STATUS
 278 EFIAPI
 279 IfrLibCreatePopUp (
 280   IN  UINTN                       NumberOfLines,
 281   OUT EFI_INPUT_KEY               *KeyValue,
 282   IN  CHAR16                      *String,
 283   ...
 284   )
 285 {
 286   EFI_STATUS                      Status;
 287   VA_LIST                         Marker;
 288
 289   VA_START (Marker, String);
 290
 291   Status = IfrLibCreatePopUp2 (NumberOfLines, KeyValue, String, Marker);
 292
 293   VA_END (Marker);
 294
 295   return Status;
 296 }
 297
 298 /**
 299     Extract block name from the array generated by VFR compiler. The name of
 300   this array is "Vfr + <StorageName> + BlockName", e.g. "VfrMyIfrNVDataBlockName".
 301   Format of this array is:
 302      Array length | 4-bytes
 303        Offset     | 2-bytes
 304        Width      | 2-bytes
 305        Offset     | 2-bytes
 306        Width      | 2-bytes
 307        ... ...
 308
 309     @param Buffer                 Array generated by VFR compiler.
 310     @param BlockName              The returned <BlockName>
 311
 312     @retval EFI_OUT_OF_RESOURCES   Run out of memory resource.
 313     @retval EFI_INVALID_PARAMETER  Buffer is NULL or BlockName is NULL.
 314     @retval EFI_SUCCESS            Operation successful.
 315
 316 **/
 317 EFI_STATUS
 318 ExtractBlockName (
 319   IN UINT8                        *Buffer,
 320   OUT CHAR16                      **BlockName
 321   )
 322
 323 {
 324   UINTN       Index;
 325   UINT32      Length;
 326   UINT32      BlockNameNumber;
 327   UINTN       HexStringBufferLen;
 328   CHAR16      *StringPtr;
 329
 330   if ((Buffer == NULL) || (BlockName == NULL)) {
 331     return EFI_INVALID_PARAMETER;
 332   }
 333
 334   //
 335   // Calculate number of Offset/Width pair
 336   //
 337   CopyMem (&Length, Buffer, sizeof (UINT32));
 338   BlockNameNumber = (Length - sizeof (UINT32)) / (sizeof (UINT16) * 2);
 339
 340   //
 341   // <BlockName> ::= &OFFSET=1234&WIDTH=1234
 342   //                 |   8  | 4 |  7   | 4 |
 343   //
 344   StringPtr = AllocateZeroPool ((BlockNameNumber * (8 + 4 + 7 + 4) + 1) * sizeof (CHAR16));
 345   if (StringPtr == NULL) {
 346     return EFI_OUT_OF_RESOURCES;
 347   }
 348   *BlockName = StringPtr;
 349
 350   Buffer += sizeof (UINT32);
 351   for (Index = 0; Index < BlockNameNumber; Index++) {
 352     StrCpy (StringPtr, L"&OFFSET=");
 353     StringPtr += 8;
 354
 355     HexStringBufferLen = 5;
 356     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 357     Buffer += sizeof (UINT16);
 358     StringPtr += 4;
 359
 360     StrCpy (StringPtr, L"&WIDTH=");
 361     StringPtr += 7;
 362
 363     HexStringBufferLen = 5;
 364     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 365     Buffer += sizeof (UINT16);
 366     StringPtr += 4;
 367   }
 368
 369   return EFI_SUCCESS;
 370 }
 371
 372 /**
 373
 374     Extract block config from the array generated by VFR compiler. The name of
 375   this array is "Vfr + <StorageName> + Default<HexCh>4", e.g. "VfrMyIfrNVDataDefault0000".
 376
 377     @param Buffer                - Array generated by VFR compiler.
 378     @param BlockConfig           - The returned <BlockConfig>
 379
 380     @retval EFI_OUT_OF_RESOURCES  - Run out of memory resource.
 381     @retval EFI_INVALID_PARAMETER - Buffer is NULL or BlockConfig is NULL.
 382     @retval EFI_SUCCESS           - Operation successful.
 383
 384 **/
 385 EFI_STATUS
 386 ExtractBlockConfig (
 387   IN UINT8                        *Buffer,
 388   OUT CHAR16                      **BlockConfig
 389   )
 390 {
 391   UINT32      Length;
 392   UINT16      Width;
 393   UINTN       HexStringBufferLen;
 394   CHAR16      *StringPtr;
 395   UINT8       *BufferEnd;
 396   CHAR16      *StringEnd;
 397   EFI_STATUS  Status;
 398
 399   if ((Buffer == NULL) || (BlockConfig == NULL)) {
 400     return EFI_INVALID_PARAMETER;
 401   }
 402
 403   //
 404   // Calculate length of AltResp string
 405   // Format of Default value array is:
 406   //  Array length | 4-bytes
 407   //        Offset | 2-bytes
 408   //        Width  | 2-bytes
 409   //        Value  | Variable length
 410   //        Offset | 2-bytes
 411   //        Width  | 2-bytes
 412   //        Value  | Variable length
 413   //        ... ...
 414   // When value is 1 byte in length, overhead of AltResp string will be maximum,
 415   //  BlockConfig ::= <&OFFSET=1234&WIDTH=1234&VALUE=12>+
 416   //                   |   8   | 4  |  7   | 4 |  7  |2|
 417   // so the maximum length of BlockConfig could be calculated as:
 418   // (ArrayLength / 5) * (8 + 4 + 7 + 4 + 7 + 2) = ArrayLength * 6.4 < ArrayLength * 7
 419   //
 420   CopyMem (&Length, Buffer, sizeof (UINT32));
 421   BufferEnd = Buffer + Length;
 422   StringPtr = AllocatePool (Length * 7 * sizeof (CHAR16));
 423   *BlockConfig = StringPtr;
 424   if (StringPtr == NULL) {
 425       return EFI_OUT_OF_RESOURCES;
 426   }
 427   StringEnd = StringPtr + (Length * 7);
 428
 429   Buffer += sizeof (UINT32);
 430   while (Buffer < BufferEnd) {
 431     StrCpy (StringPtr, L"&OFFSET=");
 432     StringPtr += 8;
 433
 434     HexStringBufferLen = 5;
 435     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 436     Buffer += sizeof (UINT16);
 437     StringPtr += 4;
 438
 439     StrCpy (StringPtr, L"&WIDTH=");
 440     StringPtr += 7;
 441
 442     HexStringBufferLen = 5;
 443     BufToHexString (StringPtr, &HexStringBufferLen, Buffer, sizeof (UINT16));
 444     CopyMem (&Width, Buffer, sizeof (UINT16));
 445     Buffer += sizeof (UINT16);
 446     StringPtr += 4;
 447
 448     StrCpy (StringPtr, L"&VALUE=");
 449     StringPtr += 7;
 450
 451     HexStringBufferLen = StringEnd - StringPtr;
 452     Status = BufToHexString (StringPtr, &HexStringBufferLen, Buffer, Width);
 453     if (EFI_ERROR (Status)) {
 454       return Status;
 455     }
 456     Buffer += Width;
 457     StringPtr += (Width * 2);
 458   }
 459
 460   return EFI_SUCCESS;
 461 }
 462
 463 /**
 464     Construct <ConfigAltResp> for a buffer storage.
 465
 466     @param ConfigRequest           The Config request string. If set to NULL, all the
 467                                    configurable elements will be extracted from BlockNameArray.
 468     @param ConfigAltResp           The returned <ConfigAltResp>.
 469     @param Progress                On return, points to a character in the Request.
 470     @param Guid                    GUID of the buffer storage.
 471     @param Name                    Name of the buffer storage.
 472     @param DriverHandle            The DriverHandle which is used to invoke HiiDatabase
 473                                    protocol interface NewPackageList().
 474     @param BufferStorage           Content of the buffer storage.
 475     @param BufferStorageSize       Length in bytes of the buffer storage.
 476     @param BlockNameArray          Array generated by VFR compiler.
 477     @param NumberAltCfg            Number of Default value array generated by VFR compiler.
 478                                    The sequential input parameters will be number of
 479                                    AltCfgId and DefaultValueArray pairs. When set to 0,
 480                                    there will be no <AltResp>.
 481
 482     retval EFI_OUT_OF_RESOURCES  Run out of memory resource.
 483     retval EFI_INVALID_PARAMETER ConfigAltResp is NULL.
 484     retval EFI_SUCCESS           Operation successful.
 485
 486 **/
 487 EFI_STATUS
 488 ConstructConfigAltResp (
 489   IN  EFI_STRING                  ConfigRequest,  OPTIONAL
 490   OUT EFI_STRING                  *Progress,
 491   OUT EFI_STRING                  *ConfigAltResp,
 492   IN  EFI_GUID                    *Guid,
 493   IN  CHAR16                      *Name,
 494   IN  EFI_HANDLE                  *DriverHandle,
 495   IN  VOID                        *BufferStorage,
 496   IN  UINTN                       BufferStorageSize,
 497   IN  VOID                        *BlockNameArray, OPTIONAL
 498   IN  UINTN                       NumberAltCfg,
 499   ...
 500 //IN  UINT16                      AltCfgId,
 501 //IN  VOID                        *DefaultValueArray,
 502   )
 503 {
 504   EFI_STATUS                      Status;
 505   CHAR16                          *ConfigHdr;
 506   CHAR16                          *BlockName;
 507   CHAR16                          *DescHdr;
 508   CHAR16                          *StringPtr;
 509   CHAR16                          **AltCfg;
 510   UINT16                          AltCfgId;
 511   VOID                            *DefaultValueArray;
 512   UINTN                           StrBufferLen;
 513   EFI_STRING                      ConfigResp;
 514   EFI_STRING                      TempStr;
 515   VA_LIST                         Args;
 516   UINTN                           AltRespLen;
 517   UINTN                           Index;
 518   BOOLEAN                         NeedFreeConfigRequest;
 519   EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
 520   UINTN                           Len;
 521
 522   if (ConfigAltResp == NULL) {
 523     return EFI_INVALID_PARAMETER;
 524   }
 525
 526   DescHdr = NULL;
 527   StringPtr = NULL;
 528   AltCfg    = NULL;
 529   ConfigResp = NULL;
 530   BlockName = NULL;
 531   NeedFreeConfigRequest = FALSE;
 532
 533   //
 534   // Construct <ConfigHdr> : "GUID=...&NAME=...&PATH=..."
 535   //
 536   ConfigHdr = NULL;
 537   StrBufferLen = 0;
 538   Status = ConstructConfigHdr (
 539              ConfigHdr,
 540              &StrBufferLen,
 541              Guid,
 542              Name,
 543              DriverHandle
 544              );
 545   ASSERT (Status == EFI_BUFFER_TOO_SMALL);
 546   ConfigHdr = AllocateZeroPool (StrBufferLen);
 547   if (ConfigHdr == NULL) {
 548     Status = EFI_OUT_OF_RESOURCES;
 549     goto Exit;
 550   }
 551   Status = ConstructConfigHdr (
 552              ConfigHdr,
 553              &StrBufferLen,
 554              Guid,
 555              Name,
 556              DriverHandle
 557              );
 558
 559   if (EFI_ERROR (Status)) {
 560     goto Exit;
 561   }
 562
 563   //
 564   // Construct <ConfigResp>
 565   //
 566   if (ConfigRequest == NULL) {
 567     //
 568     // If ConfigRequest is set to NULL, export all configurable elements in BlockNameArray
 569     //
 570     Status = ExtractBlockName (BlockNameArray, &BlockName);
 571     if (EFI_ERROR (Status)) {
 572       goto Exit;
 573     }
 574
 575     Len = StrSize (ConfigHdr);
 576     ConfigRequest = AllocateZeroPool (Len + StrSize (BlockName) - sizeof (CHAR16));
 577     if (ConfigRequest == NULL) {
 578       Status = EFI_OUT_OF_RESOURCES;
 579       goto Exit;
 580     }
 581
 582     StrCpy (ConfigRequest, ConfigHdr);
 583     StrCat (ConfigRequest, BlockName);
 584     NeedFreeConfigRequest = TRUE;
 585
 586   }
 587
 588   Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
 589   if (EFI_ERROR (Status)) {
 590     return Status;
 591   }
 592
 593   Status = HiiConfigRouting->BlockToConfig (
 594                                HiiConfigRouting,
 595                                ConfigRequest,
 596                                BufferStorage,
 597                                BufferStorageSize,
 598                                &ConfigResp,
 599                                (Progress == NULL) ? &TempStr : Progress
 600                                );
 601   if (EFI_ERROR (Status)) {
 602     return Status;
 603   }
 604
 605   AltRespLen = 0;
 606   //
 607   // Construct <AltResp>
 608   //
 609   if (NumberAltCfg > 0) {
 610     DescHdr = AllocateZeroPool (NumberAltCfg * 16 * sizeof (CHAR16));
 611     if (DescHdr == NULL) {
 612       Status = EFI_OUT_OF_RESOURCES;
 613       goto Exit;
 614     }
 615
 616     StringPtr = DescHdr;
 617     AltCfg = AllocateZeroPool (NumberAltCfg * sizeof (CHAR16 *));
 618     if (AltCfg == NULL) {
 619       Status = EFI_OUT_OF_RESOURCES;
 620       goto Exit;
 621     }
 622
 623     VA_START (Args, NumberAltCfg);
 624     for (Index = 0; Index < NumberAltCfg; Index++) {
 625       AltCfgId = (UINT16) VA_ARG (Args, UINT16);
 626       DefaultValueArray = (UINT8 *) VA_ARG (Args, VOID *);
 627
 628       //
 629       // '&' <ConfigHdr>
 630       //
 631       AltRespLen += (StrLen (ConfigHdr) + 1);
 632
 633       StringPtr = DescHdr + Index * 16;
 634       StrCpy (StringPtr, L"&ALTCFG=");
 635       AltRespLen += (8 + sizeof (UINT16) * 2);
 636
 637       StrBufferLen = 5;
 638       BufToHexString (StringPtr + 8, &StrBufferLen, (UINT8 *) &AltCfgId, sizeof (UINT16));
 639       Status = ExtractBlockConfig (DefaultValueArray, &AltCfg[Index]);
 640       if (EFI_ERROR (Status)) {
 641         goto Exit;
 642       }
 643       AltRespLen += StrLen (AltCfg[Index]);
 644     }
 645     VA_END (Args);
 646   }
 647
 648   //
 649   // Generate the final <ConfigAltResp>
 650   //
 651   StrBufferLen = (StrLen ((CHAR16 *) ConfigResp) + AltRespLen + 1) * sizeof (CHAR16);
 652   TempStr = AllocateZeroPool (StrBufferLen);
 653   *ConfigAltResp = TempStr;
 654   if (TempStr == NULL) {
 655     goto Exit;
 656   }
 657
 658   //
 659   // <ConfigAltResp> ::= <ConfigResp> ['&' <AltResp>]*
 660   //
 661   StrCpy (TempStr, ConfigResp);
 662   for (Index = 0; Index < NumberAltCfg; Index++) {
 663     StrCat (TempStr, L"&");
 664     StrCat (TempStr, ConfigHdr);
 665     StrCat (TempStr, DescHdr + Index * 16);
 666     StrCat (TempStr, AltCfg[Index]);
 667
 668     FreePool (AltCfg[Index]);
 669   }
 670
 671 Exit:
 672   if (NeedFreeConfigRequest) {
 673     FreePool (ConfigRequest);
 674   }
 675   FreePool (ConfigHdr);
 676   if (ConfigResp != NULL) {
 677     FreePool (ConfigResp);
 678   }
 679
 680   if (BlockName != NULL) {
 681     FreePool (BlockName);
 682   }
 683
 684   if (NumberAltCfg > 0) {
 685     FreePool (DescHdr);
 686     FreePool (AltCfg);
 687   }
 688
 689   return EFI_SUCCESS;
 690 }
 691
 692 /**
 693   Swap bytes in the buffer. This is a internal function.
 694
 695   @param  Buffer                 Binary buffer.
 696   @param  BufferSize             Size of the buffer in bytes.
 697
 698   @return None.
 699
 700 **/
 701 VOID
 702 SwapBuffer (
 703   IN OUT UINT8     *Buffer,
 704   IN UINTN         BufferSize
 705   )
 706 {
 707   UINTN  Index;
 708   UINT8  Temp;
 709   UINTN  SwapCount;
 710
 711   SwapCount = BufferSize / 2;
 712   for (Index = 0; Index < SwapCount; Index++) {
 713     Temp = Buffer[Index];
 714     Buffer[Index] = Buffer[BufferSize - 1 - Index];
 715     Buffer[BufferSize - 1 - Index] = Temp;
 716   }
 717 }
 718
 719 /**
 720   Converts the unicode character of the string from uppercase to lowercase.
 721   This is a internal function.
 722
 723   @param Str     String to be converted
 724
 725 **/
 726 VOID
 727 EFIAPI
 728 ToLower (
 729   IN OUT CHAR16    *Str
 730   )
 731 {
 732   CHAR16      *Ptr;
 733
 734   for (Ptr = Str; *Ptr != L'\0'; Ptr++) {
 735     if (*Ptr >= L'A' && *Ptr <= L'Z') {
 736       *Ptr = (CHAR16) (*Ptr - L'A' + L'a');
 737     }
 738   }
 739 }
 740
 741
 742 /**
 743   Converts binary buffer to Unicode string in reversed byte order from BufToHexString().
 744
 745   @param  Str                    String for output
 746   @param  Buffer                 Binary buffer.
 747   @param  BufferSize             Size of the buffer in bytes.
 748
 749   @retval EFI_SUCCESS            The function completed successfully.
 750   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
 751
 752 **/
 753 EFI_STATUS
 754 EFIAPI
 755 BufInReverseOrderToHexString (
 756   IN OUT CHAR16    *Str,
 757   IN UINT8         *Buffer,
 758   IN UINTN         BufferSize
 759   )
 760 {
 761   EFI_STATUS  Status;
 762   UINT8       *NewBuffer;
 763   UINTN       StrBufferLen;
 764
 765   NewBuffer = AllocateCopyPool (BufferSize, Buffer);
 766   if (NewBuffer == NULL) {
 767     return EFI_OUT_OF_RESOURCES;
 768   }
 769   SwapBuffer (NewBuffer, BufferSize);
 770
 771   StrBufferLen = BufferSize * sizeof (CHAR16) + 1;
 772   Status = BufToHexString (Str, &StrBufferLen, NewBuffer, BufferSize);
 773
 774   FreePool (NewBuffer);
 775   //
 776   // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
 777   //
 778   ToLower (Str);
 779
 780   return Status;
 781 }
 782
 783
 784 /**
 785   Converts Hex String to binary buffer in reversed byte order from HexStringToBuf().
 786
 787   @param  Buffer                 Pointer to buffer that receives the data.
 788   @param  BufferSize             Length in bytes of the buffer to hold converted
 789                                  data. If routine return with EFI_SUCCESS,
 790                                  containing length of converted data. If routine
 791                                  return with EFI_BUFFER_TOO_SMALL, containg length
 792                                  of buffer desired.
 793   @param  Str                    String to be converted from.
 794
 795   @retval EFI_SUCCESS            The function completed successfully.
 796   @retval RETURN_BUFFER_TOO_SMALL   The input BufferSize is too small to hold the output. BufferSize
 797                                  will be updated to the size required for the converstion.
 798
 799 **/
 800 EFI_STATUS
 801 EFIAPI
 802 HexStringToBufInReverseOrder (
 803   IN OUT UINT8         *Buffer,
 804   IN OUT UINTN         *BufferSize,
 805   IN CHAR16            *Str
 806   )
 807 {
 808   EFI_STATUS  Status;
 809   UINTN       ConvertedStrLen;
 810
 811   ConvertedStrLen = 0;
 812   Status = HexStringToBuf (Buffer, BufferSize, Str, &ConvertedStrLen);
 813   if (!EFI_ERROR (Status)) {
 814     SwapBuffer (Buffer, (ConvertedStrLen + 1) / 2);
 815   }
 816
 817   return Status;
 818 }
 819
 820 /**
 821   Convert binary representation Config string (e.g. "0041004200430044") to the
 822   original string (e.g. "ABCD"). Config string appears in <ConfigHdr> (i.e.
 823   "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
 824
 825   @param UnicodeString  Original Unicode string.
 826   @param StrBufferLen   On input: Length in bytes of buffer to hold the Unicode string.
 827                                     Includes tailing '\0' character.
 828                                     On output:
 829                                       If return EFI_SUCCESS, containing length of Unicode string buffer.
 830                                       If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
 831   @param ConfigString   Binary representation of Unicode String, <string> := (<HexCh>4)+
 832
 833   @retval EFI_SUCCESS          Operation completes successfully.
 834   @retval EFI_BUFFER_TOO_SMALL The string buffer is too small.
 835
 836 **/
 837 EFI_STATUS
 838 EFIAPI
 839 ConfigStringToUnicode (
 840   IN OUT CHAR16                *UnicodeString,
 841   IN OUT UINTN                 *StrBufferLen,
 842   IN CHAR16                    *ConfigString
 843   )
 844 {
 845   UINTN       Index;
 846   UINTN       Len;
 847   UINTN       BufferSize;
 848   CHAR16      BackupChar;
 849
 850   Len = StrLen (ConfigString) / 4;
 851   BufferSize = (Len + 1) * sizeof (CHAR16);
 852
 853   if (*StrBufferLen < BufferSize) {
 854     *StrBufferLen = BufferSize;
 855     return EFI_BUFFER_TOO_SMALL;
 856   }
 857
 858   *StrBufferLen = BufferSize;
 859
 860   for (Index = 0; Index < Len; Index++) {
 861     BackupChar = ConfigString[4];
 862     ConfigString[4] = L'\0';
 863
 864     HexStringToBuf ((UINT8 *) UnicodeString, &BufferSize, ConfigString, NULL);
 865
 866     ConfigString[4] = BackupChar;
 867
 868     ConfigString += 4;
 869     UnicodeString += 1;
 870   }
 871
 872   //
 873   // Add tailing '\0' character
 874   //
 875   *UnicodeString = L'\0';
 876
 877   return EFI_SUCCESS;
 878 }
 879
 880 /**
 881   Convert Unicode string to binary representation Config string, e.g.
 882   "ABCD" => "0041004200430044". Config string appears in <ConfigHdr> (i.e.
 883   "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
 884
 885   @param ConfigString   Binary representation of Unicode String, <string> := (<HexCh>4)+
 886   @param  StrBufferLen  On input: Length in bytes of buffer to hold the Unicode string.
 887                                     Includes tailing '\0' character.
 888                                     On output:
 889                                       If return EFI_SUCCESS, containing length of Unicode string buffer.
 890                                       If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
 891   @param  UnicodeString  Original Unicode string.
 892
 893   @retval EFI_SUCCESS           Operation completes successfully.
 894   @retval EFI_BUFFER_TOO_SMALL  The string buffer is too small.
 895
 896 **/
 897 EFI_STATUS
 898 EFIAPI
 899 UnicodeToConfigString (
 900   IN OUT CHAR16                *ConfigString,
 901   IN OUT UINTN                 *StrBufferLen,
 902   IN CHAR16                    *UnicodeString
 903   )
 904 {
 905   UINTN       Index;
 906   UINTN       Len;
 907   UINTN       BufferSize;
 908   CHAR16      *String;
 909
 910   Len = StrLen (UnicodeString);
 911   BufferSize = (Len * 4 + 1) * sizeof (CHAR16);
 912
 913   if (*StrBufferLen < BufferSize) {
 914     *StrBufferLen = BufferSize;
 915     return EFI_BUFFER_TOO_SMALL;
 916   }
 917
 918   *StrBufferLen = BufferSize;
 919   String        = ConfigString;
 920
 921   for (Index = 0; Index < Len; Index++) {
 922     BufToHexString (ConfigString, &BufferSize, (UINT8 *) UnicodeString, 2);
 923
 924     ConfigString += 4;
 925     UnicodeString += 1;
 926   }
 927
 928   //
 929   // Add tailing '\0' character
 930   //
 931   *ConfigString = L'\0';
 932
 933   //
 934   // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
 935   //
 936   ToLower (String);
 937   return EFI_SUCCESS;
 938 }
 939
 940 /**
 941   Construct <ConfigHdr> using routing information GUID/NAME/PATH.
 942
 943   @param  ConfigHdr              Pointer to the ConfigHdr string.
 944   @param  StrBufferLen           On input: Length in bytes of buffer to hold the
 945                                  ConfigHdr string. Includes tailing '\0' character.
 946                                  On output: If return EFI_SUCCESS, containing
 947                                  length of ConfigHdr string buffer. If return
 948                                  EFI_BUFFER_TOO_SMALL, containg length of string
 949                                  buffer desired.
 950   @param  Guid                   Routing information: GUID.
 951   @param  Name                   Routing information: NAME.
 952   @param  DriverHandle           Driver handle which contains the routing
 953                                  information: PATH.
 954
 955   @retval EFI_SUCCESS            Operation completes successfully.
 956   @retval EFI_BUFFER_TOO_SMALL   The ConfigHdr string buffer is too small.
 957
 958 **/
 959 EFI_STATUS
 960 EFIAPI
 961 ConstructConfigHdr (
 962   IN OUT CHAR16                *ConfigHdr,
 963   IN OUT UINTN                 *StrBufferLen,
 964   IN CONST EFI_GUID            *Guid,
 965   IN CHAR16                    *Name, OPTIONAL
 966   IN EFI_HANDLE                *DriverHandle
 967   )
 968 {
 969   EFI_STATUS                Status;
 970   UINTN                     NameStrLen;
 971   UINTN                     DevicePathSize;
 972   UINTN                     BufferSize;
 973   CHAR16                    *StrPtr;
 974   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 975
 976   //
 977   // Make sure when ConfigHdr is NULL, StrBufferlen must be 0
 978   //
 979   ASSERT (!(ConfigHdr == NULL && *StrBufferLen != 0));
 980
 981   if (Name == NULL) {
 982     //
 983     // There will be no "NAME" in <ConfigHdr> for  Name/Value storage
 984     //
 985     NameStrLen = 0;
 986   } else {
 987     //
 988     // For buffer storage
 989     //
 990     NameStrLen = StrLen (Name);
 991   }
 992
 993   //
 994   // Retrieve DevicePath Protocol associated with this HiiPackageList
 995   //
 996   Status = gBS->HandleProtocol (
 997                   DriverHandle,
 998                   &gEfiDevicePathProtocolGuid,
 999                   (VOID **) &DevicePath
1000                   );
1001   if (EFI_ERROR (Status)) {
1002     return Status;
1003   }
1004
1005   DevicePathSize = GetDevicePathSize (DevicePath);
1006
1007   //
1008   // GUID=<HexCh>32&NAME=<Char>NameStrLen&PATH=<HexChar>DevicePathStrLen <NULL>
1009   // | 5  |   32   |  6  |  NameStrLen*4 |  6  |    DevicePathStrLen    | 1 |
1010   //
1011   BufferSize = (5 + 32 + 6 + NameStrLen * 4 + 6 + DevicePathSize * 2 + 1) * sizeof (CHAR16);
1012   if (*StrBufferLen < BufferSize) {
1013     *StrBufferLen = BufferSize;
1014     return EFI_BUFFER_TOO_SMALL;
1015   }
1016
1017   *StrBufferLen = BufferSize;
1018
1019   StrPtr = ConfigHdr;
1020
1021   StrCpy (StrPtr, L"GUID=");
1022   StrPtr += 5;
1023   BufInReverseOrderToHexString (StrPtr, (UINT8 *) Guid, sizeof (EFI_GUID));
1024   StrPtr += 32;
1025
1026   //
1027   // Convert name string, e.g. name "ABCD" => "&NAME=0041004200430044"
1028   //
1029   StrCpy (StrPtr, L"&NAME=");
1030   StrPtr += 6;
1031   if (Name != NULL) {
1032     BufferSize = (NameStrLen * 4 + 1) * sizeof (CHAR16);
1033     UnicodeToConfigString (StrPtr, &BufferSize, Name);
1034     StrPtr += (NameStrLen * 4);
1035   }
1036
1037   StrCpy (StrPtr, L"&PATH=");
1038   StrPtr += 6;
1039   BufInReverseOrderToHexString (StrPtr, (UINT8 *) DevicePath, DevicePathSize);
1040
1041   return EFI_SUCCESS;
1042 }
1043
1044 /**
1045   Determines if the Routing data (Guid and Name) is correct in <ConfigHdr>.
1046
1047   @param ConfigString  Either <ConfigRequest> or <ConfigResp>.
1048   @param StorageGuid   GUID of the storage.
1049   @param StorageName   Name of the stoarge.
1050
1051   @retval TRUE         Routing information is correct in ConfigString.
1052   @retval FALSE        Routing information is incorrect in ConfigString.
1053
1054 **/
1055 BOOLEAN
1056 IsConfigHdrMatch (
1057   IN EFI_STRING                ConfigString,
1058   IN EFI_GUID                  *StorageGuid, OPTIONAL
1059   IN CHAR16                    *StorageName  OPTIONAL
1060   )
1061 {
1062   EFI_STATUS  Status;
1063   BOOLEAN     Match;
1064   EFI_GUID    Guid;
1065   CHAR16      *Name;
1066   CHAR16      *StrPtr;
1067   UINTN       BufferSize;
1068
1069   //
1070   // <ConfigHdr> ::=
1071   // GUID=<HexCh>32&NAME=<Char>NameStrLen&PATH=<HexChar>DevicePathStrLen <NULL>
1072   // | 5  |   32   |  6  |  NameStrLen*4 |  6  |    DevicePathStrLen    | 1 |
1073   //
1074   if (StrLen (ConfigString) <= (5 + 32 + 6)) {
1075     return FALSE;
1076   }
1077
1078   //
1079   // Compare GUID
1080   //
1081   if (StorageGuid != NULL) {
1082
1083     StrPtr = ConfigString + 5 + 32;
1084     if (*StrPtr != L'&') {
1085       return FALSE;
1086     }
1087     *StrPtr = L'\0';
1088
1089     BufferSize = sizeof (EFI_GUID);
1090     Status = HexStringToBufInReverseOrder (
1091                (UINT8 *) &Guid,
1092                &BufferSize,
1093                ConfigString + 5
1094                );
1095     *StrPtr = L'&';
1096
1097     if (EFI_ERROR (Status)) {
1098       return FALSE;
1099     }
1100
1101     if (!CompareGuid (&Guid, StorageGuid)) {
1102       return FALSE;
1103     }
1104   }
1105
1106   //
1107   // Compare Name
1108   //
1109   Match = TRUE;
1110   if (StorageName != NULL) {
1111     StrPtr = ConfigString + 5 + 32 + 6;
1112     while (*StrPtr != L'\0' && *StrPtr != L'&') {
1113       StrPtr++;
1114     }
1115     if (*StrPtr != L'&') {
1116       return FALSE;
1117     }
1118
1119     *StrPtr = L'\0';
1120     BufferSize = (((UINTN) StrPtr) - ((UINTN) &ConfigString[5 + 32 + 6])) / 4 + sizeof (CHAR16);
1121     Name = AllocatePool (BufferSize);
1122     ASSERT (Name != NULL);
1123     Status = ConfigStringToUnicode (
1124                Name,
1125                &BufferSize,
1126                ConfigString + 5 + 32 + 6
1127                );
1128     *StrPtr = L'&';
1129
1130     if (EFI_ERROR (Status) || (StrCmp (Name, StorageName) != 0)) {
1131       Match = FALSE;
1132     }
1133     FreePool (Name);
1134   }
1135
1136   return Match;
1137 }
1138
1139 /**
1140   Search BlockName "&OFFSET=Offset&WIDTH=Width" in a string.
1141
1142   @param  String                 The string to be searched in.
1143   @param  Offset                 Offset in BlockName.
1144   @param  Width                  Width in BlockName.
1145
1146   @retval TRUE                   Block name found.
1147   @retval FALSE                  Block name not found.
1148
1149 **/
1150 BOOLEAN
1151 EFIAPI
1152 FindBlockName (
1153   IN OUT CHAR16                *String,
1154   IN UINTN                     Offset,
1155   IN UINTN                     Width
1156   )
1157 {
1158   EFI_STATUS  Status;
1159   UINTN       Data;
1160   UINTN       BufferSize;
1161   UINTN       ConvertedStrLen;
1162
1163   while ((String = StrStr (String, L"&OFFSET=")) != NULL) {
1164     //
1165     // Skip '&OFFSET='
1166     //
1167     String = String + 8;
1168
1169     Data = 0;
1170     BufferSize = sizeof (UINTN);
1171     Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen);
1172     if (EFI_ERROR (Status)) {
1173       return FALSE;
1174     }
1175     String = String + ConvertedStrLen;
1176
1177     if (Data != Offset) {
1178       continue;
1179     }
1180
1181     if (StrnCmp (String, L"&WIDTH=", 7) != 0) {
1182       return FALSE;
1183     }
1184     String = String + 7;
1185
1186     Data = 0;
1187     BufferSize = sizeof (UINTN);
1188     Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen);
1189     if (EFI_ERROR (Status)) {
1190       return FALSE;
1191     }
1192     if (Data == Width) {
1193       return TRUE;
1194     }
1195
1196     String = String + ConvertedStrLen;
1197   }
1198
1199   return FALSE;
1200 }
1201
1202
1203 /**
1204   This routine is invoked by ConfigAccess.Callback() to retrived uncommitted data from Form Browser.
1205
1206   @param  VariableGuid           An optional field to indicate the target variable
1207                                  GUID name to use.
1208   @param  VariableName           An optional field to indicate the target
1209                                  human-readable variable name.
1210   @param  BufferSize             On input: Length in bytes of buffer to hold
1211                                  retrived data. On output: If return
1212                                  EFI_BUFFER_TOO_SMALL, containg length of buffer
1213                                  desired.
1214   @param  Buffer                 Buffer to hold retrived data.
1215
1216   @retval EFI_SUCCESS            Operation completes successfully.
1217   @retval EFI_BUFFER_TOO_SMALL   The intput buffer is too small.
1218   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
1219
1220 **/
1221 EFI_STATUS
1222 EFIAPI
1223 GetBrowserData (
1224   IN CONST EFI_GUID              *VariableGuid, OPTIONAL
1225   IN CONST CHAR16                *VariableName, OPTIONAL
1226   IN OUT UINTN                   *BufferSize,
1227   IN OUT UINT8                   *Buffer
1228   )
1229 {
1230   EFI_STATUS                      Status;
1231   CONST CHAR16                    *ConfigHdr;
1232   CHAR16                          *ConfigResp;
1233   CHAR16                          *StringPtr;
1234   UINTN                           HeaderLen;
1235   UINTN                           BufferLen;
1236   CHAR16                          *Progress;
1237
1238   //
1239   // Locate protocols for use
1240   //
1241   Status = LocateFormBrowser2Protocols ();
1242   if (EFI_ERROR (Status)) {
1243     return Status;
1244   }
1245
1246   //
1247   // Retrive formset storage data from Form Browser
1248   //
1249   ConfigHdr = mFakeConfigHdr;
1250   HeaderLen = StrLen (ConfigHdr);
1251
1252   //
1253   // First try allocate 0x4000 buffer for the formet storage data.
1254   //
1255   BufferLen = 0x4000;
1256   ConfigResp = AllocateZeroPool (BufferLen + HeaderLen);
1257   if (ConfigResp == NULL) {
1258     return EFI_OUT_OF_RESOURCES;
1259   }
1260
1261   StringPtr = ConfigResp + HeaderLen;
1262   *StringPtr = L'&';
1263   StringPtr++;
1264
1265   Status = mFormBrowser2->BrowserCallback (
1266                            mFormBrowser2,
1267                            &BufferLen,
1268                            StringPtr,
1269                            TRUE,
1270                            VariableGuid,
1271                            VariableName
1272                            );
1273   if (Status == EFI_BUFFER_TOO_SMALL) {
1274     FreePool (ConfigResp);
1275
1276     ConfigResp = AllocateZeroPool (BufferLen + HeaderLen);
1277     if (ConfigResp == NULL) {
1278       return EFI_OUT_OF_RESOURCES;
1279     }
1280
1281     StringPtr = ConfigResp + HeaderLen;
1282     *StringPtr = L'&';
1283     StringPtr++;
1284
1285     Status = mFormBrowser2->BrowserCallback (
1286                              mFormBrowser2,
1287                              &BufferLen,
1288                              StringPtr,
1289                              TRUE,
1290                              VariableGuid,
1291                              VariableName
1292                              );
1293   }
1294   if (EFI_ERROR (Status)) {
1295     FreePool (ConfigResp);
1296     return Status;
1297   }
1298   CopyMem (ConfigResp, ConfigHdr, HeaderLen * sizeof (UINT16));
1299
1300   //
1301   // Convert <ConfigResp> to buffer data
1302   //
1303   Status = mIfrSupportLibHiiConfigRouting->ConfigToBlock (
1304                                mIfrSupportLibHiiConfigRouting,
1305                                ConfigResp,
1306                                Buffer,
1307                                BufferSize,
1308                                &Progress
1309                                );
1310   FreePool (ConfigResp);
1311
1312   return Status;
1313 }
1314
1315
1316 /**
1317   This routine is invoked by ConfigAccess.Callback() to update uncommitted data of Form Browser.
1318
1319   @param  VariableGuid           An optional field to indicate the target variable
1320                                  GUID name to use.
1321   @param  VariableName           An optional field to indicate the target
1322                                  human-readable variable name.
1323   @param  BufferSize             Length in bytes of buffer to hold retrived data.
1324   @param  Buffer                 Buffer to hold retrived data.
1325   @param  RequestElement         An optional field to specify which part of the
1326                                  buffer data will be send back to Browser. If NULL,
1327                                  the whole buffer of data will be committed to
1328                                  Browser. <RequestElement> ::=
1329                                  &OFFSET=<Number>&WIDTH=<Number>*
1330
1331   @retval EFI_SUCCESS            Operation completes successfully.
1332   @retval EFI_OUT_OF_RESOURCES   There is no enough available memory space.
1333   @retval Other                  Updating Browser uncommitted data failed.
1334
1335 **/
1336 EFI_STATUS
1337 EFIAPI
1338 SetBrowserData (
1339   IN CONST EFI_GUID          *VariableGuid, OPTIONAL
1340   IN CONST CHAR16            *VariableName, OPTIONAL
1341   IN UINTN                   BufferSize,
1342   IN CONST UINT8             *Buffer,
1343   IN CONST CHAR16            *RequestElement  OPTIONAL
1344   )
1345 {
1346   EFI_STATUS                      Status;
1347   CONST CHAR16                    *ConfigHdr;
1348   CHAR16                          *ConfigResp;
1349   CHAR16                          *StringPtr;
1350   UINTN                           HeaderLen;
1351   UINTN                           BufferLen;
1352   CHAR16                          *Progress;
1353   CHAR16                          BlockName[33];
1354   CHAR16                          *ConfigRequest;
1355   CONST CHAR16                    *Request;
1356
1357   //
1358   // Locate protocols for use
1359   //
1360   Status = LocateFormBrowser2Protocols ();
1361   if (EFI_ERROR (Status)) {
1362     return Status;
1363   }
1364
1365   //
1366   // Prepare <ConfigRequest>
1367   //
1368   ConfigHdr = mFakeConfigHdr;
1369   HeaderLen = StrLen (ConfigHdr);
1370
1371   if (RequestElement == NULL) {
1372     //
1373     // RequestElement not specified, use "&OFFSET=0&WIDTH=<BufferSize>" as <BlockName>
1374     //
1375     BlockName[0] = L'\0';
1376     StrCpy (BlockName, L"&OFFSET=0&WIDTH=");
1377
1378     //
1379     // String lenghth of L"&OFFSET=0&WIDTH=" is 16
1380     //
1381     StringPtr = BlockName + 16;
1382     BufferLen = sizeof (BlockName) - (16 * sizeof (CHAR16));
1383     BufToHexString (StringPtr, &BufferLen, (UINT8 *) &BufferSize, sizeof (UINTN));
1384
1385     Request = BlockName;
1386   } else {
1387     Request = RequestElement;
1388   }
1389
1390   BufferLen = HeaderLen * sizeof (CHAR16) + StrSize (Request);
1391   ConfigRequest = AllocateZeroPool (BufferLen);
1392   if (ConfigRequest == NULL) {
1393     return EFI_OUT_OF_RESOURCES;
1394   }
1395
1396   CopyMem (ConfigRequest, ConfigHdr, HeaderLen * sizeof (CHAR16));
1397   StringPtr = ConfigRequest + HeaderLen;
1398   StrCpy (StringPtr, Request);
1399
1400   //
1401   // Convert buffer to <ConfigResp>
1402   //
1403   Status = mIfrSupportLibHiiConfigRouting->BlockToConfig (
1404                                 mIfrSupportLibHiiConfigRouting,
1405                                 ConfigRequest,
1406                                 Buffer,
1407                                 BufferSize,
1408                                 &ConfigResp,
1409                                 &Progress
1410                                 );
1411   if (EFI_ERROR (Status)) {
1412     FreePool (ConfigRequest);
1413     return Status;
1414   }
1415
1416   //
1417   // Skip <ConfigHdr> and '&'
1418   //
1419   StringPtr = ConfigResp + HeaderLen + 1;
1420
1421   //
1422   // Change uncommitted data in Browser
1423   //
1424   Status = mFormBrowser2->BrowserCallback (
1425                            mFormBrowser2,
1426                            &BufferSize,
1427                            StringPtr,
1428                            FALSE,
1429                            VariableGuid,
1430                            VariableName
1431                            );
1432   FreePool (ConfigRequest);
1433   return Status;
1434 }
1435
1436 /**
1437   Test if  a Unicode character is a hexadecimal digit. If true, the input
1438   Unicode character is converted to a byte.
1439
1440   This function tests if a Unicode character is a hexadecimal digit. If true, the input
1441   Unicode character is converted to a byte. For example, Unicode character
1442   L'A' will be converted to 0x0A.
1443
1444   If Digit is NULL, then ASSERT.
1445
1446   @param  Digit       The output hexadecimal digit.
1447
1448   @param  Char        The input Unicode character.
1449
1450   @retval TRUE        Char is in the range of Hexadecimal number. Digit is updated
1451                       to the byte value of the number.
1452   @retval FALSE       Char is not in the range of Hexadecimal number. Digit is keep
1453                       intact.
1454
1455 **/
1456 BOOLEAN
1457 EFIAPI
1458 IsHexDigit (
1459   OUT UINT8      *Digit,
1460   IN  CHAR16      Char
1461   )
1462 {
1463   ASSERT (Digit != NULL);
1464
1465   if ((Char >= L'0') && (Char <= L'9')) {
1466     *Digit = (UINT8) (Char - L'0');
1467     return TRUE;
1468   }
1469
1470   if ((Char >= L'A') && (Char <= L'F')) {
1471     *Digit = (UINT8) (Char - L'A' + 0x0A);
1472     return TRUE;
1473   }
1474
1475   if ((Char >= L'a') && (Char <= L'f')) {
1476     *Digit = (UINT8) (Char - L'a' + 0x0A);
1477     return TRUE;
1478   }
1479
1480   return FALSE;
1481 }
1482
1483 /**
1484   Convert binary buffer to a Unicode String in a specified sequence.
1485
1486   This function converts bytes in the memory block pointed by Buffer to a Unicode String Str.
1487   Each byte will be represented by two Unicode characters. For example, byte 0xA1 will
1488   be converted into two Unicode character L'A' and L'1'. In the output String, the Unicode Character
1489   for the Most Significant Nibble will be put before the Unicode Character for the Least Significant
1490   Nibble. The output string for the buffer containing a single byte 0xA1 will be L"A1".
1491   For a buffer with multiple bytes, the Unicode character produced by the first byte will be put into the
1492   the last character in the output string. The one next to first byte will be put into the
1493   character before the last character. This rules applies to the rest of the bytes. The Unicode
1494   character by the last byte will be put into the first character in the output string. For example,
1495   the input buffer for a 64-bits unsigned integer 0x12345678abcdef1234 will be converted to
1496   a Unicode string equal to L"12345678abcdef1234".
1497
1498   @param String                        On input, String is pointed to the buffer allocated for the convertion.
1499   @param StringLen                     The Length of String buffer to hold the output String. The length must include the tailing '\0' character.
1500                                        The StringLen required to convert a N bytes Buffer will be a least equal to or greater
1501                                        than 2*N + 1.
1502   @param Buffer                        The pointer to a input buffer.
1503   @param BufferSizeInBytes             Length in bytes of the input buffer.
1504
1505
1506   @retval  EFI_SUCCESS                 The convertion is successful. All bytes in Buffer has been convert to the corresponding
1507                                        Unicode character and placed into the right place in String.
1508   @retval  EFI_BUFFER_TOO_SMALL        StringSizeInBytes is smaller than 2 * N + 1the number of bytes required to
1509                                        complete the convertion.
1510 **/
1511 RETURN_STATUS
1512 EFIAPI
1513 BufToHexString (
1514   IN OUT       CHAR16               *String,
1515   IN OUT       UINTN                *StringLen,
1516   IN     CONST UINT8                *Buffer,
1517   IN           UINTN                BufferSizeInBytes
1518   )
1519 {
1520   UINTN       Idx;
1521   UINT8       Byte;
1522   UINTN       StrLen;
1523
1524   //
1525   // Make sure string is either passed or allocate enough.
1526   // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
1527   // Plus the Unicode termination character.
1528   //
1529   StrLen = BufferSizeInBytes * 2;
1530   if (StrLen > ((*StringLen) - 1)) {
1531     *StringLen = StrLen + 1;
1532     return RETURN_BUFFER_TOO_SMALL;
1533   }
1534
1535   *StringLen = StrLen + 1;
1536   //
1537   // Ends the string.
1538   //
1539   String[StrLen] = L'\0';
1540
1541   for (Idx = 0; Idx < BufferSizeInBytes; Idx++) {
1542     Byte = Buffer[Idx];
1543     String[StrLen - 1 - Idx * 2] = mIfrSupportLibHexStr [Byte & 0xF];
1544     String[StrLen - 2 - Idx * 2] = mIfrSupportLibHexStr [Byte >> 4];
1545   }
1546
1547   return RETURN_SUCCESS;
1548 }
1549
1550
1551 /**
1552   Convert a Unicode string consisting of hexadecimal characters to a output byte buffer.
1553
1554   This function converts a Unicode string consisting of characters in the range of Hexadecimal
1555   character (L'0' to L'9', L'A' to L'F' and L'a' to L'f') to a output byte buffer. The function will stop
1556   at the first non-hexadecimal character or the NULL character. The convertion process can be
1557   simply viewed as the reverse operations defined by BufToHexString. Two Unicode characters will be
1558   converted into one byte. The first Unicode character represents the Most Significant Nibble and the
1559   second Unicode character represents the Least Significant Nibble in the output byte.
1560   The first pair of Unicode characters represents the last byte in the output buffer. The second pair of Unicode
1561   characters represent the  the byte preceding the last byte. This rule applies to the rest pairs of bytes.
1562   The last pair represent the first byte in the output buffer.
1563
1564   For example, a Unciode String L"12345678" will be converted into a buffer wil the following bytes
1565   (first byte is the byte in the lowest memory address): "0x78, 0x56, 0x34, 0x12".
1566
1567   If String has N valid hexadecimal characters for conversion,  the caller must make sure Buffer is at least
1568   N/2 (if N is even) or (N+1)/2 (if N if odd) bytes.
1569
1570   If either Buffer, BufferSizeInBytes or String is NULL, then ASSERT ().
1571
1572   @param Buffer                      The output buffer allocated by the caller.
1573   @param BufferSizeInBytes           On input, the size in bytes of Buffer. On output, it is updated to
1574                                      contain the size of the Buffer which is actually used for the converstion.
1575                                      For Unicode string with 2*N hexadecimal characters (not including the
1576                                      tailing NULL character), N bytes of Buffer will be used for the output.
1577   @param String                      The input hexadecimal string.
1578   @param ConvertedStrLen             The number of hexadecimal characters used to produce content in output
1579                                      buffer Buffer.
1580
1581   @retval  RETURN_BUFFER_TOO_SMALL   The input BufferSizeInBytes is too small to hold the output. BufferSizeInBytes
1582                                      will be updated to the size required for the converstion.
1583   @retval  RETURN_SUCCESS            The convertion is successful or the first Unicode character from String
1584                                      is hexadecimal. If ConvertedStrLen is not NULL, it is updated
1585                                      to the number of hexadecimal character used for the converstion.
1586 **/
1587 RETURN_STATUS
1588 EFIAPI
1589 HexStringToBuf (
1590   OUT          UINT8                    *Buffer,
1591   IN OUT       UINTN                    *BufferSizeInBytes,
1592   IN     CONST CHAR16                   *String,
1593   OUT          UINTN                    *ConvertedStrLen  OPTIONAL
1594   )
1595 {
1596   UINTN       HexCnt;
1597   UINTN       Idx;
1598   UINTN       BufferLength;
1599   UINT8       Digit;
1600   UINT8       Byte;
1601
1602   ASSERT (Buffer != NULL);
1603   ASSERT (BufferSizeInBytes != NULL);
1604   ASSERT (String != NULL);
1605
1606   //
1607   // Find out how many hex characters the string has.
1608   //
1609   for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, String[Idx]); Idx++, HexCnt++);
1610
1611   if (HexCnt == 0) {
1612     *ConvertedStrLen = 0;
1613     return RETURN_SUCCESS;
1614   }
1615   //
1616   // Two Unicode characters make up 1 buffer byte. Round up.
1617   //
1618   BufferLength = (HexCnt + 1) / 2;
1619
1620   //
1621   // Test if  buffer is passed enough.
1622   //
1623   if (BufferLength > (*BufferSizeInBytes)) {
1624     *BufferSizeInBytes = BufferLength;
1625     return RETURN_BUFFER_TOO_SMALL;
1626   }
1627
1628   *BufferSizeInBytes = BufferLength;
1629
1630   for (Idx = 0; Idx < HexCnt; Idx++) {
1631
1632     IsHexDigit (&Digit, String[HexCnt - 1 - Idx]);
1633
1634     //
1635     // For odd charaters, write the lower nibble for each buffer byte,
1636     // and for even characters, the upper nibble.
1637     //
1638     if ((Idx & 1) == 0) {
1639       Byte = Digit;
1640     } else {
1641       Byte = Buffer[Idx / 2];
1642       Byte &= 0x0F;
1643       Byte = (UINT8) (Byte | Digit << 4);
1644     }
1645
1646     Buffer[Idx / 2] = Byte;
1647   }
1648
1649   if (ConvertedStrLen != NULL) {
1650     *ConvertedStrLen = HexCnt;
1651   }
1652
1653   return RETURN_SUCCESS;
1654 }