1 /** @file 2 Implementation of interfaces function for EFI_HII_CONFIG_ROUTING_PROTOCOL. 3 4 Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 16 #include "HiiDatabase.h" 17 extern HII_DATABASE_PRIVATE_DATA mPrivate; 18 19 /** 20 Calculate the number of Unicode characters of the incoming Configuration string, 21 not including NULL terminator. 22 23 This is a internal function. 24 25 @param String String in <MultiConfigRequest> or 26 <MultiConfigResp> format. 27 28 @return The number of Unicode characters. 29 30 **/ 31 UINTN 32 CalculateConfigStringLen ( 33 IN EFI_STRING String 34 ) 35 { 36 EFI_STRING TmpPtr; 37 38 // 39 // "GUID=" should be the first element of incoming string. 40 // 41 ASSERT (String != NULL); 42 ASSERT (StrnCmp (String, L"GUID=", StrLen (L"GUID=")) == 0); 43 44 // 45 // The beginning of next <ConfigRequest>/<ConfigResp> should be "&GUID=". 46 // Will meet '\0' if there is only one <ConfigRequest>/<ConfigResp>. 47 // 48 TmpPtr = StrStr (String, L"&GUID="); 49 if (TmpPtr == NULL) { 50 return StrLen (String); 51 } 52 53 return (TmpPtr - String); 54 } 55 56 57 /** 58 Convert the hex UNICODE %02x encoding of a UEFI device path to binary 59 from <PathHdr> of <ConfigHdr>. 60 61 This is a internal function. 62 63 @param String UEFI configuration string 64 @param DevicePathData Binary of a UEFI device path. 65 66 @retval EFI_NOT_FOUND The device path is not invalid. 67 @retval EFI_INVALID_PARAMETER Any incoming parameter is invalid. 68 @retval EFI_OUT_OF_RESOURCES Lake of resources to store neccesary structures. 69 @retval EFI_SUCCESS The device path is retrieved and translated to 70 binary format. 71 72 **/ 73 EFI_STATUS 74 GetDevicePath ( 75 IN EFI_STRING String, 76 OUT UINT8 **DevicePathData 77 ) 78 { 79 UINTN Length; 80 EFI_STRING PathHdr; 81 UINT8 *DevicePathBuffer; 82 CHAR16 TemStr[2]; 83 UINTN Index; 84 UINT8 DigitUint8; 85 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 86 87 88 if (String == NULL || DevicePathData == NULL) { 89 return EFI_INVALID_PARAMETER; 90 } 91 92 // 93 // Find the 'PATH=' of <PathHdr> and skip it. 94 // 95 for (; (*String != 0 && StrnCmp (String, L"PATH=", StrLen (L"PATH=")) != 0); String++); 96 if (*String == 0) { 97 return EFI_INVALID_PARAMETER; 98 } 99 // 100 // Check whether path data does exist. 101 // 102 String += StrLen (L"PATH="); 103 if (*String == 0) { 104 return EFI_INVALID_PARAMETER; 105 } 106 PathHdr = String; 107 108 // 109 // The content between 'PATH=' of <ConfigHdr> and '&' of next element 110 // or '\0' (end of configuration string) is the UNICODE %02x bytes encoding 111 // of UEFI device path. 112 // 113 for (Length = 0; *String != 0 && *String != L'&'; String++, Length++); 114 // 115 // Check DevicePath Length 116 // 117 if (((Length + 1) / 2) < sizeof (EFI_DEVICE_PATH_PROTOCOL)) { 118 return EFI_NOT_FOUND; 119 } 120 121 // 122 // The data in <PathHdr> is encoded as hex UNICODE %02x bytes in the same order 123 // as the device path resides in RAM memory. 124 // Translate the data into binary. 125 // 126 DevicePathBuffer = (UINT8 *) AllocateZeroPool ((Length + 1) / 2); 127 if (DevicePathBuffer == NULL) { 128 return EFI_OUT_OF_RESOURCES; 129 } 130 131 // 132 // Convert DevicePath 133 // 134 ZeroMem (TemStr, sizeof (TemStr)); 135 for (Index = 0; Index < Length; Index ++) { 136 TemStr[0] = PathHdr[Index]; 137 DigitUint8 = (UINT8) StrHexToUint64 (TemStr); 138 if ((Index & 1) == 0) { 139 DevicePathBuffer [Index/2] = DigitUint8; 140 } else { 141 DevicePathBuffer [Index/2] = (UINT8) ((DevicePathBuffer [Index/2] << 4) + DigitUint8); 142 } 143 } 144 145 // 146 // Validate DevicePath 147 // 148 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) DevicePathBuffer; 149 while (!IsDevicePathEnd (DevicePath)) { 150 if ((DevicePath->Type == 0) || (DevicePath->SubType == 0) || (DevicePathNodeLength (DevicePath) < sizeof (EFI_DEVICE_PATH_PROTOCOL))) { 151 // 152 // Invalid device path 153 // 154 FreePool (DevicePathBuffer); 155 return EFI_NOT_FOUND; 156 } 157 DevicePath = NextDevicePathNode (DevicePath); 158 } 159 160 // 161 // return the device path 162 // 163 *DevicePathData = DevicePathBuffer; 164 return EFI_SUCCESS; 165 } 166 167 /** 168 Converts the unicode character of the string from uppercase to lowercase. 169 This is a internal function. 170 171 @param ConfigString String to be converted 172 173 **/ 174 VOID 175 EFIAPI 176 HiiToLower ( 177 IN EFI_STRING ConfigString 178 ) 179 { 180 EFI_STRING String; 181 BOOLEAN Lower; 182 183 ASSERT (ConfigString != NULL); 184 185 // 186 // Convert all hex digits in range [A-F] in the configuration header to [a-f] 187 // 188 for (String = ConfigString, Lower = FALSE; *String != L'\0'; String++) { 189 if (*String == L'=') { 190 Lower = TRUE; 191 } else if (*String == L'&') { 192 Lower = FALSE; 193 } else if (Lower && *String >= L'A' && *String <= L'F') { 194 *String = (CHAR16) (*String - L'A' + L'a'); 195 } 196 } 197 198 return; 199 } 200 201 /** 202 Generate a sub string then output it. 203 204 This is a internal function. 205 206 @param String A constant string which is the prefix of the to be 207 generated string, e.g. GUID= 208 209 @param BufferLen The length of the Buffer in bytes. 210 211 @param Buffer Points to a buffer which will be converted to be the 212 content of the generated string. 213 214 @param Flag If 1, the buffer contains data for the value of GUID or PATH stored in 215 UINT8 *; if 2, the buffer contains unicode string for the value of NAME; 216 if 3, the buffer contains other data. 217 218 @param SubStr Points to the output string. It's caller's 219 responsibility to free this buffer. 220 221 222 **/ 223 VOID 224 GenerateSubStr ( 225 IN CONST EFI_STRING String, 226 IN UINTN BufferLen, 227 IN VOID *Buffer, 228 IN UINT8 Flag, 229 OUT EFI_STRING *SubStr 230 ) 231 { 232 UINTN Length; 233 EFI_STRING Str; 234 EFI_STRING StringHeader; 235 CHAR16 *TemString; 236 CHAR16 *TemName; 237 UINT8 *TemBuffer; 238 UINTN Index; 239 240 ASSERT (String != NULL && SubStr != NULL); 241 242 if (Buffer == NULL) { 243 *SubStr = AllocateCopyPool (StrSize (String), String); 244 ASSERT (*SubStr != NULL); 245 return; 246 } 247 248 // 249 // Header + Data + '&' + '\0' 250 // 251 Length = StrLen (String) + BufferLen * 2 + 1 + 1; 252 Str = AllocateZeroPool (Length * sizeof (CHAR16)); 253 ASSERT (Str != NULL); 254 255 StrCpyS (Str, Length, String); 256 257 StringHeader = Str + StrLen (String); 258 TemString = (CHAR16 *) StringHeader; 259 260 switch (Flag) { 261 case 1: 262 // 263 // Convert Buffer to Hex String in reverse order 264 // 265 TemBuffer = ((UINT8 *) Buffer); 266 for (Index = 0; Index < BufferLen; Index ++, TemBuffer ++) { 267 TemString += UnicodeValueToString (TemString, PREFIX_ZERO | RADIX_HEX, *TemBuffer, 2); 268 } 269 break; 270 case 2: 271 // 272 // Check buffer is enough 273 // 274 TemName = (CHAR16 *) Buffer; 275 ASSERT ((BufferLen * 2 + 1) >= (StrLen (TemName) * 4 + 1)); 276 // 277 // Convert Unicode String to Config String, e.g. "ABCD" => "0041004200430044" 278 // 279 for (; *TemName != L'\0'; TemName++) { 280 TemString += UnicodeValueToString (TemString, PREFIX_ZERO | RADIX_HEX, *TemName, 4); 281 } 282 break; 283 case 3: 284 // 285 // Convert Buffer to Hex String 286 // 287 TemBuffer = ((UINT8 *) Buffer) + BufferLen - 1; 288 for (Index = 0; Index < BufferLen; Index ++, TemBuffer --) { 289 TemString += UnicodeValueToString (TemString, PREFIX_ZERO | RADIX_HEX, *TemBuffer, 2); 290 } 291 break; 292 default: 293 break; 294 } 295 296 // 297 // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format. 298 // 299 StrCatS (Str, Length, L"&"); 300 HiiToLower (Str); 301 302 *SubStr = Str; 303 } 304 305 306 /** 307 Retrieve the <ConfigBody> from String then output it. 308 309 This is a internal function. 310 311 @param String A sub string of a configuration string in 312 <MultiConfigAltResp> format. 313 @param ConfigBody Points to the output string. It's caller's 314 responsibility to free this buffer. 315 316 @retval EFI_INVALID_PARAMETER There is no form package in current hii database. 317 @retval EFI_OUT_OF_RESOURCES Not enough memory to finish this operation. 318 @retval EFI_SUCCESS All existing storage is exported. 319 320 **/ 321 EFI_STATUS 322 OutputConfigBody ( 323 IN EFI_STRING String, 324 OUT EFI_STRING *ConfigBody 325 ) 326 { 327 EFI_STRING TmpPtr; 328 EFI_STRING Result; 329 UINTN Length; 330 331 if (String == NULL || ConfigBody == NULL) { 332 return EFI_INVALID_PARAMETER; 333 } 334 335 // 336 // The setting information should start OFFSET, not ALTCFG. 337 // 338 if (StrnCmp (String, L"&ALTCFG=", StrLen (L"&ALTCFG=")) == 0) { 339 return EFI_INVALID_PARAMETER; 340 } 341 342 TmpPtr = StrStr (String, L"GUID="); 343 if (TmpPtr == NULL) { 344 // 345 // It is the last <ConfigResp> of the incoming configuration string. 346 // 347 Result = AllocateCopyPool (StrSize (String), String); 348 if (Result == NULL) { 349 return EFI_OUT_OF_RESOURCES; 350 } else { 351 *ConfigBody = Result; 352 return EFI_SUCCESS; 353 } 354 } 355 356 Length = TmpPtr - String; 357 if (Length == 0) { 358 return EFI_NOT_FOUND; 359 } 360 Result = AllocateCopyPool (Length * sizeof (CHAR16), String); 361 if (Result == NULL) { 362 return EFI_OUT_OF_RESOURCES; 363 } 364 365 *(Result + Length - 1) = 0; 366 *ConfigBody = Result; 367 return EFI_SUCCESS; 368 } 369 370 /** 371 Append a string to a multi-string format. 372 373 This is a internal function. 374 375 @param MultiString String in <MultiConfigRequest>, 376 <MultiConfigAltResp>, or <MultiConfigResp>. On 377 input, the buffer length of this string is 378 MAX_STRING_LENGTH. On output, the buffer length 379 might be updated. 380 @param AppendString NULL-terminated Unicode string. 381 382 @retval EFI_INVALID_PARAMETER Any incoming parameter is invalid. 383 @retval EFI_SUCCESS AppendString is append to the end of MultiString 384 385 **/ 386 EFI_STATUS 387 AppendToMultiString ( 388 IN OUT EFI_STRING *MultiString, 389 IN EFI_STRING AppendString 390 ) 391 { 392 UINTN AppendStringSize; 393 UINTN MultiStringSize; 394 UINTN MaxLen; 395 396 if (MultiString == NULL || *MultiString == NULL || AppendString == NULL) { 397 return EFI_INVALID_PARAMETER; 398 } 399 400 AppendStringSize = StrSize (AppendString); 401 MultiStringSize = StrSize (*MultiString); 402 MaxLen = MAX_STRING_LENGTH / sizeof (CHAR16); 403 404 // 405 // Enlarge the buffer each time when length exceeds MAX_STRING_LENGTH. 406 // 407 if (MultiStringSize + AppendStringSize > MAX_STRING_LENGTH || 408 MultiStringSize > MAX_STRING_LENGTH) { 409 *MultiString = (EFI_STRING) ReallocatePool ( 410 MultiStringSize, 411 MultiStringSize + AppendStringSize, 412 (VOID *) (*MultiString) 413 ); 414 MaxLen = (MultiStringSize + AppendStringSize) / sizeof (CHAR16); 415 ASSERT (*MultiString != NULL); 416 } 417 // 418 // Append the incoming string 419 // 420 StrCatS (*MultiString, MaxLen, AppendString); 421 422 return EFI_SUCCESS; 423 } 424 425 426 /** 427 Get the value of <Number> in <BlockConfig> format, i.e. the value of OFFSET 428 or WIDTH or VALUE. 429 <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number> 430 431 This is a internal function. 432 433 @param StringPtr String in <BlockConfig> format and points to the 434 first character of <Number>. 435 @param Number The output value. Caller takes the responsibility 436 to free memory. 437 @param Len Length of the <Number>, in characters. 438 439 @retval EFI_OUT_OF_RESOURCES Insufficient resources to store neccessary 440 structures. 441 @retval EFI_SUCCESS Value of <Number> is outputted in Number 442 successfully. 443 444 **/ 445 EFI_STATUS 446 GetValueOfNumber ( 447 IN EFI_STRING StringPtr, 448 OUT UINT8 **Number, 449 OUT UINTN *Len 450 ) 451 { 452 EFI_STRING TmpPtr; 453 UINTN Length; 454 EFI_STRING Str; 455 UINT8 *Buf; 456 EFI_STATUS Status; 457 UINT8 DigitUint8; 458 UINTN Index; 459 CHAR16 TemStr[2]; 460 461 if (StringPtr == NULL || *StringPtr == L'\0' || Number == NULL || Len == NULL) { 462 return EFI_INVALID_PARAMETER; 463 } 464 465 Buf = NULL; 466 467 TmpPtr = StringPtr; 468 while (*StringPtr != L'\0' && *StringPtr != L'&') { 469 StringPtr++; 470 } 471 *Len = StringPtr - TmpPtr; 472 Length = *Len + 1; 473 474 Str = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16)); 475 if (Str == NULL) { 476 Status = EFI_OUT_OF_RESOURCES; 477 goto Exit; 478 } 479 CopyMem (Str, TmpPtr, *Len * sizeof (CHAR16)); 480 *(Str + *Len) = L'\0'; 481 482 Length = (Length + 1) / 2; 483 Buf = (UINT8 *) AllocateZeroPool (Length); 484 if (Buf == NULL) { 485 Status = EFI_OUT_OF_RESOURCES; 486 goto Exit; 487 } 488 489 Length = *Len; 490 ZeroMem (TemStr, sizeof (TemStr)); 491 for (Index = 0; Index < Length; Index ++) { 492 TemStr[0] = Str[Length - Index - 1]; 493 DigitUint8 = (UINT8) StrHexToUint64 (TemStr); 494 if ((Index & 1) == 0) { 495 Buf [Index/2] = DigitUint8; 496 } else { 497 Buf [Index/2] = (UINT8) ((DigitUint8 << 4) + Buf [Index/2]); 498 } 499 } 500 501 *Number = Buf; 502 Status = EFI_SUCCESS; 503 504 Exit: 505 if (Str != NULL) { 506 FreePool (Str); 507 } 508 509 return Status; 510 } 511 512 /** 513 This function merges DefaultAltCfgResp string into AltCfgResp string for 514 the missing AltCfgId in AltCfgResq. 515 516 @param AltCfgResp Pointer to a null-terminated Unicode string in 517 <ConfigAltResp> format. The default value string 518 will be merged into it. 519 @param DefaultAltCfgResp Pointer to a null-terminated Unicode string in 520 <MultiConfigAltResp> format. The default value 521 string may contain more than one ConfigAltResp 522 string for the different varstore buffer. 523 524 @retval EFI_SUCCESS The merged string returns. 525 @retval EFI_INVALID_PARAMETER *AltCfgResp is to NULL. 526 **/ 527 EFI_STATUS 528 EFIAPI 529 MergeDefaultString ( 530 IN OUT EFI_STRING *AltCfgResp, 531 IN EFI_STRING DefaultAltCfgResp 532 ) 533 { 534 EFI_STRING StringPtrDefault; 535 EFI_STRING StringPtrEnd; 536 CHAR16 TempChar; 537 EFI_STRING StringPtr; 538 EFI_STRING AltConfigHdr; 539 UINTN HeaderLength; 540 UINTN SizeAltCfgResp; 541 UINTN MaxLen; 542 UINTN TotalSize; 543 544 if (*AltCfgResp == NULL) { 545 return EFI_INVALID_PARAMETER; 546 } 547 548 // 549 // Get the requestr ConfigHdr 550 // 551 SizeAltCfgResp = 0; 552 StringPtr = *AltCfgResp; 553 554 // 555 // Find <ConfigHdr> GUID=...&NAME=...&PATH=... 556 // 557 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 558 return EFI_INVALID_PARAMETER; 559 } 560 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&NAME=", StrLen (L"&NAME=")) != 0) { 561 StringPtr++; 562 } 563 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&PATH=", StrLen (L"&PATH=")) != 0) { 564 StringPtr++; 565 } 566 if (*StringPtr == L'\0') { 567 return EFI_INVALID_PARAMETER; 568 } 569 StringPtr += StrLen (L"&PATH="); 570 while (*StringPtr != L'\0' && *StringPtr != L'&') { 571 StringPtr ++; 572 } 573 HeaderLength = StringPtr - *AltCfgResp; 574 575 // 576 // Construct AltConfigHdr string "&<ConfigHdr>&ALTCFG=XXXX\0" 577 // |1| StrLen (ConfigHdr) | 8 | 4 | 1 | 578 // 579 MaxLen = 1 + HeaderLength + 8 + 4 + 1; 580 AltConfigHdr = AllocateZeroPool (MaxLen * sizeof (CHAR16)); 581 if (AltConfigHdr == NULL) { 582 return EFI_OUT_OF_RESOURCES; 583 } 584 StrCpyS (AltConfigHdr, MaxLen, L"&"); 585 StrnCatS (AltConfigHdr, MaxLen, *AltCfgResp, HeaderLength); 586 StrCatS (AltConfigHdr, MaxLen, L"&ALTCFG="); 587 HeaderLength = StrLen (AltConfigHdr); 588 589 StringPtrDefault = StrStr (DefaultAltCfgResp, AltConfigHdr); 590 while (StringPtrDefault != NULL) { 591 // 592 // Get AltCfg Name 593 // 594 StrnCatS (AltConfigHdr, MaxLen, StringPtrDefault + HeaderLength, 4); 595 StringPtr = StrStr (*AltCfgResp, AltConfigHdr); 596 597 // 598 // Append the found default value string to the input AltCfgResp 599 // 600 if (StringPtr == NULL) { 601 StringPtrEnd = StrStr (StringPtrDefault + 1, L"&GUID"); 602 SizeAltCfgResp = StrSize (*AltCfgResp); 603 TotalSize = SizeAltCfgResp + StrSize (StringPtrDefault); 604 if (StringPtrEnd == NULL) { 605 // 606 // No more default string is found. 607 // 608 *AltCfgResp = (EFI_STRING) ReallocatePool ( 609 SizeAltCfgResp, 610 TotalSize, 611 (VOID *) (*AltCfgResp) 612 ); 613 if (*AltCfgResp == NULL) { 614 FreePool (AltConfigHdr); 615 return EFI_OUT_OF_RESOURCES; 616 } 617 StrCatS (*AltCfgResp, TotalSize / sizeof (CHAR16), StringPtrDefault); 618 break; 619 } else { 620 TempChar = *StringPtrEnd; 621 *StringPtrEnd = L'\0'; 622 *AltCfgResp = (EFI_STRING) ReallocatePool ( 623 SizeAltCfgResp, 624 TotalSize, 625 (VOID *) (*AltCfgResp) 626 ); 627 if (*AltCfgResp == NULL) { 628 FreePool (AltConfigHdr); 629 return EFI_OUT_OF_RESOURCES; 630 } 631 StrCatS (*AltCfgResp, TotalSize / sizeof (CHAR16), StringPtrDefault); 632 *StringPtrEnd = TempChar; 633 } 634 } 635 636 // 637 // Find next AltCfg String 638 // 639 *(AltConfigHdr + HeaderLength) = L'\0'; 640 StringPtrDefault = StrStr (StringPtrDefault + 1, AltConfigHdr); 641 } 642 643 FreePool (AltConfigHdr); 644 return EFI_SUCCESS; 645 } 646 647 /** 648 This function inserts new DefaultValueData into the BlockData DefaultValue array. 649 650 @param BlockData The BlockData is updated to add new default value. 651 @param DefaultValueData The DefaultValue is added. 652 653 **/ 654 VOID 655 InsertDefaultValue ( 656 IN IFR_BLOCK_DATA *BlockData, 657 IN IFR_DEFAULT_DATA *DefaultValueData 658 ) 659 { 660 LIST_ENTRY *Link; 661 IFR_DEFAULT_DATA *DefaultValueArray; 662 LIST_ENTRY *DefaultLink; 663 664 DefaultLink = &BlockData->DefaultValueEntry; 665 666 for (Link = DefaultLink->ForwardLink; Link != DefaultLink; Link = Link->ForwardLink) { 667 DefaultValueArray = BASE_CR (Link, IFR_DEFAULT_DATA, Entry); 668 if (DefaultValueArray->DefaultId == DefaultValueData->DefaultId) { 669 // 670 // DEFAULT_VALUE_FROM_OPCODE has high priority, DEFAULT_VALUE_FROM_DEFAULT has low priority. 671 // 672 if (DefaultValueData->Type > DefaultValueArray->Type) { 673 // 674 // Update the default value array in BlockData. 675 // 676 CopyMem (&DefaultValueArray->Value, &DefaultValueData->Value, sizeof (EFI_IFR_TYPE_VALUE)); 677 DefaultValueArray->Type = DefaultValueData->Type; 678 DefaultValueArray->Cleaned = DefaultValueData->Cleaned; 679 } 680 return; 681 } 682 } 683 684 // 685 // Insert new default value data in tail. 686 // 687 DefaultValueArray = AllocateZeroPool (sizeof (IFR_DEFAULT_DATA)); 688 ASSERT (DefaultValueArray != NULL); 689 CopyMem (DefaultValueArray, DefaultValueData, sizeof (IFR_DEFAULT_DATA)); 690 InsertTailList (Link, &DefaultValueArray->Entry); 691 } 692 693 /** 694 This function inserts new BlockData into the block link 695 696 @param BlockLink The list entry points to block array. 697 @param BlockData The point to BlockData is added. 698 699 **/ 700 VOID 701 InsertBlockData ( 702 IN LIST_ENTRY *BlockLink, 703 IN IFR_BLOCK_DATA **BlockData 704 ) 705 { 706 LIST_ENTRY *Link; 707 IFR_BLOCK_DATA *BlockArray; 708 IFR_BLOCK_DATA *BlockSingleData; 709 710 BlockSingleData = *BlockData; 711 712 if (BlockSingleData->Name != NULL) { 713 InsertTailList (BlockLink, &BlockSingleData->Entry); 714 return; 715 } 716 717 // 718 // Insert block data in its Offset and Width order. 719 // 720 for (Link = BlockLink->ForwardLink; Link != BlockLink; Link = Link->ForwardLink) { 721 BlockArray = BASE_CR (Link, IFR_BLOCK_DATA, Entry); 722 if (BlockArray->Offset == BlockSingleData->Offset) { 723 if (BlockArray->Width > BlockSingleData->Width) { 724 // 725 // Insert this block data in the front of block array 726 // 727 InsertTailList (Link, &BlockSingleData->Entry); 728 return; 729 } 730 731 if (BlockArray->Width == BlockSingleData->Width) { 732 // 733 // The same block array has been added. 734 // 735 if (BlockSingleData != BlockArray) { 736 FreePool (BlockSingleData); 737 *BlockData = BlockArray; 738 } 739 return; 740 } 741 } else if (BlockArray->Offset > BlockSingleData->Offset) { 742 // 743 // Insert new block data in the front of block array 744 // 745 InsertTailList (Link, &BlockSingleData->Entry); 746 return; 747 } 748 } 749 750 // 751 // Add new block data into the tail. 752 // 753 InsertTailList (Link, &BlockSingleData->Entry); 754 } 755 756 /** 757 Retrieves a pointer to the a Null-terminated ASCII string containing the list 758 of languages that an HII handle in the HII Database supports. The returned 759 string is allocated using AllocatePool(). The caller is responsible for freeing 760 the returned string using FreePool(). The format of the returned string follows 761 the language format assumed the HII Database. 762 763 If HiiHandle is NULL, then ASSERT(). 764 765 @param[in] HiiHandle A handle that was previously registered in the HII Database. 766 767 @retval NULL HiiHandle is not registered in the HII database 768 @retval NULL There are not enough resources available to retrieve the suported 769 languages. 770 @retval NULL The list of suported languages could not be retrieved. 771 @retval Other A pointer to the Null-terminated ASCII string of supported languages. 772 773 **/ 774 CHAR8 * 775 GetSupportedLanguages ( 776 IN EFI_HII_HANDLE HiiHandle 777 ) 778 { 779 EFI_STATUS Status; 780 UINTN LanguageSize; 781 CHAR8 TempSupportedLanguages; 782 CHAR8 *SupportedLanguages; 783 784 ASSERT (HiiHandle != NULL); 785 786 // 787 // Retrieve the size required for the supported languages buffer. 788 // 789 LanguageSize = 0; 790 Status = mPrivate.HiiString.GetLanguages (&mPrivate.HiiString, HiiHandle, &TempSupportedLanguages, &LanguageSize); 791 792 // 793 // If GetLanguages() returns EFI_SUCCESS for a zero size, 794 // then there are no supported languages registered for HiiHandle. If GetLanguages() 795 // returns an error other than EFI_BUFFER_TOO_SMALL, then HiiHandle is not present 796 // in the HII Database 797 // 798 if (Status != EFI_BUFFER_TOO_SMALL) { 799 // 800 // Return NULL if the size can not be retrieved, or if HiiHandle is not in the HII Database 801 // 802 return NULL; 803 } 804 805 // 806 // Allocate the supported languages buffer. 807 // 808 SupportedLanguages = AllocateZeroPool (LanguageSize); 809 if (SupportedLanguages == NULL) { 810 // 811 // Return NULL if allocation fails. 812 // 813 return NULL; 814 } 815 816 // 817 // Retrieve the supported languages string 818 // 819 Status = mPrivate.HiiString.GetLanguages (&mPrivate.HiiString, HiiHandle, SupportedLanguages, &LanguageSize); 820 if (EFI_ERROR (Status)) { 821 // 822 // Free the buffer and return NULL if the supported languages can not be retrieved. 823 // 824 FreePool (SupportedLanguages); 825 return NULL; 826 } 827 828 // 829 // Return the Null-terminated ASCII string of supported languages 830 // 831 return SupportedLanguages; 832 } 833 834 /** 835 Retrieves a string from a string package. 836 837 If HiiHandle is NULL, then ASSERT(). 838 If StringId is 0, then ASSET. 839 840 @param[in] HiiHandle A handle that was previously registered in the HII Database. 841 @param[in] StringId The identifier of the string to retrieved from the string 842 package associated with HiiHandle. 843 844 @retval NULL The string specified by StringId is not present in the string package. 845 @retval Other The string was returned. 846 847 **/ 848 EFI_STRING 849 InternalGetString ( 850 IN EFI_HII_HANDLE HiiHandle, 851 IN EFI_STRING_ID StringId 852 ) 853 { 854 EFI_STATUS Status; 855 UINTN StringSize; 856 CHAR16 TempString; 857 EFI_STRING String; 858 CHAR8 *SupportedLanguages; 859 CHAR8 *PlatformLanguage; 860 CHAR8 *BestLanguage; 861 CHAR8 *Language; 862 863 ASSERT (HiiHandle != NULL); 864 ASSERT (StringId != 0); 865 866 // 867 // Initialize all allocated buffers to NULL 868 // 869 SupportedLanguages = NULL; 870 PlatformLanguage = NULL; 871 BestLanguage = NULL; 872 String = NULL; 873 Language = ""; 874 875 // 876 // Get the languages that the package specified by HiiHandle supports 877 // 878 SupportedLanguages = GetSupportedLanguages (HiiHandle); 879 if (SupportedLanguages == NULL) { 880 goto Error; 881 } 882 883 // 884 // Get the current platform language setting 885 // 886 GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatformLanguage, NULL); 887 888 // 889 // Get the best matching language from SupportedLanguages 890 // 891 BestLanguage = GetBestLanguage ( 892 SupportedLanguages, 893 FALSE, // RFC 4646 mode 894 Language, // Highest priority 895 PlatformLanguage != NULL ? PlatformLanguage : "", // Next highest priority 896 SupportedLanguages, // Lowest priority 897 NULL 898 ); 899 if (BestLanguage == NULL) { 900 goto Error; 901 } 902 903 // 904 // Retrieve the size of the string in the string package for the BestLanguage 905 // 906 StringSize = 0; 907 Status = mPrivate.HiiString.GetString ( 908 &mPrivate.HiiString, 909 BestLanguage, 910 HiiHandle, 911 StringId, 912 &TempString, 913 &StringSize, 914 NULL 915 ); 916 // 917 // If GetString() returns EFI_SUCCESS for a zero size, 918 // then there are no supported languages registered for HiiHandle. If GetString() 919 // returns an error other than EFI_BUFFER_TOO_SMALL, then HiiHandle is not present 920 // in the HII Database 921 // 922 if (Status != EFI_BUFFER_TOO_SMALL) { 923 goto Error; 924 } 925 926 // 927 // Allocate a buffer for the return string 928 // 929 String = AllocateZeroPool (StringSize); 930 if (String == NULL) { 931 goto Error; 932 } 933 934 // 935 // Retrieve the string from the string package 936 // 937 Status = mPrivate.HiiString.GetString ( 938 &mPrivate.HiiString, 939 BestLanguage, 940 HiiHandle, 941 StringId, 942 String, 943 &StringSize, 944 NULL 945 ); 946 if (EFI_ERROR (Status)) { 947 // 948 // Free the buffer and return NULL if the supported languages can not be retrieved. 949 // 950 FreePool (String); 951 String = NULL; 952 } 953 954 Error: 955 // 956 // Free allocated buffers 957 // 958 if (SupportedLanguages != NULL) { 959 FreePool (SupportedLanguages); 960 } 961 if (PlatformLanguage != NULL) { 962 FreePool (PlatformLanguage); 963 } 964 if (BestLanguage != NULL) { 965 FreePool (BestLanguage); 966 } 967 968 // 969 // Return the Null-terminated Unicode string 970 // 971 return String; 972 } 973 974 /** 975 This function checks VarOffset and VarWidth is in the block range. 976 977 @param RequestBlockArray The block array is to be checked. 978 @param VarOffset Offset of var to the structure 979 @param VarWidth Width of var. 980 @param IsNameValueType Whether this varstore is name/value varstore or not. 981 @param HiiHandle Hii handle for this hii package. 982 983 @retval TRUE This Var is in the block range. 984 @retval FALSE This Var is not in the block range. 985 **/ 986 BOOLEAN 987 BlockArrayCheck ( 988 IN IFR_BLOCK_DATA *RequestBlockArray, 989 IN UINT16 VarOffset, 990 IN UINT16 VarWidth, 991 IN BOOLEAN IsNameValueType, 992 IN EFI_HII_HANDLE HiiHandle 993 ) 994 { 995 LIST_ENTRY *Link; 996 IFR_BLOCK_DATA *BlockData; 997 EFI_STRING Name; 998 999 // 1000 // No Request Block array, all vars are got. 1001 // 1002 if (RequestBlockArray == NULL) { 1003 return TRUE; 1004 } 1005 1006 // 1007 // Check the input var is in the request block range. 1008 // 1009 for (Link = RequestBlockArray->Entry.ForwardLink; Link != &RequestBlockArray->Entry; Link = Link->ForwardLink) { 1010 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry); 1011 1012 if (IsNameValueType) { 1013 Name = InternalGetString (HiiHandle, VarOffset); 1014 ASSERT (Name != NULL); 1015 1016 if (StrnCmp (BlockData->Name, Name, StrLen (Name)) == 0) { 1017 FreePool (Name); 1018 return TRUE; 1019 } 1020 FreePool (Name); 1021 } else { 1022 if ((VarOffset >= BlockData->Offset) && ((VarOffset + VarWidth) <= (BlockData->Offset + BlockData->Width))) { 1023 return TRUE; 1024 } 1025 } 1026 } 1027 1028 return FALSE; 1029 } 1030 1031 /** 1032 Get form package data from data base. 1033 1034 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package. 1035 @param HiiFormPackage The buffer saves the package data. 1036 @param PackageSize The buffer size of the package data. 1037 1038 **/ 1039 EFI_STATUS 1040 GetFormPackageData ( 1041 IN HII_DATABASE_RECORD *DataBaseRecord, 1042 IN OUT UINT8 **HiiFormPackage, 1043 OUT UINTN *PackageSize 1044 ) 1045 { 1046 EFI_STATUS Status; 1047 UINTN Size; 1048 UINTN ResultSize; 1049 1050 if (DataBaseRecord == NULL || HiiFormPackage == NULL || PackageSize == NULL) { 1051 return EFI_INVALID_PARAMETER; 1052 } 1053 1054 Size = 0; 1055 ResultSize = 0; 1056 // 1057 // 0. Get Hii Form Package by HiiHandle 1058 // 1059 Status = ExportFormPackages ( 1060 &mPrivate, 1061 DataBaseRecord->Handle, 1062 DataBaseRecord->PackageList, 1063 0, 1064 Size, 1065 HiiFormPackage, 1066 &ResultSize 1067 ); 1068 if (EFI_ERROR (Status)) { 1069 return Status; 1070 } 1071 1072 (*HiiFormPackage) = AllocatePool (ResultSize); 1073 if (*HiiFormPackage == NULL) { 1074 Status = EFI_OUT_OF_RESOURCES; 1075 return Status; 1076 } 1077 1078 // 1079 // Get HiiFormPackage by HiiHandle 1080 // 1081 Size = ResultSize; 1082 ResultSize = 0; 1083 Status = ExportFormPackages ( 1084 &mPrivate, 1085 DataBaseRecord->Handle, 1086 DataBaseRecord->PackageList, 1087 0, 1088 Size, 1089 *HiiFormPackage, 1090 &ResultSize 1091 ); 1092 if (EFI_ERROR (Status)) { 1093 FreePool (*HiiFormPackage); 1094 } 1095 1096 *PackageSize = Size; 1097 1098 return Status; 1099 } 1100 1101 1102 /** 1103 This function parses Form Package to get the efi varstore info according to the request ConfigHdr. 1104 1105 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package. 1106 @param ConfigHdr Request string ConfigHdr. If it is NULL, 1107 the first found varstore will be as ConfigHdr. 1108 @param IsEfiVarstore Whether the request storage type is efi varstore type. 1109 @param EfiVarStore The efi varstore info which will return. 1110 **/ 1111 EFI_STATUS 1112 GetVarStoreType ( 1113 IN HII_DATABASE_RECORD *DataBaseRecord, 1114 IN EFI_STRING ConfigHdr, 1115 OUT BOOLEAN *IsEfiVarstore, 1116 OUT EFI_IFR_VARSTORE_EFI **EfiVarStore 1117 ) 1118 { 1119 EFI_STATUS Status; 1120 UINTN IfrOffset; 1121 UINTN PackageOffset; 1122 EFI_IFR_OP_HEADER *IfrOpHdr; 1123 CHAR16 *VarStoreName; 1124 EFI_STRING GuidStr; 1125 EFI_STRING NameStr; 1126 EFI_STRING TempStr; 1127 UINTN LengthString; 1128 UINT8 *HiiFormPackage; 1129 UINTN PackageSize; 1130 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore; 1131 EFI_HII_PACKAGE_HEADER *PackageHeader; 1132 1133 HiiFormPackage = NULL; 1134 LengthString = 0; 1135 Status = EFI_SUCCESS; 1136 GuidStr = NULL; 1137 NameStr = NULL; 1138 TempStr = NULL; 1139 *IsEfiVarstore = FALSE; 1140 1141 Status = GetFormPackageData(DataBaseRecord, &HiiFormPackage, &PackageSize); 1142 if (EFI_ERROR (Status)) { 1143 return Status; 1144 } 1145 1146 IfrOffset = sizeof (EFI_HII_PACKAGE_HEADER); 1147 PackageOffset = IfrOffset; 1148 PackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiFormPackage; 1149 1150 while (IfrOffset < PackageSize) { 1151 // 1152 // More than one form packages exist. 1153 // 1154 if (PackageOffset >= PackageHeader->Length) { 1155 // 1156 // Process the new form package. 1157 // 1158 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER); 1159 IfrOffset += PackageOffset; 1160 PackageHeader = (EFI_HII_PACKAGE_HEADER *) (HiiFormPackage + IfrOffset); 1161 } 1162 1163 IfrOpHdr = (EFI_IFR_OP_HEADER *) (HiiFormPackage + IfrOffset); 1164 IfrOffset += IfrOpHdr->Length; 1165 PackageOffset += IfrOpHdr->Length; 1166 1167 if (IfrOpHdr->OpCode == EFI_IFR_VARSTORE_EFI_OP ) { 1168 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpHdr; 1169 // 1170 // If the length is small than the structure, this is from old efi 1171 // varstore definition. Old efi varstore get config directly from 1172 // GetVariable function. 1173 // 1174 if (IfrOpHdr->Length < sizeof (EFI_IFR_VARSTORE_EFI)) { 1175 continue; 1176 } 1177 1178 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name) * sizeof (CHAR16)); 1179 if (VarStoreName == NULL) { 1180 Status = EFI_OUT_OF_RESOURCES; 1181 goto Done; 1182 } 1183 AsciiStrToUnicodeStr ((CHAR8 *) IfrEfiVarStore->Name, VarStoreName); 1184 1185 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) &IfrEfiVarStore->Guid, 1, &GuidStr); 1186 GenerateSubStr (L"NAME=", StrLen (VarStoreName) * sizeof (CHAR16), (VOID *) VarStoreName, 2, &NameStr); 1187 LengthString = StrLen (GuidStr); 1188 LengthString = LengthString + StrLen (NameStr) + 1; 1189 TempStr = AllocateZeroPool (LengthString * sizeof (CHAR16)); 1190 if (TempStr == NULL) { 1191 FreePool (GuidStr); 1192 FreePool (NameStr); 1193 FreePool (VarStoreName); 1194 Status = EFI_OUT_OF_RESOURCES; 1195 goto Done; 1196 } 1197 StrCpyS (TempStr, LengthString, GuidStr); 1198 StrCatS (TempStr, LengthString, NameStr); 1199 if (ConfigHdr == NULL || StrnCmp (ConfigHdr, TempStr, StrLen (TempStr)) == 0) { 1200 *EfiVarStore = (EFI_IFR_VARSTORE_EFI *) AllocateZeroPool (IfrOpHdr->Length); 1201 if (*EfiVarStore == NULL) { 1202 FreePool (VarStoreName); 1203 FreePool (GuidStr); 1204 FreePool (NameStr); 1205 FreePool (TempStr); 1206 Status = EFI_OUT_OF_RESOURCES; 1207 goto Done; 1208 } 1209 *IsEfiVarstore = TRUE; 1210 CopyMem (*EfiVarStore, IfrEfiVarStore, IfrOpHdr->Length); 1211 } 1212 1213 // 1214 // Free alllocated temp string. 1215 // 1216 FreePool (VarStoreName); 1217 FreePool (GuidStr); 1218 FreePool (NameStr); 1219 FreePool (TempStr); 1220 1221 // 1222 // Already found the varstore, break; 1223 // 1224 if (*IsEfiVarstore) { 1225 break; 1226 } 1227 } 1228 } 1229 Done: 1230 if (HiiFormPackage != NULL) { 1231 FreePool (HiiFormPackage); 1232 } 1233 1234 return Status; 1235 } 1236 1237 /** 1238 Check whether the ConfigRequest string has the request elements. 1239 For EFI_HII_VARSTORE_BUFFER type, the request has "&OFFSET=****&WIDTH=****..." format. 1240 For EFI_HII_VARSTORE_NAME_VALUE type, the request has "&NAME1**&NAME2..." format. 1241 1242 @param ConfigRequest The input config request string. 1243 1244 @retval TRUE The input include config request elements. 1245 @retval FALSE The input string not includes. 1246 1247 **/ 1248 BOOLEAN 1249 GetElementsFromRequest ( 1250 IN EFI_STRING ConfigRequest 1251 ) 1252 { 1253 EFI_STRING TmpRequest; 1254 1255 TmpRequest = StrStr (ConfigRequest, L"PATH="); 1256 ASSERT (TmpRequest != NULL); 1257 1258 if ((StrStr (TmpRequest, L"&OFFSET=") != NULL) || (StrStr (TmpRequest, L"&") != NULL)) { 1259 return TRUE; 1260 } 1261 1262 return FALSE; 1263 } 1264 1265 /** 1266 Check whether the this varstore is the request varstore. 1267 1268 @param VarstoreGuid Varstore guid. 1269 @param Name Varstore name. 1270 @param ConfigHdr Current configRequest info. 1271 1272 @retval TRUE This varstore is the requst one. 1273 @retval FALSE This varstore is not the requst one. 1274 1275 **/ 1276 BOOLEAN 1277 IsThisVarstore ( 1278 IN EFI_GUID *VarstoreGuid, 1279 IN CHAR16 *Name, 1280 IN CHAR16 *ConfigHdr 1281 ) 1282 { 1283 EFI_STRING GuidStr; 1284 EFI_STRING NameStr; 1285 EFI_STRING TempStr; 1286 UINTN LengthString; 1287 BOOLEAN RetVal; 1288 1289 RetVal = FALSE; 1290 GuidStr = NULL; 1291 TempStr = NULL; 1292 1293 // 1294 // If ConfigHdr has name field and varstore not has name, return FALSE. 1295 // 1296 if (Name == NULL && ConfigHdr != NULL && StrStr (ConfigHdr, L"NAME=&") == NULL) { 1297 return FALSE; 1298 } 1299 1300 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *)VarstoreGuid, 1, &GuidStr); 1301 if (Name != NULL) { 1302 GenerateSubStr (L"NAME=", StrLen (Name) * sizeof (CHAR16), (VOID *) Name, 2, &NameStr); 1303 } else { 1304 GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr); 1305 } 1306 LengthString = StrLen (GuidStr); 1307 LengthString = LengthString + StrLen (NameStr) + 1; 1308 TempStr = AllocateZeroPool (LengthString * sizeof (CHAR16)); 1309 if (TempStr == NULL) { 1310 goto Done; 1311 } 1312 1313 StrCpyS (TempStr, LengthString, GuidStr); 1314 StrCatS (TempStr, LengthString, NameStr); 1315 1316 if (ConfigHdr == NULL || StrnCmp (ConfigHdr, TempStr, StrLen (TempStr)) == 0) { 1317 RetVal = TRUE; 1318 } 1319 1320 Done: 1321 if (GuidStr != NULL) { 1322 FreePool (GuidStr); 1323 } 1324 1325 if (NameStr != NULL) { 1326 FreePool (NameStr); 1327 } 1328 1329 if (TempStr != NULL) { 1330 FreePool (TempStr); 1331 } 1332 1333 return RetVal; 1334 } 1335 1336 /** 1337 This function parses Form Package to get the efi varstore info according to the request ConfigHdr. 1338 1339 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package. 1340 @param ConfigHdr Request string ConfigHdr. If it is NULL, 1341 the first found varstore will be as ConfigHdr. 1342 @retval TRUE This hii package is the reqeust one. 1343 @retval FALSE This hii package is not the reqeust one. 1344 **/ 1345 BOOLEAN 1346 IsThisPackageList ( 1347 IN HII_DATABASE_RECORD *DataBaseRecord, 1348 IN EFI_STRING ConfigHdr 1349 ) 1350 { 1351 EFI_STATUS Status; 1352 UINTN IfrOffset; 1353 UINTN PackageOffset; 1354 EFI_IFR_OP_HEADER *IfrOpHdr; 1355 CHAR16 *VarStoreName; 1356 UINT8 *HiiFormPackage; 1357 UINTN PackageSize; 1358 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore; 1359 EFI_HII_PACKAGE_HEADER *PackageHeader; 1360 EFI_IFR_VARSTORE *IfrVarStore; 1361 EFI_IFR_VARSTORE_NAME_VALUE *IfrNameValueVarStore; 1362 BOOLEAN FindVarstore; 1363 1364 HiiFormPackage = NULL; 1365 VarStoreName = NULL; 1366 Status = EFI_SUCCESS; 1367 FindVarstore = FALSE; 1368 1369 Status = GetFormPackageData(DataBaseRecord, &HiiFormPackage, &PackageSize); 1370 if (EFI_ERROR (Status)) { 1371 return FALSE; 1372 } 1373 1374 IfrOffset = sizeof (EFI_HII_PACKAGE_HEADER); 1375 PackageOffset = IfrOffset; 1376 PackageHeader = (EFI_HII_PACKAGE_HEADER *) HiiFormPackage; 1377 1378 while (IfrOffset < PackageSize) { 1379 // 1380 // More than one form packages exist. 1381 // 1382 if (PackageOffset >= PackageHeader->Length) { 1383 // 1384 // Process the new form package. 1385 // 1386 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER); 1387 IfrOffset += PackageOffset; 1388 PackageHeader = (EFI_HII_PACKAGE_HEADER *) (HiiFormPackage + IfrOffset); 1389 } 1390 1391 IfrOpHdr = (EFI_IFR_OP_HEADER *) (HiiFormPackage + IfrOffset); 1392 IfrOffset += IfrOpHdr->Length; 1393 PackageOffset += IfrOpHdr->Length; 1394 1395 switch (IfrOpHdr->OpCode) { 1396 1397 case EFI_IFR_VARSTORE_OP: 1398 IfrVarStore = (EFI_IFR_VARSTORE *) IfrOpHdr; 1399 1400 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)IfrVarStore->Name) * sizeof (CHAR16)); 1401 if (VarStoreName == NULL) { 1402 goto Done; 1403 } 1404 AsciiStrToUnicodeStr ((CHAR8 *)IfrVarStore->Name, VarStoreName); 1405 1406 if (IsThisVarstore((VOID *)&IfrVarStore->Guid, VarStoreName, ConfigHdr)) { 1407 FindVarstore = TRUE; 1408 goto Done; 1409 } 1410 break; 1411 1412 case EFI_IFR_VARSTORE_EFI_OP: 1413 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpHdr; 1414 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name) * sizeof (CHAR16)); 1415 if (VarStoreName == NULL) { 1416 goto Done; 1417 } 1418 AsciiStrToUnicodeStr ((CHAR8 *)IfrEfiVarStore->Name, VarStoreName); 1419 1420 if (IsThisVarstore (&IfrEfiVarStore->Guid, VarStoreName, ConfigHdr)) { 1421 FindVarstore = TRUE; 1422 goto Done; 1423 } 1424 break; 1425 1426 case EFI_IFR_VARSTORE_NAME_VALUE_OP: 1427 IfrNameValueVarStore = (EFI_IFR_VARSTORE_NAME_VALUE *) IfrOpHdr; 1428 1429 if (IsThisVarstore (&IfrNameValueVarStore->Guid, NULL, ConfigHdr)) { 1430 FindVarstore = TRUE; 1431 goto Done; 1432 } 1433 break; 1434 1435 case EFI_IFR_FORM_OP: 1436 case EFI_IFR_FORM_MAP_OP: 1437 // 1438 // No matched varstore is found and directly return. 1439 // 1440 goto Done; 1441 1442 default: 1443 break; 1444 } 1445 } 1446 Done: 1447 if (HiiFormPackage != NULL) { 1448 FreePool (HiiFormPackage); 1449 } 1450 1451 if (VarStoreName != NULL) { 1452 FreePool (VarStoreName); 1453 } 1454 1455 return FindVarstore; 1456 } 1457 1458 /** 1459 Check whether the this op code is required. 1460 1461 @param RequestBlockArray The array includes all the request info or NULL. 1462 @param HiiHandle The hii handle for this form package. 1463 @param VarStorageData The varstore data strucure. 1464 @param IfrOpHdr Ifr opcode header for this opcode. 1465 @param VarWidth The buffer width for this opcode. 1466 @param ReturnData The data block added for this opcode. 1467 1468 @retval EFI_SUCCESS This opcode is required. 1469 @retval Others This opcode is not required or error occur. 1470 1471 **/ 1472 EFI_STATUS 1473 IsThisOpcodeRequired ( 1474 IN IFR_BLOCK_DATA *RequestBlockArray, 1475 IN EFI_HII_HANDLE HiiHandle, 1476 IN OUT IFR_VARSTORAGE_DATA *VarStorageData, 1477 IN EFI_IFR_OP_HEADER *IfrOpHdr, 1478 IN UINT16 VarWidth, 1479 OUT IFR_BLOCK_DATA **ReturnData 1480 ) 1481 { 1482 IFR_BLOCK_DATA *BlockData; 1483 UINT16 VarOffset; 1484 EFI_STRING_ID NameId; 1485 EFI_IFR_QUESTION_HEADER *IfrQuestionHdr; 1486 1487 NameId = 0; 1488 VarOffset = 0; 1489 IfrQuestionHdr = (EFI_IFR_QUESTION_HEADER *)((CHAR8 *) IfrOpHdr + sizeof (EFI_IFR_OP_HEADER)); 1490 1491 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) { 1492 NameId = IfrQuestionHdr->VarStoreInfo.VarName; 1493 1494 // 1495 // Check whether this question is in requested block array. 1496 // 1497 if (!BlockArrayCheck (RequestBlockArray, NameId, 0, TRUE, HiiHandle)) { 1498 // 1499 // This question is not in the requested string. Skip it. 1500 // 1501 return EFI_SUCCESS; 1502 } 1503 } else { 1504 VarOffset = IfrQuestionHdr->VarStoreInfo.VarOffset; 1505 1506 // 1507 // Check whether this question is in requested block array. 1508 // 1509 if (!BlockArrayCheck (RequestBlockArray, VarOffset, VarWidth, FALSE, HiiHandle)) { 1510 // 1511 // This question is not in the requested string. Skip it. 1512 // 1513 return EFI_SUCCESS; 1514 } 1515 1516 // 1517 // Check this var question is in the var storage 1518 // 1519 if (((VarOffset + VarWidth) > VarStorageData->Size)) { 1520 return EFI_INVALID_PARAMETER; 1521 } 1522 } 1523 1524 BlockData = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA)); 1525 if (BlockData == NULL) { 1526 return EFI_OUT_OF_RESOURCES; 1527 } 1528 1529 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) { 1530 BlockData->Name = InternalGetString(HiiHandle, NameId); 1531 } else { 1532 BlockData->Offset = VarOffset; 1533 } 1534 1535 BlockData->Width = VarWidth; 1536 BlockData->QuestionId = IfrQuestionHdr->QuestionId; 1537 BlockData->OpCode = IfrOpHdr->OpCode; 1538 BlockData->Scope = IfrOpHdr->Scope; 1539 InitializeListHead (&BlockData->DefaultValueEntry); 1540 // 1541 // Add Block Data into VarStorageData BlockEntry 1542 // 1543 InsertBlockData (&VarStorageData->BlockEntry, &BlockData); 1544 *ReturnData = BlockData; 1545 1546 return EFI_SUCCESS; 1547 } 1548 1549 /** 1550 This function parses Form Package to get the block array and the default 1551 value array according to the request ConfigHdr. 1552 1553 @param HiiHandle Hii Handle for this hii package. 1554 @param Package Pointer to the form package data. 1555 @param PackageLength Length of the pacakge. 1556 @param ConfigHdr Request string ConfigHdr. If it is NULL, 1557 the first found varstore will be as ConfigHdr. 1558 @param RequestBlockArray The block array is retrieved from the request string. 1559 @param VarStorageData VarStorage structure contains the got block and default value. 1560 @param DefaultIdArray Point to the got default id and default name array. 1561 1562 @retval EFI_SUCCESS The block array and the default value array are got. 1563 @retval EFI_INVALID_PARAMETER The varstore defintion in the differnt form pacakges 1564 are conflicted. 1565 @retval EFI_OUT_OF_RESOURCES No enough memory. 1566 **/ 1567 EFI_STATUS 1568 EFIAPI 1569 ParseIfrData ( 1570 IN EFI_HII_HANDLE HiiHandle, 1571 IN UINT8 *Package, 1572 IN UINT32 PackageLength, 1573 IN EFI_STRING ConfigHdr, 1574 IN IFR_BLOCK_DATA *RequestBlockArray, 1575 IN OUT IFR_VARSTORAGE_DATA *VarStorageData, 1576 OUT IFR_DEFAULT_DATA *DefaultIdArray 1577 ) 1578 { 1579 EFI_STATUS Status; 1580 UINTN IfrOffset; 1581 UINTN PackageOffset; 1582 EFI_IFR_VARSTORE *IfrVarStore; 1583 EFI_IFR_VARSTORE_EFI *IfrEfiVarStore; 1584 EFI_IFR_OP_HEADER *IfrOpHdr; 1585 EFI_IFR_ONE_OF *IfrOneOf; 1586 EFI_IFR_REF4 *IfrRef; 1587 EFI_IFR_ONE_OF_OPTION *IfrOneOfOption; 1588 EFI_IFR_DEFAULT *IfrDefault; 1589 EFI_IFR_ORDERED_LIST *IfrOrderedList; 1590 EFI_IFR_CHECKBOX *IfrCheckBox; 1591 EFI_IFR_PASSWORD *IfrPassword; 1592 EFI_IFR_STRING *IfrString; 1593 EFI_IFR_DATE *IfrDate; 1594 EFI_IFR_TIME *IfrTime; 1595 IFR_DEFAULT_DATA DefaultData; 1596 IFR_DEFAULT_DATA *DefaultDataPtr; 1597 IFR_BLOCK_DATA *BlockData; 1598 CHAR16 *VarStoreName; 1599 UINT16 VarWidth; 1600 UINT16 VarDefaultId; 1601 BOOLEAN FirstOneOfOption; 1602 BOOLEAN FirstOrderedList; 1603 LIST_ENTRY *LinkData; 1604 LIST_ENTRY *LinkDefault; 1605 EFI_IFR_VARSTORE_NAME_VALUE *IfrNameValueVarStore; 1606 EFI_HII_PACKAGE_HEADER *PackageHeader; 1607 EFI_VARSTORE_ID VarStoreId; 1608 1609 Status = EFI_SUCCESS; 1610 BlockData = NULL; 1611 DefaultDataPtr = NULL; 1612 FirstOneOfOption = FALSE; 1613 VarStoreId = 0; 1614 FirstOrderedList = FALSE; 1615 ZeroMem (&DefaultData, sizeof (IFR_DEFAULT_DATA)); 1616 1617 // 1618 // Go through the form package to parse OpCode one by one. 1619 // 1620 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER); 1621 PackageHeader = (EFI_HII_PACKAGE_HEADER *) Package; 1622 IfrOffset = PackageOffset; 1623 while (IfrOffset < PackageLength) { 1624 1625 // 1626 // More than one form package found. 1627 // 1628 if (PackageOffset >= PackageHeader->Length) { 1629 // 1630 // Already found varstore for this request, break; 1631 // 1632 if (VarStoreId != 0) { 1633 VarStoreId = 0; 1634 } 1635 1636 // 1637 // Get next package header info. 1638 // 1639 IfrOffset += sizeof (EFI_HII_PACKAGE_HEADER); 1640 PackageOffset = sizeof (EFI_HII_PACKAGE_HEADER); 1641 PackageHeader = (EFI_HII_PACKAGE_HEADER *) (Package + IfrOffset); 1642 } 1643 1644 IfrOpHdr = (EFI_IFR_OP_HEADER *) (Package + IfrOffset); 1645 switch (IfrOpHdr->OpCode) { 1646 case EFI_IFR_VARSTORE_OP: 1647 // 1648 // VarStore is found. Don't need to search any more. 1649 // 1650 if (VarStoreId != 0) { 1651 break; 1652 } 1653 1654 IfrVarStore = (EFI_IFR_VARSTORE *) IfrOpHdr; 1655 1656 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)IfrVarStore->Name) * sizeof (CHAR16)); 1657 if (VarStoreName == NULL) { 1658 Status = EFI_OUT_OF_RESOURCES; 1659 goto Done; 1660 } 1661 AsciiStrToUnicodeStr ((CHAR8 *)IfrVarStore->Name, VarStoreName); 1662 1663 if (IsThisVarstore((VOID *)&IfrVarStore->Guid, VarStoreName, ConfigHdr)) { 1664 // 1665 // Find the matched VarStore 1666 // 1667 CopyGuid (&VarStorageData->Guid, (EFI_GUID *) (VOID *) &IfrVarStore->Guid); 1668 VarStorageData->Size = IfrVarStore->Size; 1669 VarStorageData->Name = VarStoreName; 1670 VarStorageData->Type = EFI_HII_VARSTORE_BUFFER; 1671 VarStoreId = IfrVarStore->VarStoreId; 1672 } 1673 break; 1674 1675 case EFI_IFR_VARSTORE_EFI_OP: 1676 // 1677 // VarStore is found. Don't need to search any more. 1678 // 1679 if (VarStoreId != 0) { 1680 break; 1681 } 1682 1683 IfrEfiVarStore = (EFI_IFR_VARSTORE_EFI *) IfrOpHdr; 1684 1685 // 1686 // If the length is small than the structure, this is from old efi 1687 // varstore definition. Old efi varstore get config directly from 1688 // GetVariable function. 1689 // 1690 if (IfrOpHdr->Length < sizeof (EFI_IFR_VARSTORE_EFI)) { 1691 break; 1692 } 1693 1694 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)IfrEfiVarStore->Name) * sizeof (CHAR16)); 1695 if (VarStoreName == NULL) { 1696 Status = EFI_OUT_OF_RESOURCES; 1697 goto Done; 1698 } 1699 AsciiStrToUnicodeStr ((CHAR8 *)IfrEfiVarStore->Name, VarStoreName); 1700 1701 if (IsThisVarstore (&IfrEfiVarStore->Guid, VarStoreName, ConfigHdr)) { 1702 // 1703 // Find the matched VarStore 1704 // 1705 CopyGuid (&VarStorageData->Guid, (EFI_GUID *) (VOID *) &IfrEfiVarStore->Guid); 1706 VarStorageData->Size = IfrEfiVarStore->Size; 1707 VarStorageData->Name = VarStoreName; 1708 VarStorageData->Type = EFI_HII_VARSTORE_EFI_VARIABLE_BUFFER; 1709 VarStoreId = IfrEfiVarStore->VarStoreId; 1710 } 1711 break; 1712 1713 case EFI_IFR_VARSTORE_NAME_VALUE_OP: 1714 // 1715 // VarStore is found. Don't need to search any more. 1716 // 1717 if (VarStoreId != 0) { 1718 break; 1719 } 1720 1721 IfrNameValueVarStore = (EFI_IFR_VARSTORE_NAME_VALUE *) IfrOpHdr; 1722 1723 if (IsThisVarstore (&IfrNameValueVarStore->Guid, NULL, ConfigHdr)) { 1724 // 1725 // Find the matched VarStore 1726 // 1727 CopyGuid (&VarStorageData->Guid, (EFI_GUID *) (VOID *) &IfrNameValueVarStore->Guid); 1728 VarStorageData->Type = EFI_HII_VARSTORE_NAME_VALUE; 1729 VarStoreId = IfrNameValueVarStore->VarStoreId; 1730 } 1731 break; 1732 1733 case EFI_IFR_DEFAULTSTORE_OP: 1734 // 1735 // Add new the map between default id and default name. 1736 // 1737 DefaultDataPtr = (IFR_DEFAULT_DATA *) AllocateZeroPool (sizeof (IFR_DEFAULT_DATA)); 1738 if (DefaultDataPtr == NULL) { 1739 Status = EFI_OUT_OF_RESOURCES; 1740 goto Done; 1741 } 1742 DefaultDataPtr->DefaultId = ((EFI_IFR_DEFAULTSTORE *) IfrOpHdr)->DefaultId; 1743 InsertTailList (&DefaultIdArray->Entry, &DefaultDataPtr->Entry); 1744 DefaultDataPtr = NULL; 1745 break; 1746 1747 case EFI_IFR_FORM_OP: 1748 case EFI_IFR_FORM_MAP_OP: 1749 // 1750 // No matched varstore is found and directly return. 1751 // 1752 if ( VarStoreId == 0) { 1753 Status = EFI_SUCCESS; 1754 goto Done; 1755 } 1756 break; 1757 1758 case EFI_IFR_REF_OP: 1759 // 1760 // Ref question is not in IFR Form. This IFR form is not valid. 1761 // 1762 if ( VarStoreId == 0) { 1763 Status = EFI_INVALID_PARAMETER; 1764 goto Done; 1765 } 1766 // 1767 // Check whether this question is for the requested varstore. 1768 // 1769 IfrRef = (EFI_IFR_REF4 *) IfrOpHdr; 1770 if (IfrRef->Question.VarStoreId != VarStoreId) { 1771 break; 1772 } 1773 VarWidth = (UINT16) (sizeof (EFI_HII_REF)); 1774 1775 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 1776 if (EFI_ERROR (Status)) { 1777 goto Done; 1778 } 1779 break; 1780 1781 case EFI_IFR_ONE_OF_OP: 1782 case EFI_IFR_NUMERIC_OP: 1783 // 1784 // Numeric and OneOf has the same opcode structure. 1785 // 1786 1787 // 1788 // Numeric and OneOf question is not in IFR Form. This IFR form is not valid. 1789 // 1790 if (VarStoreId == 0) { 1791 Status = EFI_INVALID_PARAMETER; 1792 goto Done; 1793 } 1794 // 1795 // Check whether this question is for the requested varstore. 1796 // 1797 IfrOneOf = (EFI_IFR_ONE_OF *) IfrOpHdr; 1798 if (IfrOneOf->Question.VarStoreId != VarStoreId) { 1799 break; 1800 } 1801 VarWidth = (UINT16) (1 << (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE)); 1802 1803 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 1804 if (EFI_ERROR (Status)) { 1805 goto Done; 1806 } 1807 1808 if (BlockData == NULL) { 1809 // 1810 // BlockData == NULL means this opcode is not in the requst array. 1811 // 1812 break; 1813 } 1814 1815 if (IfrOpHdr->OpCode == EFI_IFR_ONE_OF_OP) { 1816 // 1817 // Set this flag to TRUE for the first oneof option. 1818 // 1819 FirstOneOfOption = TRUE; 1820 } else if (IfrOpHdr->OpCode == EFI_IFR_NUMERIC_OP) { 1821 // 1822 // Numeric minimum value will be used as default value when no default is specified. 1823 // 1824 DefaultData.Type = DefaultValueFromDefault; 1825 switch (IfrOneOf->Flags & EFI_IFR_NUMERIC_SIZE) { 1826 case EFI_IFR_NUMERIC_SIZE_1: 1827 DefaultData.Value.u8 = IfrOneOf->data.u8.MinValue; 1828 break; 1829 1830 case EFI_IFR_NUMERIC_SIZE_2: 1831 CopyMem (&DefaultData.Value.u16, &IfrOneOf->data.u16.MinValue, sizeof (UINT16)); 1832 break; 1833 1834 case EFI_IFR_NUMERIC_SIZE_4: 1835 CopyMem (&DefaultData.Value.u32, &IfrOneOf->data.u32.MinValue, sizeof (UINT32)); 1836 break; 1837 1838 case EFI_IFR_NUMERIC_SIZE_8: 1839 CopyMem (&DefaultData.Value.u64, &IfrOneOf->data.u64.MinValue, sizeof (UINT64)); 1840 break; 1841 1842 default: 1843 Status = EFI_INVALID_PARAMETER; 1844 goto Done; 1845 } 1846 // 1847 // Set default value base on the DefaultId list get from IFR data. 1848 // 1849 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) { 1850 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry); 1851 DefaultData.DefaultId = DefaultDataPtr->DefaultId; 1852 InsertDefaultValue (BlockData, &DefaultData); 1853 } 1854 } 1855 break; 1856 1857 case EFI_IFR_ORDERED_LIST_OP: 1858 // 1859 // offset by question header 1860 // width by EFI_IFR_ORDERED_LIST MaxContainers * OneofOption Type 1861 // 1862 1863 FirstOrderedList = TRUE; 1864 // 1865 // OrderedList question is not in IFR Form. This IFR form is not valid. 1866 // 1867 if (VarStoreId == 0) { 1868 Status = EFI_INVALID_PARAMETER; 1869 goto Done; 1870 } 1871 // 1872 // Check whether this question is for the requested varstore. 1873 // 1874 IfrOrderedList = (EFI_IFR_ORDERED_LIST *) IfrOpHdr; 1875 if (IfrOrderedList->Question.VarStoreId != VarStoreId) { 1876 BlockData = NULL; 1877 break; 1878 } 1879 VarWidth = IfrOrderedList->MaxContainers; 1880 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 1881 if (EFI_ERROR (Status)) { 1882 goto Done; 1883 } 1884 break; 1885 1886 case EFI_IFR_CHECKBOX_OP: 1887 // 1888 // EFI_IFR_DEFAULT_OP 1889 // offset by question header 1890 // width is 1 sizeof (BOOLEAN) 1891 // default id by CheckBox Flags if CheckBox flags (Default or Mau) is set, the default value is 1 to be set. 1892 // value by DefaultOption 1893 // default id by DeaultOption DefaultId can override CheckBox Flags and Default value. 1894 // 1895 1896 // 1897 // CheckBox question is not in IFR Form. This IFR form is not valid. 1898 // 1899 if (VarStoreId == 0) { 1900 Status = EFI_INVALID_PARAMETER; 1901 goto Done; 1902 } 1903 // 1904 // Check whether this question is for the requested varstore. 1905 // 1906 IfrCheckBox = (EFI_IFR_CHECKBOX *) IfrOpHdr; 1907 if (IfrCheckBox->Question.VarStoreId != VarStoreId) { 1908 break; 1909 } 1910 VarWidth = (UINT16) sizeof (BOOLEAN); 1911 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 1912 if (EFI_ERROR (Status)) { 1913 goto Done; 1914 } 1915 1916 if (BlockData == NULL) { 1917 // 1918 // BlockData == NULL means this opcode is not in the requst array. 1919 // 1920 break; 1921 } 1922 1923 // 1924 // Add default value for standard ID by CheckBox Flag 1925 // 1926 VarDefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; 1927 // 1928 // Prepare new DefaultValue 1929 // 1930 DefaultData.DefaultId = VarDefaultId; 1931 if ((IfrCheckBox->Flags & EFI_IFR_CHECKBOX_DEFAULT) == EFI_IFR_CHECKBOX_DEFAULT) { 1932 // 1933 // When flag is set, defautl value is TRUE. 1934 // 1935 DefaultData.Type = DefaultValueFromFlag; 1936 DefaultData.Value.b = TRUE; 1937 } else { 1938 // 1939 // When flag is not set, defautl value is FASLE. 1940 // 1941 DefaultData.Type = DefaultValueFromDefault; 1942 DefaultData.Value.b = FALSE; 1943 } 1944 // 1945 // Add DefaultValue into current BlockData 1946 // 1947 InsertDefaultValue (BlockData, &DefaultData); 1948 1949 // 1950 // Add default value for Manufacture ID by CheckBox Flag 1951 // 1952 VarDefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING; 1953 // 1954 // Prepare new DefaultValue 1955 // 1956 DefaultData.DefaultId = VarDefaultId; 1957 if ((IfrCheckBox->Flags & EFI_IFR_CHECKBOX_DEFAULT_MFG) == EFI_IFR_CHECKBOX_DEFAULT_MFG) { 1958 // 1959 // When flag is set, defautl value is TRUE. 1960 // 1961 DefaultData.Type = DefaultValueFromFlag; 1962 DefaultData.Value.b = TRUE; 1963 } else { 1964 // 1965 // When flag is not set, defautl value is FASLE. 1966 // 1967 DefaultData.Type = DefaultValueFromDefault; 1968 DefaultData.Value.b = FALSE; 1969 } 1970 // 1971 // Add DefaultValue into current BlockData 1972 // 1973 InsertDefaultValue (BlockData, &DefaultData); 1974 break; 1975 1976 case EFI_IFR_DATE_OP: 1977 // 1978 // offset by question header 1979 // width MaxSize * sizeof (CHAR16) 1980 // no default value, only block array 1981 // 1982 1983 // 1984 // Date question is not in IFR Form. This IFR form is not valid. 1985 // 1986 if (VarStoreId == 0) { 1987 Status = EFI_INVALID_PARAMETER; 1988 goto Done; 1989 } 1990 // 1991 // Check whether this question is for the requested varstore. 1992 // 1993 IfrDate = (EFI_IFR_DATE *) IfrOpHdr; 1994 if (IfrDate->Question.VarStoreId != VarStoreId) { 1995 break; 1996 } 1997 1998 VarWidth = (UINT16) sizeof (EFI_HII_DATE); 1999 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 2000 if (EFI_ERROR (Status)) { 2001 goto Done; 2002 } 2003 break; 2004 2005 case EFI_IFR_TIME_OP: 2006 // 2007 // offset by question header 2008 // width MaxSize * sizeof (CHAR16) 2009 // no default value, only block array 2010 // 2011 2012 // 2013 // Time question is not in IFR Form. This IFR form is not valid. 2014 // 2015 if (VarStoreId == 0) { 2016 Status = EFI_INVALID_PARAMETER; 2017 goto Done; 2018 } 2019 // 2020 // Check whether this question is for the requested varstore. 2021 // 2022 IfrTime = (EFI_IFR_TIME *) IfrOpHdr; 2023 if (IfrTime->Question.VarStoreId != VarStoreId) { 2024 break; 2025 } 2026 2027 VarWidth = (UINT16) sizeof (EFI_HII_TIME); 2028 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 2029 if (EFI_ERROR (Status)) { 2030 goto Done; 2031 } 2032 break; 2033 2034 case EFI_IFR_STRING_OP: 2035 // 2036 // offset by question header 2037 // width MaxSize * sizeof (CHAR16) 2038 // no default value, only block array 2039 // 2040 2041 // 2042 // String question is not in IFR Form. This IFR form is not valid. 2043 // 2044 if (VarStoreId == 0) { 2045 Status = EFI_INVALID_PARAMETER; 2046 goto Done; 2047 } 2048 // 2049 // Check whether this question is for the requested varstore. 2050 // 2051 IfrString = (EFI_IFR_STRING *) IfrOpHdr; 2052 if (IfrString->Question.VarStoreId != VarStoreId) { 2053 break; 2054 } 2055 2056 VarWidth = (UINT16) (IfrString->MaxSize * sizeof (UINT16)); 2057 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 2058 if (EFI_ERROR (Status)) { 2059 goto Done; 2060 } 2061 break; 2062 2063 case EFI_IFR_PASSWORD_OP: 2064 // 2065 // offset by question header 2066 // width MaxSize * sizeof (CHAR16) 2067 // no default value, only block array 2068 // 2069 2070 // 2071 // Password question is not in IFR Form. This IFR form is not valid. 2072 // 2073 if (VarStoreId == 0) { 2074 Status = EFI_INVALID_PARAMETER; 2075 goto Done; 2076 } 2077 // 2078 // Check whether this question is for the requested varstore. 2079 // 2080 IfrPassword = (EFI_IFR_PASSWORD *) IfrOpHdr; 2081 if (IfrPassword->Question.VarStoreId != VarStoreId) { 2082 break; 2083 } 2084 2085 VarWidth = (UINT16) (IfrPassword->MaxSize * sizeof (UINT16)); 2086 Status = IsThisOpcodeRequired(RequestBlockArray, HiiHandle, VarStorageData, IfrOpHdr, VarWidth, &BlockData); 2087 if (EFI_ERROR (Status)) { 2088 goto Done; 2089 } 2090 2091 // 2092 // No default value for string. 2093 // 2094 BlockData = NULL; 2095 break; 2096 2097 case EFI_IFR_ONE_OF_OPTION_OP: 2098 // 2099 // No matched block data is ignored. 2100 // 2101 if (BlockData == NULL || BlockData->Scope == 0) { 2102 break; 2103 } 2104 2105 IfrOneOfOption = (EFI_IFR_ONE_OF_OPTION *) IfrOpHdr; 2106 if (BlockData->OpCode == EFI_IFR_ORDERED_LIST_OP) { 2107 2108 if (!FirstOrderedList){ 2109 break; 2110 } 2111 // 2112 // Get ordered list option data type. 2113 // 2114 if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_8 || IfrOneOfOption->Type == EFI_IFR_TYPE_BOOLEAN) { 2115 VarWidth = 1; 2116 } else if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_16) { 2117 VarWidth = 2; 2118 } else if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_32) { 2119 VarWidth = 4; 2120 } else if (IfrOneOfOption->Type == EFI_IFR_TYPE_NUM_SIZE_64) { 2121 VarWidth = 8; 2122 } else { 2123 // 2124 // Invalid ordered list option data type. 2125 // 2126 Status = EFI_INVALID_PARAMETER; 2127 if (BlockData->Name != NULL) { 2128 FreePool (BlockData->Name); 2129 } 2130 FreePool (BlockData); 2131 goto Done; 2132 } 2133 2134 // 2135 // Calculate Ordered list QuestionId width. 2136 // 2137 BlockData->Width = (UINT16) (BlockData->Width * VarWidth); 2138 // 2139 // Check whether this question is in requested block array. 2140 // 2141 if (!BlockArrayCheck (RequestBlockArray, BlockData->Offset, BlockData->Width, (BOOLEAN)(BlockData->Name != NULL), HiiHandle)) { 2142 // 2143 // This question is not in the requested string. Skip it. 2144 // 2145 if (BlockData->Name != NULL) { 2146 FreePool (BlockData->Name); 2147 } 2148 FreePool (BlockData); 2149 BlockData = NULL; 2150 break; 2151 } 2152 // 2153 // Check this var question is in the var storage 2154 // 2155 if ((BlockData->Name == NULL) && ((BlockData->Offset + BlockData->Width) > VarStorageData->Size)) { 2156 Status = EFI_INVALID_PARAMETER; 2157 if (BlockData->Name != NULL) { 2158 FreePool (BlockData->Name); 2159 } 2160 FreePool (BlockData); 2161 goto Done; 2162 } 2163 // 2164 // Add Block Data into VarStorageData BlockEntry 2165 // 2166 InsertBlockData (&VarStorageData->BlockEntry, &BlockData); 2167 2168 FirstOrderedList = FALSE; 2169 2170 break; 2171 } 2172 2173 // 2174 // 1. Set default value for OneOf option when flag field has default attribute. 2175 // 2176 if (((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT) == EFI_IFR_OPTION_DEFAULT) || 2177 ((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT_MFG) == EFI_IFR_OPTION_DEFAULT_MFG)) { 2178 // 2179 // This flag is used to specify whether this option is the first. Set it to FALSE for the following options. 2180 // The first oneof option value will be used as default value when no default value is specified. 2181 // 2182 FirstOneOfOption = FALSE; 2183 2184 // Prepare new DefaultValue 2185 // 2186 DefaultData.Type = DefaultValueFromFlag; 2187 CopyMem (&DefaultData.Value, &IfrOneOfOption->Value, IfrOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value)); 2188 if ((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT) == EFI_IFR_OPTION_DEFAULT) { 2189 DefaultData.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; 2190 InsertDefaultValue (BlockData, &DefaultData); 2191 } 2192 if ((IfrOneOfOption->Flags & EFI_IFR_OPTION_DEFAULT_MFG) == EFI_IFR_OPTION_DEFAULT_MFG) { 2193 DefaultData.DefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING; 2194 InsertDefaultValue (BlockData, &DefaultData); 2195 } 2196 } 2197 2198 // 2199 // 2. Set as the default value when this is the first option. 2200 // The first oneof option value will be used as default value when no default value is specified. 2201 // 2202 if (FirstOneOfOption) { 2203 // This flag is used to specify whether this option is the first. Set it to FALSE for the following options. 2204 FirstOneOfOption = FALSE; 2205 2206 // 2207 // Prepare new DefaultValue 2208 // 2209 DefaultData.Type = DefaultValueFromDefault; 2210 CopyMem (&DefaultData.Value, &IfrOneOfOption->Value, IfrOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value)); 2211 for (LinkData = DefaultIdArray->Entry.ForwardLink; LinkData != &DefaultIdArray->Entry; LinkData = LinkData->ForwardLink) { 2212 DefaultDataPtr = BASE_CR (LinkData, IFR_DEFAULT_DATA, Entry); 2213 DefaultData.DefaultId = DefaultDataPtr->DefaultId; 2214 InsertDefaultValue (BlockData, &DefaultData); 2215 } 2216 } 2217 break; 2218 2219 case EFI_IFR_DEFAULT_OP: 2220 // 2221 // Update Current BlockData to the default value. 2222 // 2223 if (BlockData == NULL || BlockData->Scope == 0) { 2224 // 2225 // No matched block data is ignored. 2226 // 2227 break; 2228 } 2229 2230 // 2231 // Get the DefaultId 2232 // 2233 IfrDefault = (EFI_IFR_DEFAULT *) IfrOpHdr; 2234 VarDefaultId = IfrDefault->DefaultId; 2235 // 2236 // Prepare new DefaultValue 2237 // 2238 DefaultData.Type = DefaultValueFromOpcode; 2239 DefaultData.DefaultId = VarDefaultId; 2240 CopyMem (&DefaultData.Value, &IfrDefault->Value, IfrDefault->Header.Length - OFFSET_OF (EFI_IFR_DEFAULT, Value)); 2241 2242 // If the value field is expression, set the cleaned flag. 2243 if (IfrDefault->Type == EFI_IFR_TYPE_OTHER) { 2244 DefaultData.Cleaned = TRUE; 2245 } 2246 // 2247 // Add DefaultValue into current BlockData 2248 // 2249 InsertDefaultValue (BlockData, &DefaultData); 2250 2251 // 2252 // After insert the default value, reset the cleaned value for next 2253 // time used. If not set here, need to set the value before everytime 2254 // use it. 2255 // 2256 DefaultData.Cleaned = FALSE; 2257 break; 2258 2259 case EFI_IFR_END_OP: 2260 // 2261 // End Opcode is for Var question. 2262 // 2263 if (BlockData != NULL) { 2264 if (BlockData->Scope > 0) { 2265 BlockData->Scope--; 2266 } 2267 if (BlockData->Scope == 0) { 2268 BlockData = NULL; 2269 } 2270 } 2271 2272 break; 2273 2274 default: 2275 if (BlockData != NULL) { 2276 if (BlockData->Scope > 0) { 2277 BlockData->Scope = (UINT8) (BlockData->Scope + IfrOpHdr->Scope); 2278 } 2279 2280 if (BlockData->Scope == 0) { 2281 BlockData = NULL; 2282 } 2283 } 2284 break; 2285 } 2286 2287 IfrOffset += IfrOpHdr->Length; 2288 PackageOffset += IfrOpHdr->Length; 2289 } 2290 2291 Done: 2292 for (LinkData = VarStorageData->BlockEntry.ForwardLink; LinkData != &VarStorageData->BlockEntry; LinkData = LinkData->ForwardLink) { 2293 BlockData = BASE_CR (LinkData, IFR_BLOCK_DATA, Entry); 2294 for (LinkDefault = BlockData->DefaultValueEntry.ForwardLink; LinkDefault != &BlockData->DefaultValueEntry; ) { 2295 DefaultDataPtr = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry); 2296 LinkDefault = LinkDefault->ForwardLink; 2297 if (DefaultDataPtr->Cleaned == TRUE) { 2298 RemoveEntryList (&DefaultDataPtr->Entry); 2299 FreePool (DefaultDataPtr); 2300 } 2301 } 2302 } 2303 2304 return Status; 2305 } 2306 2307 /** 2308 parse the configrequest string, get the elements. 2309 2310 @param ConfigRequest The input configrequest string. 2311 @param Progress Return the progress data. 2312 2313 @retval Block data pointer. 2314 **/ 2315 IFR_BLOCK_DATA * 2316 GetBlockElement ( 2317 IN EFI_STRING ConfigRequest, 2318 OUT EFI_STRING *Progress 2319 ) 2320 { 2321 EFI_STRING StringPtr; 2322 IFR_BLOCK_DATA *BlockData; 2323 IFR_BLOCK_DATA *RequestBlockArray; 2324 EFI_STATUS Status; 2325 UINT8 *TmpBuffer; 2326 UINT16 Offset; 2327 UINT16 Width; 2328 LIST_ENTRY *Link; 2329 IFR_BLOCK_DATA *NextBlockData; 2330 UINTN Length; 2331 2332 TmpBuffer = NULL; 2333 2334 // 2335 // Init RequestBlockArray 2336 // 2337 RequestBlockArray = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA)); 2338 if (RequestBlockArray == NULL) { 2339 goto Done; 2340 } 2341 InitializeListHead (&RequestBlockArray->Entry); 2342 2343 // 2344 // Get the request Block array from the request string 2345 // Offset and Width 2346 // 2347 2348 // 2349 // Parse each <RequestElement> if exists 2350 // Only <BlockName> format is supported by this help function. 2351 // <BlockName> ::= &'OFFSET='<Number>&'WIDTH='<Number> 2352 // 2353 StringPtr = ConfigRequest; 2354 while (*StringPtr != 0 && StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) == 0) { 2355 // 2356 // Skip the OFFSET string 2357 // 2358 *Progress = StringPtr; 2359 StringPtr += StrLen (L"&OFFSET="); 2360 // 2361 // Get Offset 2362 // 2363 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 2364 if (EFI_ERROR (Status)) { 2365 goto Done; 2366 } 2367 Offset = 0; 2368 CopyMem ( 2369 &Offset, 2370 TmpBuffer, 2371 (((Length + 1) / 2) < sizeof (UINT16)) ? ((Length + 1) / 2) : sizeof (UINT16) 2372 ); 2373 FreePool (TmpBuffer); 2374 2375 StringPtr += Length; 2376 if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) { 2377 goto Done; 2378 } 2379 StringPtr += StrLen (L"&WIDTH="); 2380 2381 // 2382 // Get Width 2383 // 2384 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 2385 if (EFI_ERROR (Status)) { 2386 goto Done; 2387 } 2388 Width = 0; 2389 CopyMem ( 2390 &Width, 2391 TmpBuffer, 2392 (((Length + 1) / 2) < sizeof (UINT16)) ? ((Length + 1) / 2) : sizeof (UINT16) 2393 ); 2394 FreePool (TmpBuffer); 2395 2396 StringPtr += Length; 2397 if (*StringPtr != 0 && *StringPtr != L'&') { 2398 goto Done; 2399 } 2400 2401 // 2402 // Set Block Data 2403 // 2404 BlockData = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA)); 2405 if (BlockData == NULL) { 2406 goto Done; 2407 } 2408 BlockData->Offset = Offset; 2409 BlockData->Width = Width; 2410 InsertBlockData (&RequestBlockArray->Entry, &BlockData); 2411 2412 // 2413 // Skip &VALUE string if &VALUE does exists. 2414 // 2415 if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) == 0) { 2416 StringPtr += StrLen (L"&VALUE="); 2417 2418 // 2419 // Get Value 2420 // 2421 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 2422 if (EFI_ERROR (Status)) { 2423 goto Done; 2424 } 2425 2426 StringPtr += Length; 2427 if (*StringPtr != 0 && *StringPtr != L'&') { 2428 goto Done; 2429 } 2430 } 2431 // 2432 // If '\0', parsing is finished. 2433 // 2434 if (*StringPtr == 0) { 2435 break; 2436 } 2437 } 2438 2439 // 2440 // Merge the requested block data. 2441 // 2442 Link = RequestBlockArray->Entry.ForwardLink; 2443 while ((Link != &RequestBlockArray->Entry) && (Link->ForwardLink != &RequestBlockArray->Entry)) { 2444 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry); 2445 NextBlockData = BASE_CR (Link->ForwardLink, IFR_BLOCK_DATA, Entry); 2446 if ((NextBlockData->Offset >= BlockData->Offset) && (NextBlockData->Offset <= (BlockData->Offset + BlockData->Width))) { 2447 if ((NextBlockData->Offset + NextBlockData->Width) > (BlockData->Offset + BlockData->Width)) { 2448 BlockData->Width = (UINT16) (NextBlockData->Offset + NextBlockData->Width - BlockData->Offset); 2449 } 2450 RemoveEntryList (Link->ForwardLink); 2451 FreePool (NextBlockData); 2452 continue; 2453 } 2454 Link = Link->ForwardLink; 2455 } 2456 2457 return RequestBlockArray; 2458 2459 Done: 2460 if (RequestBlockArray != NULL) { 2461 // 2462 // Free Link Array RequestBlockArray 2463 // 2464 while (!IsListEmpty (&RequestBlockArray->Entry)) { 2465 BlockData = BASE_CR (RequestBlockArray->Entry.ForwardLink, IFR_BLOCK_DATA, Entry); 2466 RemoveEntryList (&BlockData->Entry); 2467 FreePool (BlockData); 2468 } 2469 2470 FreePool (RequestBlockArray); 2471 } 2472 2473 return NULL; 2474 } 2475 2476 /** 2477 parse the configrequest string, get the elements. 2478 2479 @param ConfigRequest The input config request string. 2480 @param Progress Return the progress data. 2481 2482 @retval return data block array. 2483 **/ 2484 IFR_BLOCK_DATA * 2485 GetNameElement ( 2486 IN EFI_STRING ConfigRequest, 2487 OUT EFI_STRING *Progress 2488 ) 2489 { 2490 EFI_STRING StringPtr; 2491 EFI_STRING NextTag; 2492 IFR_BLOCK_DATA *BlockData; 2493 IFR_BLOCK_DATA *RequestBlockArray; 2494 BOOLEAN HasValue; 2495 2496 StringPtr = ConfigRequest; 2497 2498 // 2499 // Init RequestBlockArray 2500 // 2501 RequestBlockArray = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA)); 2502 if (RequestBlockArray == NULL) { 2503 goto Done; 2504 } 2505 InitializeListHead (&RequestBlockArray->Entry); 2506 2507 // 2508 // Get the request Block array from the request string 2509 // 2510 2511 // 2512 // Parse each <RequestElement> if exists 2513 // Only <BlockName> format is supported by this help function. 2514 // <BlockName> ::= &'Name***=*** 2515 // 2516 while (StringPtr != NULL && *StringPtr == L'&') { 2517 2518 *Progress = StringPtr; 2519 // 2520 // Skip the L"&" string 2521 // 2522 StringPtr += 1; 2523 2524 HasValue = FALSE; 2525 if ((NextTag = StrStr (StringPtr, L"=")) != NULL) { 2526 *NextTag = L'\0'; 2527 HasValue = TRUE; 2528 } else if ((NextTag = StrStr (StringPtr, L"&")) != NULL) { 2529 *NextTag = L'\0'; 2530 } 2531 2532 // 2533 // Set Block Data 2534 // 2535 BlockData = (IFR_BLOCK_DATA *) AllocateZeroPool (sizeof (IFR_BLOCK_DATA)); 2536 if (BlockData == NULL) { 2537 goto Done; 2538 } 2539 2540 // 2541 // Get Name 2542 // 2543 BlockData->Name = AllocateCopyPool(StrSize (StringPtr), StringPtr); 2544 InsertBlockData (&RequestBlockArray->Entry, &BlockData); 2545 2546 if (HasValue) { 2547 // 2548 // If has value, skip the value. 2549 // 2550 StringPtr = NextTag + 1; 2551 *NextTag = L'='; 2552 StringPtr = StrStr (StringPtr, L"&"); 2553 } else if (NextTag != NULL) { 2554 // 2555 // restore the '&' text. 2556 // 2557 StringPtr = NextTag; 2558 *NextTag = L'&'; 2559 } 2560 } 2561 2562 return RequestBlockArray; 2563 2564 Done: 2565 if (RequestBlockArray != NULL) { 2566 // 2567 // Free Link Array RequestBlockArray 2568 // 2569 while (!IsListEmpty (&RequestBlockArray->Entry)) { 2570 BlockData = BASE_CR (RequestBlockArray->Entry.ForwardLink, IFR_BLOCK_DATA, Entry); 2571 RemoveEntryList (&BlockData->Entry); 2572 if (BlockData->Name != NULL) { 2573 FreePool (BlockData->Name); 2574 } 2575 FreePool (BlockData); 2576 } 2577 2578 FreePool (RequestBlockArray); 2579 } 2580 2581 return NULL; 2582 } 2583 2584 /** 2585 Generate ConfigRequest string base on the varstore info. 2586 2587 @param ConfigHdr The config header for this varstore. 2588 @param VarStorageData The varstore info. 2589 @param Status Return Status. 2590 @param ConfigRequest The ConfigRequest info may be return. 2591 2592 @retval TRUE Need to continue 2593 @retval Others NO need to continue or error occur. 2594 **/ 2595 BOOLEAN 2596 GenerateConfigRequest ( 2597 IN CHAR16 *ConfigHdr, 2598 IN IFR_VARSTORAGE_DATA *VarStorageData, 2599 OUT EFI_STATUS *Status, 2600 IN OUT EFI_STRING *ConfigRequest 2601 ) 2602 { 2603 BOOLEAN DataExist; 2604 UINTN Length; 2605 LIST_ENTRY *Link; 2606 CHAR16 *FullConfigRequest; 2607 CHAR16 *StringPtr; 2608 IFR_BLOCK_DATA *BlockData; 2609 2610 // 2611 // Append VarStorageData BlockEntry into *Request string 2612 // Now support only one varstore in a form package. 2613 // 2614 2615 // 2616 // Go through all VarStorageData Entry and get BlockEntry for each one for the multiple varstore in a single form package 2617 // Then construct them all to return MultiRequest string : ConfigHdr BlockConfig 2618 // 2619 2620 // 2621 // Compute the length of the entire request starting with <ConfigHdr> and a 2622 // Null-terminator 2623 // 2624 DataExist = FALSE; 2625 Length = StrLen (ConfigHdr) + 1; 2626 2627 for (Link = VarStorageData->BlockEntry.ForwardLink; Link != &VarStorageData->BlockEntry; Link = Link->ForwardLink) { 2628 DataExist = TRUE; 2629 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry); 2630 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) { 2631 // 2632 // Add <BlockName> length for each Name 2633 // 2634 // <BlockName> ::= &Name1&Name2&... 2635 // |1| StrLen(Name1) 2636 // 2637 Length = Length + (1 + StrLen (BlockData->Name)); 2638 } else { 2639 // 2640 // Add <BlockName> length for each Offset/Width pair 2641 // 2642 // <BlockName> ::= &OFFSET=1234&WIDTH=1234 2643 // | 8 | 4 | 7 | 4 | 2644 // 2645 Length = Length + (8 + 4 + 7 + 4); 2646 } 2647 } 2648 // 2649 // No any request block data is found. The request string can't be constructed. 2650 // 2651 if (!DataExist) { 2652 *Status = EFI_SUCCESS; 2653 return FALSE; 2654 } 2655 2656 // 2657 // Allocate buffer for the entire <ConfigRequest> 2658 // 2659 FullConfigRequest = AllocateZeroPool (Length * sizeof (CHAR16)); 2660 if (FullConfigRequest == NULL) { 2661 *Status = EFI_OUT_OF_RESOURCES; 2662 return FALSE; 2663 } 2664 StringPtr = FullConfigRequest; 2665 2666 // 2667 // Start with <ConfigHdr> 2668 // 2669 StrCpyS (StringPtr, Length, ConfigHdr); 2670 StringPtr += StrLen (StringPtr); 2671 2672 // 2673 // Loop through all the Offset/Width pairs and append them to ConfigRequest 2674 // 2675 for (Link = VarStorageData->BlockEntry.ForwardLink; Link != &VarStorageData->BlockEntry; Link = Link->ForwardLink) { 2676 BlockData = BASE_CR (Link, IFR_BLOCK_DATA, Entry); 2677 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) { 2678 // 2679 // Append &Name1\0 2680 // 2681 UnicodeSPrint ( 2682 StringPtr, 2683 (1 + StrLen (BlockData->Name) + 1) * sizeof (CHAR16), 2684 L"&%s", 2685 BlockData->Name 2686 ); 2687 } else { 2688 // 2689 // Append &OFFSET=XXXX&WIDTH=YYYY\0 2690 // 2691 UnicodeSPrint ( 2692 StringPtr, 2693 (8 + 4 + 7 + 4 + 1) * sizeof (CHAR16), 2694 L"&OFFSET=%04X&WIDTH=%04X", 2695 BlockData->Offset, 2696 BlockData->Width 2697 ); 2698 } 2699 StringPtr += StrLen (StringPtr); 2700 } 2701 // 2702 // Set to the got full request string. 2703 // 2704 HiiToLower (FullConfigRequest); 2705 2706 if (*ConfigRequest != NULL) { 2707 FreePool (*ConfigRequest); 2708 } 2709 *ConfigRequest = FullConfigRequest; 2710 2711 return TRUE; 2712 } 2713 2714 /** 2715 Generate ConfigRequest Header base on the varstore info. 2716 2717 @param VarStorageData The varstore info. 2718 @param DevicePath Device path for this varstore. 2719 @param ConfigHdr The config header for this varstore. 2720 2721 @retval EFI_SUCCESS Generate the header success. 2722 @retval EFI_OUT_OF_RESOURCES Allocate buffer fail. 2723 **/ 2724 EFI_STATUS 2725 GenerateHdr ( 2726 IN IFR_VARSTORAGE_DATA *VarStorageData, 2727 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, 2728 OUT EFI_STRING *ConfigHdr 2729 ) 2730 { 2731 EFI_STRING GuidStr; 2732 EFI_STRING NameStr; 2733 EFI_STRING PathStr; 2734 UINTN Length; 2735 EFI_STATUS Status; 2736 2737 Status = EFI_SUCCESS; 2738 NameStr = NULL; 2739 GuidStr = NULL; 2740 PathStr = NULL; 2741 2742 // 2743 // Construct <ConfigHdr> : "GUID=...&NAME=...&PATH=..." by VarStorageData Guid, Name and DriverHandle 2744 // 2745 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) &VarStorageData->Guid, 1, &GuidStr); 2746 if (VarStorageData->Name != NULL) { 2747 GenerateSubStr (L"NAME=", StrLen (VarStorageData->Name) * sizeof (CHAR16), (VOID *) VarStorageData->Name, 2, &NameStr); 2748 } else { 2749 GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr); 2750 } 2751 GenerateSubStr ( 2752 L"PATH=", 2753 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) DevicePath), 2754 (VOID *) DevicePath, 2755 1, 2756 &PathStr 2757 ); 2758 Length = StrLen (GuidStr) + StrLen (NameStr) + StrLen (PathStr) + 1; 2759 if (VarStorageData->Name == NULL) { 2760 Length += 1; 2761 } 2762 2763 *ConfigHdr = AllocateZeroPool (Length * sizeof (CHAR16)); 2764 if (*ConfigHdr == NULL) { 2765 Status = EFI_OUT_OF_RESOURCES; 2766 goto Done; 2767 } 2768 StrCpyS (*ConfigHdr, Length, GuidStr); 2769 StrCatS (*ConfigHdr, Length, NameStr); 2770 if (VarStorageData->Name == NULL) { 2771 StrCatS (*ConfigHdr, Length, L"&"); 2772 } 2773 StrCatS (*ConfigHdr, Length, PathStr); 2774 2775 // 2776 // Remove the last character L'&' 2777 // 2778 *(*ConfigHdr + StrLen (*ConfigHdr) - 1) = L'\0'; 2779 2780 Done: 2781 if (GuidStr != NULL) { 2782 FreePool (GuidStr); 2783 } 2784 2785 if (NameStr != NULL) { 2786 FreePool (NameStr); 2787 } 2788 2789 if (PathStr != NULL) { 2790 FreePool (PathStr); 2791 } 2792 2793 return Status; 2794 } 2795 2796 /** 2797 Get Data buffer size based on data type. 2798 2799 @param ValueType The input data type. 2800 2801 @retval The data buffer size for the input type. 2802 **/ 2803 UINT16 2804 GetStorageWidth ( 2805 IN UINT8 ValueType 2806 ) 2807 { 2808 UINT16 StorageWidth; 2809 2810 switch (ValueType) { 2811 case EFI_IFR_NUMERIC_SIZE_1: 2812 case EFI_IFR_TYPE_BOOLEAN: 2813 StorageWidth = (UINT16) sizeof (UINT8); 2814 break; 2815 2816 case EFI_IFR_NUMERIC_SIZE_2: 2817 StorageWidth = (UINT16) sizeof (UINT16); 2818 break; 2819 2820 case EFI_IFR_NUMERIC_SIZE_4: 2821 StorageWidth = (UINT16) sizeof (UINT32); 2822 break; 2823 2824 case EFI_IFR_NUMERIC_SIZE_8: 2825 StorageWidth = (UINT16) sizeof (UINT64); 2826 break; 2827 2828 case EFI_IFR_TYPE_TIME: 2829 StorageWidth = (UINT16) sizeof (EFI_IFR_TIME); 2830 break; 2831 2832 case EFI_IFR_TYPE_DATE: 2833 StorageWidth = (UINT16) sizeof (EFI_IFR_DATE); 2834 break; 2835 2836 default: 2837 StorageWidth = 0; 2838 break; 2839 } 2840 2841 return StorageWidth; 2842 } 2843 2844 /** 2845 Generate ConfigAltResp string base on the varstore info. 2846 2847 @param HiiHandle Hii Handle for this hii package. 2848 @param ConfigHdr The config header for this varstore. 2849 @param VarStorageData The varstore info. 2850 @param DefaultIdArray The Default id array. 2851 @param DefaultAltCfgResp The DefaultAltCfgResp info may be return. 2852 2853 @retval TRUE Need to continue 2854 @retval Others NO need to continue or error occur. 2855 **/ 2856 EFI_STATUS 2857 GenerateAltConfigResp ( 2858 IN EFI_HII_HANDLE HiiHandle, 2859 IN CHAR16 *ConfigHdr, 2860 IN IFR_VARSTORAGE_DATA *VarStorageData, 2861 IN IFR_DEFAULT_DATA *DefaultIdArray, 2862 IN OUT EFI_STRING *DefaultAltCfgResp 2863 ) 2864 { 2865 BOOLEAN DataExist; 2866 UINTN Length; 2867 LIST_ENTRY *Link; 2868 LIST_ENTRY *LinkData; 2869 LIST_ENTRY *LinkDefault; 2870 LIST_ENTRY *ListEntry; 2871 CHAR16 *StringPtr; 2872 IFR_BLOCK_DATA *BlockData; 2873 IFR_DEFAULT_DATA *DefaultId; 2874 IFR_DEFAULT_DATA *DefaultValueData; 2875 UINTN Width; 2876 UINT8 *TmpBuffer; 2877 CHAR16 *DefaultString; 2878 2879 BlockData = NULL; 2880 DataExist = FALSE; 2881 DefaultString = NULL; 2882 // 2883 // Add length for <ConfigHdr> + '\0' 2884 // 2885 Length = StrLen (ConfigHdr) + 1; 2886 2887 for (Link = DefaultIdArray->Entry.ForwardLink; Link != &DefaultIdArray->Entry; Link = Link->ForwardLink) { 2888 DefaultId = BASE_CR (Link, IFR_DEFAULT_DATA, Entry); 2889 // 2890 // Add length for "&<ConfigHdr>&ALTCFG=XXXX" 2891 // |1| StrLen (ConfigHdr) | 8 | 4 | 2892 // 2893 Length += (1 + StrLen (ConfigHdr) + 8 + 4); 2894 2895 for (LinkData = VarStorageData->BlockEntry.ForwardLink; LinkData != &VarStorageData->BlockEntry; LinkData = LinkData->ForwardLink) { 2896 BlockData = BASE_CR (LinkData, IFR_BLOCK_DATA, Entry); 2897 ListEntry = &BlockData->DefaultValueEntry; 2898 for (LinkDefault = ListEntry->ForwardLink; LinkDefault != ListEntry; LinkDefault = LinkDefault->ForwardLink) { 2899 DefaultValueData = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry); 2900 if (DefaultValueData->DefaultId != DefaultId->DefaultId) { 2901 continue; 2902 } 2903 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) { 2904 // 2905 // Add length for "&Name1=zzzzzzzzzzzz" 2906 // |1|Name|1|Value| 2907 // 2908 Length += (1 + StrLen (BlockData->Name) + 1 + BlockData->Width * 2); 2909 } else { 2910 // 2911 // Add length for "&OFFSET=XXXX&WIDTH=YYYY&VALUE=zzzzzzzzzzzz" 2912 // | 8 | 4 | 7 | 4 | 7 | Width * 2 | 2913 // 2914 Length += (8 + 4 + 7 + 4 + 7 + BlockData->Width * 2); 2915 } 2916 DataExist = TRUE; 2917 } 2918 } 2919 } 2920 2921 // 2922 // No default value is found. The default string doesn't exist. 2923 // 2924 if (!DataExist) { 2925 return EFI_SUCCESS; 2926 } 2927 2928 // 2929 // Allocate buffer for the entire <DefaultAltCfgResp> 2930 // 2931 *DefaultAltCfgResp = AllocateZeroPool (Length * sizeof (CHAR16)); 2932 if (*DefaultAltCfgResp == NULL) { 2933 return EFI_OUT_OF_RESOURCES; 2934 } 2935 StringPtr = *DefaultAltCfgResp; 2936 2937 // 2938 // Start with <ConfigHdr> 2939 // 2940 StrCpyS (StringPtr, Length, ConfigHdr); 2941 StringPtr += StrLen (StringPtr); 2942 2943 for (Link = DefaultIdArray->Entry.ForwardLink; Link != &DefaultIdArray->Entry; Link = Link->ForwardLink) { 2944 DefaultId = BASE_CR (Link, IFR_DEFAULT_DATA, Entry); 2945 // 2946 // Add <AltConfigHdr> of the form "&<ConfigHdr>&ALTCFG=XXXX\0" 2947 // |1| StrLen (ConfigHdr) | 8 | 4 | 2948 // 2949 UnicodeSPrint ( 2950 StringPtr, 2951 (1 + StrLen (ConfigHdr) + 8 + 4 + 1) * sizeof (CHAR16), 2952 L"&%s&ALTCFG=%04X", 2953 ConfigHdr, 2954 DefaultId->DefaultId 2955 ); 2956 StringPtr += StrLen (StringPtr); 2957 2958 for (LinkData = VarStorageData->BlockEntry.ForwardLink; LinkData != &VarStorageData->BlockEntry; LinkData = LinkData->ForwardLink) { 2959 BlockData = BASE_CR (LinkData, IFR_BLOCK_DATA, Entry); 2960 ListEntry = &BlockData->DefaultValueEntry; 2961 for (LinkDefault = ListEntry->ForwardLink; LinkDefault != ListEntry; LinkDefault = LinkDefault->ForwardLink) { 2962 DefaultValueData = BASE_CR (LinkDefault, IFR_DEFAULT_DATA, Entry); 2963 if (DefaultValueData->DefaultId != DefaultId->DefaultId) { 2964 continue; 2965 } 2966 if (VarStorageData->Type == EFI_HII_VARSTORE_NAME_VALUE) { 2967 UnicodeSPrint ( 2968 StringPtr, 2969 (1 + StrLen (ConfigHdr) + 1) * sizeof (CHAR16), 2970 L"&%s=", 2971 BlockData->Name 2972 ); 2973 StringPtr += StrLen (StringPtr); 2974 } else { 2975 // 2976 // Add <BlockConfig> 2977 // <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number> 2978 // 2979 UnicodeSPrint ( 2980 StringPtr, 2981 (8 + 4 + 7 + 4 + 7 + 1) * sizeof (CHAR16), 2982 L"&OFFSET=%04X&WIDTH=%04X&VALUE=", 2983 BlockData->Offset, 2984 BlockData->Width 2985 ); 2986 StringPtr += StrLen (StringPtr); 2987 } 2988 Width = BlockData->Width; 2989 // 2990 // Convert Value to a hex string in "%x" format 2991 // NOTE: This is in the opposite byte that GUID and PATH use 2992 // 2993 if (BlockData->OpCode == EFI_IFR_STRING_OP){ 2994 DefaultString = InternalGetString(HiiHandle, DefaultValueData->Value.string); 2995 TmpBuffer = (UINT8 *) DefaultString; 2996 } else { 2997 TmpBuffer = (UINT8 *) &(DefaultValueData->Value); 2998 } 2999 for (; Width > 0 && (TmpBuffer != NULL); Width--) { 3000 StringPtr += UnicodeValueToString (StringPtr, PREFIX_ZERO | RADIX_HEX, TmpBuffer[Width - 1], 2); 3001 } 3002 if (DefaultString != NULL){ 3003 FreePool(DefaultString); 3004 DefaultString = NULL; 3005 } 3006 } 3007 } 3008 } 3009 3010 HiiToLower (*DefaultAltCfgResp); 3011 3012 return EFI_SUCCESS; 3013 } 3014 3015 /** 3016 This function gets the full request string and full default value string by 3017 parsing IFR data in HII form packages. 3018 3019 When Request points to NULL string, the request string and default value string 3020 for each varstore in form package will return. 3021 3022 @param DataBaseRecord The DataBaseRecord instance contains the found Hii handle and package. 3023 @param DevicePath Device Path which Hii Config Access Protocol is registered. 3024 @param Request Pointer to a null-terminated Unicode string in 3025 <ConfigRequest> format. When it doesn't contain 3026 any RequestElement, it will be updated to return 3027 the full RequestElement retrieved from IFR data. 3028 If it points to NULL, the request string for the first 3029 varstore in form package will be merged into a 3030 <MultiConfigRequest> format string and return. 3031 @param AltCfgResp Pointer to a null-terminated Unicode string in 3032 <ConfigAltResp> format. When the pointer is to NULL, 3033 the full default value string retrieved from IFR data 3034 will return. When the pinter is to a string, the 3035 full default value string retrieved from IFR data 3036 will be merged into the input string and return. 3037 When Request points to NULL, the default value string 3038 for each varstore in form package will be merged into 3039 a <MultiConfigAltResp> format string and return. 3040 @param PointerProgress Optional parameter, it can be be NULL. 3041 When it is not NULL, if Request is NULL, it returns NULL. 3042 On return, points to a character in the Request 3043 string. Points to the string's null terminator if 3044 request was successful. Points to the most recent 3045 & before the first failing name / value pair (or 3046 the beginning of the string if the failure is in 3047 the first name / value pair) if the request was 3048 not successful. 3049 @retval EFI_SUCCESS The Results string is set to the full request string. 3050 And AltCfgResp contains all default value string. 3051 @retval EFI_OUT_OF_RESOURCES Not enough memory for the return string. 3052 @retval EFI_NOT_FOUND The varstore (Guid and Name) in Request string 3053 can't be found in Form package. 3054 @retval EFI_NOT_FOUND HiiPackage can't be got on the input HiiHandle. 3055 @retval EFI_INVALID_PARAMETER Request points to NULL. 3056 3057 **/ 3058 EFI_STATUS 3059 EFIAPI 3060 GetFullStringFromHiiFormPackages ( 3061 IN HII_DATABASE_RECORD *DataBaseRecord, 3062 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, 3063 IN OUT EFI_STRING *Request, 3064 IN OUT EFI_STRING *AltCfgResp, 3065 OUT EFI_STRING *PointerProgress OPTIONAL 3066 ) 3067 { 3068 EFI_STATUS Status; 3069 UINT8 *HiiFormPackage; 3070 UINTN PackageSize; 3071 IFR_BLOCK_DATA *RequestBlockArray; 3072 IFR_BLOCK_DATA *BlockData; 3073 IFR_DEFAULT_DATA *DefaultValueData; 3074 IFR_DEFAULT_DATA *DefaultId; 3075 IFR_DEFAULT_DATA *DefaultIdArray; 3076 IFR_VARSTORAGE_DATA *VarStorageData; 3077 EFI_STRING DefaultAltCfgResp; 3078 EFI_STRING ConfigHdr; 3079 EFI_STRING StringPtr; 3080 EFI_STRING Progress; 3081 3082 if (DataBaseRecord == NULL || DevicePath == NULL || Request == NULL || AltCfgResp == NULL) { 3083 return EFI_INVALID_PARAMETER; 3084 } 3085 3086 // 3087 // Initialize the local variables. 3088 // 3089 RequestBlockArray = NULL; 3090 DefaultIdArray = NULL; 3091 VarStorageData = NULL; 3092 DefaultAltCfgResp = NULL; 3093 ConfigHdr = NULL; 3094 HiiFormPackage = NULL; 3095 PackageSize = 0; 3096 Progress = *Request; 3097 3098 Status = GetFormPackageData (DataBaseRecord, &HiiFormPackage, &PackageSize); 3099 if (EFI_ERROR (Status)) { 3100 goto Done; 3101 } 3102 3103 // 3104 // 1. Get the request block array by Request String when Request string containts the block array. 3105 // 3106 StringPtr = NULL; 3107 if (*Request != NULL) { 3108 StringPtr = *Request; 3109 // 3110 // Jump <ConfigHdr> 3111 // 3112 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 3113 Status = EFI_INVALID_PARAMETER; 3114 goto Done; 3115 } 3116 StringPtr += StrLen (L"GUID="); 3117 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&NAME=", StrLen (L"&NAME=")) != 0) { 3118 StringPtr++; 3119 } 3120 if (*StringPtr == L'\0') { 3121 Status = EFI_INVALID_PARAMETER; 3122 goto Done; 3123 } 3124 StringPtr += StrLen (L"&NAME="); 3125 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&PATH=", StrLen (L"&PATH=")) != 0) { 3126 StringPtr++; 3127 } 3128 if (*StringPtr == L'\0') { 3129 Status = EFI_INVALID_PARAMETER; 3130 goto Done; 3131 } 3132 StringPtr += StrLen (L"&PATH="); 3133 while (*StringPtr != L'\0' && *StringPtr != L'&') { 3134 StringPtr ++; 3135 } 3136 3137 if (*StringPtr == L'\0') { 3138 // 3139 // No request block is found. 3140 // 3141 StringPtr = NULL; 3142 } 3143 } 3144 3145 // 3146 // If StringPtr != NULL, get the request elements. 3147 // 3148 if (StringPtr != NULL) { 3149 if (StrStr (StringPtr, L"&OFFSET=") != NULL) { 3150 RequestBlockArray = GetBlockElement(StringPtr, &Progress); 3151 } else { 3152 RequestBlockArray = GetNameElement(StringPtr, &Progress); 3153 } 3154 3155 if (RequestBlockArray == NULL) { 3156 Status = EFI_INVALID_PARAMETER; 3157 goto Done; 3158 } 3159 } 3160 3161 // 3162 // Initialize DefaultIdArray to store the map between DeaultId and DefaultName 3163 // 3164 DefaultIdArray = (IFR_DEFAULT_DATA *) AllocateZeroPool (sizeof (IFR_DEFAULT_DATA)); 3165 if (DefaultIdArray == NULL) { 3166 Status = EFI_OUT_OF_RESOURCES; 3167 goto Done; 3168 } 3169 InitializeListHead (&DefaultIdArray->Entry); 3170 3171 // 3172 // Initialize VarStorageData to store the var store Block and Default value information. 3173 // 3174 VarStorageData = (IFR_VARSTORAGE_DATA *) AllocateZeroPool (sizeof (IFR_VARSTORAGE_DATA)); 3175 if (VarStorageData == NULL) { 3176 Status = EFI_OUT_OF_RESOURCES; 3177 goto Done; 3178 } 3179 InitializeListHead (&VarStorageData->Entry); 3180 InitializeListHead (&VarStorageData->BlockEntry); 3181 3182 // 3183 // 2. Parse FormPackage to get BlockArray and DefaultId Array for the request BlockArray. 3184 // 3185 3186 // 3187 // Parse the opcode in form pacakge to get the default setting. 3188 // 3189 Status = ParseIfrData (DataBaseRecord->Handle, 3190 HiiFormPackage, 3191 (UINT32) PackageSize, 3192 *Request, 3193 RequestBlockArray, 3194 VarStorageData, 3195 DefaultIdArray); 3196 if (EFI_ERROR (Status)) { 3197 goto Done; 3198 } 3199 3200 // 3201 // No requested varstore in IFR data and directly return 3202 // 3203 if (VarStorageData->Type == 0 && VarStorageData->Name == NULL) { 3204 Status = EFI_SUCCESS; 3205 goto Done; 3206 } 3207 3208 // 3209 // 3. Construct Request Element (Block Name) for 2.1 and 2.2 case. 3210 // 3211 Status = GenerateHdr (VarStorageData, DevicePath, &ConfigHdr); 3212 if (EFI_ERROR (Status)) { 3213 goto Done; 3214 } 3215 3216 if (RequestBlockArray == NULL) { 3217 if (!GenerateConfigRequest(ConfigHdr, VarStorageData, &Status, Request)) { 3218 goto Done; 3219 } 3220 } 3221 3222 // 3223 // 4. Construct Default Value string in AltResp according to request element. 3224 // Go through all VarStorageData Entry and get the DefaultId array for each one 3225 // Then construct them all to : ConfigHdr AltConfigHdr ConfigBody AltConfigHdr ConfigBody 3226 // 3227 Status = GenerateAltConfigResp (DataBaseRecord->Handle,ConfigHdr, VarStorageData, DefaultIdArray, &DefaultAltCfgResp); 3228 if (EFI_ERROR (Status)) { 3229 goto Done; 3230 } 3231 3232 // 3233 // 5. Merge string into the input AltCfgResp if the iput *AltCfgResp is not NULL. 3234 // 3235 if (*AltCfgResp != NULL && DefaultAltCfgResp != NULL) { 3236 Status = MergeDefaultString (AltCfgResp, DefaultAltCfgResp); 3237 FreePool (DefaultAltCfgResp); 3238 } else if (*AltCfgResp == NULL) { 3239 *AltCfgResp = DefaultAltCfgResp; 3240 } 3241 3242 Done: 3243 if (RequestBlockArray != NULL) { 3244 // 3245 // Free Link Array RequestBlockArray 3246 // 3247 while (!IsListEmpty (&RequestBlockArray->Entry)) { 3248 BlockData = BASE_CR (RequestBlockArray->Entry.ForwardLink, IFR_BLOCK_DATA, Entry); 3249 RemoveEntryList (&BlockData->Entry); 3250 if (BlockData->Name != NULL) { 3251 FreePool (BlockData->Name); 3252 } 3253 FreePool (BlockData); 3254 } 3255 3256 FreePool (RequestBlockArray); 3257 } 3258 3259 if (VarStorageData != NULL) { 3260 // 3261 // Free link array VarStorageData 3262 // 3263 while (!IsListEmpty (&VarStorageData->BlockEntry)) { 3264 BlockData = BASE_CR (VarStorageData->BlockEntry.ForwardLink, IFR_BLOCK_DATA, Entry); 3265 RemoveEntryList (&BlockData->Entry); 3266 if (BlockData->Name != NULL) { 3267 FreePool (BlockData->Name); 3268 } 3269 // 3270 // Free default value link array 3271 // 3272 while (!IsListEmpty (&BlockData->DefaultValueEntry)) { 3273 DefaultValueData = BASE_CR (BlockData->DefaultValueEntry.ForwardLink, IFR_DEFAULT_DATA, Entry); 3274 RemoveEntryList (&DefaultValueData->Entry); 3275 FreePool (DefaultValueData); 3276 } 3277 FreePool (BlockData); 3278 } 3279 FreePool (VarStorageData); 3280 } 3281 3282 if (DefaultIdArray != NULL) { 3283 // 3284 // Free DefaultId Array 3285 // 3286 while (!IsListEmpty (&DefaultIdArray->Entry)) { 3287 DefaultId = BASE_CR (DefaultIdArray->Entry.ForwardLink, IFR_DEFAULT_DATA, Entry); 3288 RemoveEntryList (&DefaultId->Entry); 3289 FreePool (DefaultId); 3290 } 3291 FreePool (DefaultIdArray); 3292 } 3293 3294 // 3295 // Free the allocated string 3296 // 3297 if (ConfigHdr != NULL) { 3298 FreePool (ConfigHdr); 3299 } 3300 3301 // 3302 // Free Pacakge data 3303 // 3304 if (HiiFormPackage != NULL) { 3305 FreePool (HiiFormPackage); 3306 } 3307 3308 if (PointerProgress != NULL) { 3309 if (*Request == NULL) { 3310 *PointerProgress = NULL; 3311 } else if (EFI_ERROR (Status)) { 3312 *PointerProgress = *Request; 3313 } else { 3314 *PointerProgress = *Request + StrLen (*Request); 3315 } 3316 } 3317 3318 return Status; 3319 } 3320 3321 /** 3322 This function gets the full request resp string by 3323 parsing IFR data in HII form packages. 3324 3325 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 3326 instance. 3327 @param EfiVarStoreInfo The efi varstore info which is save in the EFI 3328 varstore data structure. 3329 @param Request Pointer to a null-terminated Unicode string in 3330 <ConfigRequest> format. 3331 @param RequestResp Pointer to a null-terminated Unicode string in 3332 <ConfigResp> format. 3333 @param AccessProgress On return, points to a character in the Request 3334 string. Points to the string's null terminator if 3335 request was successful. Points to the most recent 3336 & before the first failing name / value pair (or 3337 the beginning of the string if the failure is in 3338 the first name / value pair) if the request was 3339 not successful. 3340 3341 @retval EFI_SUCCESS The Results string is set to the full request string. 3342 And AltCfgResp contains all default value string. 3343 @retval EFI_OUT_OF_RESOURCES Not enough memory for the return string. 3344 @retval EFI_INVALID_PARAMETER Request points to NULL. 3345 3346 **/ 3347 EFI_STATUS 3348 GetConfigRespFromEfiVarStore ( 3349 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 3350 IN EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo, 3351 IN EFI_STRING Request, 3352 OUT EFI_STRING *RequestResp, 3353 OUT EFI_STRING *AccessProgress 3354 ) 3355 { 3356 EFI_STATUS Status; 3357 EFI_STRING VarStoreName; 3358 UINT8 *VarStore; 3359 UINTN BufferSize; 3360 3361 Status = EFI_SUCCESS; 3362 BufferSize = 0; 3363 VarStore = NULL; 3364 VarStoreName = NULL; 3365 *AccessProgress = Request; 3366 3367 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)EfiVarStoreInfo->Name) * sizeof (CHAR16)); 3368 if (VarStoreName == NULL) { 3369 Status = EFI_OUT_OF_RESOURCES; 3370 goto Done; 3371 } 3372 AsciiStrToUnicodeStr ((CHAR8 *) EfiVarStoreInfo->Name, VarStoreName); 3373 3374 3375 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, NULL); 3376 if (Status != EFI_BUFFER_TOO_SMALL) { 3377 goto Done; 3378 } 3379 3380 VarStore = AllocateZeroPool (BufferSize); 3381 ASSERT (VarStore != NULL); 3382 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, VarStore); 3383 if (EFI_ERROR (Status)) { 3384 goto Done; 3385 } 3386 3387 Status = HiiBlockToConfig(This, Request, VarStore, BufferSize, RequestResp, AccessProgress); 3388 if (EFI_ERROR (Status)) { 3389 goto Done; 3390 } 3391 3392 Done: 3393 if (VarStoreName != NULL) { 3394 FreePool (VarStoreName); 3395 } 3396 3397 if (VarStore != NULL) { 3398 FreePool (VarStore); 3399 } 3400 3401 return Status; 3402 } 3403 3404 3405 /** 3406 This function route the full request resp string for efi varstore. 3407 3408 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 3409 instance. 3410 @param EfiVarStoreInfo The efi varstore info which is save in the EFI 3411 varstore data structure. 3412 @param RequestResp Pointer to a null-terminated Unicode string in 3413 <ConfigResp> format. 3414 @param Result Pointer to a null-terminated Unicode string in 3415 <ConfigResp> format. 3416 3417 @retval EFI_SUCCESS The Results string is set to the full request string. 3418 And AltCfgResp contains all default value string. 3419 @retval EFI_OUT_OF_RESOURCES Not enough memory for the return string. 3420 @retval EFI_INVALID_PARAMETER Request points to NULL. 3421 3422 **/ 3423 EFI_STATUS 3424 RouteConfigRespForEfiVarStore ( 3425 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 3426 IN EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo, 3427 IN EFI_STRING RequestResp, 3428 OUT EFI_STRING *Result 3429 ) 3430 { 3431 EFI_STATUS Status; 3432 EFI_STRING VarStoreName; 3433 UINT8 *VarStore; 3434 UINTN BufferSize; 3435 UINTN BlockSize; 3436 3437 Status = EFI_SUCCESS; 3438 BufferSize = 0; 3439 VarStore = NULL; 3440 VarStoreName = NULL; 3441 3442 VarStoreName = AllocateZeroPool (AsciiStrSize ((CHAR8 *)EfiVarStoreInfo->Name) * sizeof (CHAR16)); 3443 if (VarStoreName == NULL) { 3444 Status = EFI_OUT_OF_RESOURCES; 3445 goto Done; 3446 } 3447 AsciiStrToUnicodeStr ((CHAR8 *) EfiVarStoreInfo->Name, VarStoreName); 3448 3449 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, NULL); 3450 if (Status != EFI_BUFFER_TOO_SMALL) { 3451 goto Done; 3452 } 3453 3454 BlockSize = BufferSize; 3455 VarStore = AllocateZeroPool (BufferSize); 3456 ASSERT (VarStore != NULL); 3457 Status = gRT->GetVariable (VarStoreName, &EfiVarStoreInfo->Guid, NULL, &BufferSize, VarStore); 3458 if (EFI_ERROR (Status)) { 3459 goto Done; 3460 } 3461 3462 Status = HiiConfigToBlock(This, RequestResp, VarStore, &BlockSize, Result); 3463 if (EFI_ERROR (Status)) { 3464 goto Done; 3465 } 3466 3467 Status = gRT->SetVariable (VarStoreName, &EfiVarStoreInfo->Guid, EfiVarStoreInfo->Attributes, BufferSize, VarStore); 3468 if (EFI_ERROR (Status)) { 3469 goto Done; 3470 } 3471 3472 Done: 3473 if (VarStoreName != NULL) { 3474 FreePool (VarStoreName); 3475 } 3476 3477 if (VarStore != NULL) { 3478 FreePool (VarStore); 3479 } 3480 3481 return Status; 3482 } 3483 3484 /** 3485 Validate the config request elements. 3486 3487 @param ConfigElements A null-terminated Unicode string in <ConfigRequest> format, 3488 without configHdr field. 3489 3490 @retval CHAR16 * THE first Name/value pair not correct. 3491 @retval NULL Success parse the name/value pair 3492 **/ 3493 CHAR16 * 3494 OffsetWidthValidate ( 3495 CHAR16 *ConfigElements 3496 ) 3497 { 3498 CHAR16 *StringPtr; 3499 CHAR16 *RetVal; 3500 3501 StringPtr = ConfigElements; 3502 3503 while (1) { 3504 RetVal = StringPtr; 3505 if (StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) != 0) { 3506 return RetVal; 3507 } 3508 3509 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) { 3510 StringPtr++; 3511 } 3512 if (*StringPtr == L'\0') { 3513 return RetVal; 3514 } 3515 3516 StringPtr += StrLen (L"&WIDTH="); 3517 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) != 0) { 3518 StringPtr ++; 3519 } 3520 3521 if (*StringPtr == L'\0') { 3522 return NULL; 3523 } 3524 } 3525 } 3526 3527 /** 3528 Validate the config request elements. 3529 3530 @param ConfigElements A null-terminated Unicode string in <ConfigRequest> format, 3531 without configHdr field. 3532 3533 @retval CHAR16 * THE first Name/value pair not correct. 3534 @retval NULL Success parse the name/value pair 3535 3536 **/ 3537 CHAR16 * 3538 NameValueValidate ( 3539 CHAR16 *ConfigElements 3540 ) 3541 { 3542 CHAR16 *StringPtr; 3543 CHAR16 *RetVal; 3544 3545 StringPtr = ConfigElements; 3546 3547 while (1) { 3548 RetVal = StringPtr; 3549 if (*StringPtr != L'&') { 3550 return RetVal; 3551 } 3552 StringPtr += 1; 3553 3554 StringPtr = StrStr (StringPtr, L"&"); 3555 3556 if (StringPtr == NULL) { 3557 return NULL; 3558 } 3559 } 3560 } 3561 3562 /** 3563 Validate the config request string. 3564 3565 @param ConfigRequest A null-terminated Unicode string in <ConfigRequest> format. 3566 3567 @retval CHAR16 * THE first element not correct. 3568 @retval NULL Success parse the name/value pair 3569 3570 **/ 3571 CHAR16 * 3572 ConfigRequestValidate ( 3573 CHAR16 *ConfigRequest 3574 ) 3575 { 3576 BOOLEAN HasNameField; 3577 CHAR16 *StringPtr; 3578 3579 HasNameField = TRUE; 3580 StringPtr = ConfigRequest; 3581 3582 // 3583 // Check <ConfigHdr> 3584 // 3585 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 3586 return ConfigRequest; 3587 } 3588 StringPtr += StrLen (L"GUID="); 3589 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&NAME=", StrLen (L"&NAME=")) != 0) { 3590 StringPtr++; 3591 } 3592 if (*StringPtr == L'\0') { 3593 return ConfigRequest; 3594 } 3595 StringPtr += StrLen (L"&NAME="); 3596 if (*StringPtr == L'&') { 3597 HasNameField = FALSE; 3598 } 3599 while (*StringPtr != L'\0' && StrnCmp (StringPtr, L"&PATH=", StrLen (L"&PATH=")) != 0) { 3600 StringPtr++; 3601 } 3602 if (*StringPtr == L'\0') { 3603 return ConfigRequest; 3604 } 3605 StringPtr += StrLen (L"&PATH="); 3606 while (*StringPtr != L'\0' && *StringPtr != L'&') { 3607 StringPtr ++; 3608 } 3609 3610 if (*StringPtr == L'\0') { 3611 return NULL; 3612 } 3613 3614 if (HasNameField) { 3615 // 3616 // Should be Buffer varstore, config request should be "OFFSET/Width" pairs. 3617 // 3618 return OffsetWidthValidate(StringPtr); 3619 } else { 3620 // 3621 // Should be Name/Value varstore, config request should be "&name1&name2..." pairs. 3622 // 3623 return NameValueValidate(StringPtr); 3624 } 3625 } 3626 3627 /** 3628 This function allows a caller to extract the current configuration 3629 for one or more named elements from one or more drivers. 3630 3631 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 3632 instance. 3633 @param Request A null-terminated Unicode string in 3634 <MultiConfigRequest> format. 3635 @param Progress On return, points to a character in the Request 3636 string. Points to the string's null terminator if 3637 request was successful. Points to the most recent 3638 & before the first failing name / value pair (or 3639 the beginning of the string if the failure is in 3640 the first name / value pair) if the request was 3641 not successful. 3642 @param Results Null-terminated Unicode string in 3643 <MultiConfigAltResp> format which has all values 3644 filled in for the names in the Request string. 3645 String to be allocated by the called function. 3646 3647 @retval EFI_SUCCESS The Results string is filled with the values 3648 corresponding to all requested names. 3649 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the parts of the 3650 results that must be stored awaiting possible 3651 future protocols. 3652 @retval EFI_NOT_FOUND Routing data doesn't match any known driver. 3653 Progress set to the "G" in "GUID" of the routing 3654 header that doesn't match. Note: There is no 3655 requirement that all routing data be validated 3656 before any configuration extraction. 3657 @retval EFI_INVALID_PARAMETER For example, passing in a NULL for the Request 3658 parameter would result in this type of error. The 3659 Progress parameter is set to NULL. 3660 @retval EFI_INVALID_PARAMETER Illegal syntax. Progress set to most recent & 3661 before the error or the beginning of the string. 3662 @retval EFI_INVALID_PARAMETER The ExtractConfig function of the underlying HII 3663 Configuration Access Protocol returned 3664 EFI_INVALID_PARAMETER. Progress set to most recent 3665 & before the error or the beginning of the string. 3666 3667 **/ 3668 EFI_STATUS 3669 EFIAPI 3670 HiiConfigRoutingExtractConfig ( 3671 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 3672 IN CONST EFI_STRING Request, 3673 OUT EFI_STRING *Progress, 3674 OUT EFI_STRING *Results 3675 ) 3676 { 3677 HII_DATABASE_PRIVATE_DATA *Private; 3678 EFI_STRING StringPtr; 3679 EFI_STRING ConfigRequest; 3680 UINTN Length; 3681 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 3682 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; 3683 EFI_STATUS Status; 3684 LIST_ENTRY *Link; 3685 HII_DATABASE_RECORD *Database; 3686 UINT8 *DevicePathPkg; 3687 UINT8 *CurrentDevicePath; 3688 EFI_HANDLE DriverHandle; 3689 EFI_HII_HANDLE HiiHandle; 3690 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; 3691 EFI_STRING AccessProgress; 3692 EFI_STRING AccessResults; 3693 EFI_STRING DefaultResults; 3694 BOOLEAN FirstElement; 3695 BOOLEAN IfrDataParsedFlag; 3696 BOOLEAN IsEfiVarStore; 3697 EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo; 3698 EFI_STRING ErrorPtr; 3699 UINTN DevicePathSize; 3700 3701 if (This == NULL || Progress == NULL || Results == NULL) { 3702 return EFI_INVALID_PARAMETER; 3703 } 3704 3705 if (Request == NULL) { 3706 *Progress = NULL; 3707 return EFI_INVALID_PARAMETER; 3708 } 3709 3710 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This); 3711 StringPtr = Request; 3712 *Progress = StringPtr; 3713 DefaultResults = NULL; 3714 ConfigRequest = NULL; 3715 Status = EFI_SUCCESS; 3716 AccessResults = NULL; 3717 AccessProgress = NULL; 3718 DevicePath = NULL; 3719 IfrDataParsedFlag = FALSE; 3720 IsEfiVarStore = FALSE; 3721 EfiVarStoreInfo = NULL; 3722 3723 // 3724 // The first element of <MultiConfigRequest> should be 3725 // <GuidHdr>, which is in 'GUID='<Guid> syntax. 3726 // 3727 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 3728 return EFI_INVALID_PARAMETER; 3729 } 3730 3731 FirstElement = TRUE; 3732 3733 // 3734 // Allocate a fix length of memory to store Results. Reallocate memory for 3735 // Results if this fix length is insufficient. 3736 // 3737 *Results = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH); 3738 if (*Results == NULL) { 3739 return EFI_OUT_OF_RESOURCES; 3740 } 3741 3742 while (*StringPtr != 0 && StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) == 0) { 3743 // 3744 // If parsing error, set Progress to the beginning of the <MultiConfigRequest> 3745 // or most recent & before the error. 3746 // 3747 if (StringPtr == Request) { 3748 *Progress = StringPtr; 3749 } else { 3750 *Progress = StringPtr - 1; 3751 } 3752 3753 // 3754 // Process each <ConfigRequest> of <MultiConfigRequest> 3755 // 3756 Length = CalculateConfigStringLen (StringPtr); 3757 ConfigRequest = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), StringPtr); 3758 if (ConfigRequest == NULL) { 3759 Status = EFI_OUT_OF_RESOURCES; 3760 goto Done; 3761 } 3762 *(ConfigRequest + Length) = 0; 3763 3764 // 3765 // Get the UEFI device path 3766 // 3767 Status = GetDevicePath (ConfigRequest, (UINT8 **) &DevicePath); 3768 if (EFI_ERROR (Status)) { 3769 goto Done; 3770 } 3771 3772 // 3773 // Find driver which matches the routing data. 3774 // 3775 DriverHandle = NULL; 3776 HiiHandle = NULL; 3777 Database = NULL; 3778 for (Link = Private->DatabaseList.ForwardLink; 3779 Link != &Private->DatabaseList; 3780 Link = Link->ForwardLink 3781 ) { 3782 Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE); 3783 if ((DevicePathPkg = Database->PackageList->DevicePathPkg) != NULL) { 3784 CurrentDevicePath = DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER); 3785 DevicePathSize = GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath); 3786 if ((CompareMem (DevicePath,CurrentDevicePath,DevicePathSize) == 0) && IsThisPackageList(Database, ConfigRequest)) { 3787 DriverHandle = Database->DriverHandle; 3788 HiiHandle = Database->Handle; 3789 break; 3790 } 3791 } 3792 } 3793 3794 // 3795 // Try to find driver handle by device path. 3796 // 3797 if (DriverHandle == NULL) { 3798 TempDevicePath = DevicePath; 3799 Status = gBS->LocateDevicePath ( 3800 &gEfiDevicePathProtocolGuid, 3801 &TempDevicePath, 3802 &DriverHandle 3803 ); 3804 if (EFI_ERROR (Status) || (DriverHandle == NULL)) { 3805 // 3806 // Routing data does not match any known driver. 3807 // Set Progress to the 'G' in "GUID" of the routing header. 3808 // 3809 *Progress = StringPtr; 3810 Status = EFI_NOT_FOUND; 3811 goto Done; 3812 } 3813 } 3814 3815 // 3816 // Validate ConfigRequest String. 3817 // 3818 ErrorPtr = ConfigRequestValidate(ConfigRequest); 3819 if (ErrorPtr != NULL) { 3820 *Progress = StrStr (StringPtr, ErrorPtr); 3821 Status = EFI_INVALID_PARAMETER; 3822 goto Done; 3823 } 3824 3825 // 3826 // Check whether ConfigRequest contains request string. 3827 // 3828 IfrDataParsedFlag = FALSE; 3829 if ((HiiHandle != NULL) && !GetElementsFromRequest(ConfigRequest)) { 3830 // 3831 // Get the full request string from IFR when HiiPackage is registered to HiiHandle 3832 // 3833 IfrDataParsedFlag = TRUE; 3834 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &ConfigRequest, &DefaultResults, &AccessProgress); 3835 if (EFI_ERROR (Status)) { 3836 // 3837 // AccessProgress indicates the parsing progress on <ConfigRequest>. 3838 // Map it to the progress on <MultiConfigRequest> then return it. 3839 // 3840 ASSERT (AccessProgress != NULL); 3841 *Progress = StrStr (StringPtr, AccessProgress); 3842 goto Done; 3843 } 3844 // 3845 // Not any request block is found. 3846 // 3847 if (!GetElementsFromRequest(ConfigRequest)) { 3848 AccessResults = AllocateCopyPool (StrSize (ConfigRequest), ConfigRequest); 3849 goto NextConfigString; 3850 } 3851 } 3852 3853 // 3854 // Check whether this ConfigRequest is search from Efi varstore type storage. 3855 // 3856 Status = GetVarStoreType(Database, ConfigRequest, &IsEfiVarStore, &EfiVarStoreInfo); 3857 if (EFI_ERROR (Status)) { 3858 goto Done; 3859 } 3860 3861 if (IsEfiVarStore) { 3862 // 3863 // Call the GetVariable function to extract settings. 3864 // 3865 Status = GetConfigRespFromEfiVarStore(This, EfiVarStoreInfo, ConfigRequest, &AccessResults, &AccessProgress); 3866 FreePool (EfiVarStoreInfo); 3867 } else { 3868 // 3869 // Call corresponding ConfigAccess protocol to extract settings 3870 // 3871 Status = gBS->HandleProtocol ( 3872 DriverHandle, 3873 &gEfiHiiConfigAccessProtocolGuid, 3874 (VOID **) &ConfigAccess 3875 ); 3876 if (EFI_ERROR (Status)) { 3877 goto Done; 3878 } 3879 3880 Status = ConfigAccess->ExtractConfig ( 3881 ConfigAccess, 3882 ConfigRequest, 3883 &AccessProgress, 3884 &AccessResults 3885 ); 3886 } 3887 if (EFI_ERROR (Status)) { 3888 // 3889 // AccessProgress indicates the parsing progress on <ConfigRequest>. 3890 // Map it to the progress on <MultiConfigRequest> then return it. 3891 // 3892 *Progress = StrStr (StringPtr, AccessProgress); 3893 goto Done; 3894 } 3895 3896 // 3897 // Attach this <ConfigAltResp> to a <MultiConfigAltResp>. There is a '&' 3898 // which seperates the first <ConfigAltResp> and the following ones. 3899 // 3900 ASSERT (*AccessProgress == 0); 3901 3902 // 3903 // Update AccessResults by getting default setting from IFR when HiiPackage is registered to HiiHandle 3904 // 3905 if (!IfrDataParsedFlag && HiiHandle != NULL) { 3906 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &ConfigRequest, &DefaultResults, NULL); 3907 ASSERT_EFI_ERROR (Status); 3908 } 3909 3910 FreePool (DevicePath); 3911 DevicePath = NULL; 3912 3913 if (DefaultResults != NULL) { 3914 Status = MergeDefaultString (&AccessResults, DefaultResults); 3915 ASSERT_EFI_ERROR (Status); 3916 FreePool (DefaultResults); 3917 DefaultResults = NULL; 3918 } 3919 3920 NextConfigString: 3921 if (!FirstElement) { 3922 Status = AppendToMultiString (Results, L"&"); 3923 ASSERT_EFI_ERROR (Status); 3924 } 3925 3926 Status = AppendToMultiString (Results, AccessResults); 3927 ASSERT_EFI_ERROR (Status); 3928 3929 FirstElement = FALSE; 3930 3931 FreePool (AccessResults); 3932 AccessResults = NULL; 3933 FreePool (ConfigRequest); 3934 ConfigRequest = NULL; 3935 3936 // 3937 // Go to next <ConfigRequest> (skip '&'). 3938 // 3939 StringPtr += Length; 3940 if (*StringPtr == 0) { 3941 *Progress = StringPtr; 3942 break; 3943 } 3944 3945 StringPtr++; 3946 } 3947 3948 Done: 3949 if (EFI_ERROR (Status)) { 3950 FreePool (*Results); 3951 *Results = NULL; 3952 } 3953 3954 if (ConfigRequest != NULL) { 3955 FreePool (ConfigRequest); 3956 } 3957 3958 if (AccessResults != NULL) { 3959 FreePool (AccessResults); 3960 } 3961 3962 if (DefaultResults != NULL) { 3963 FreePool (DefaultResults); 3964 } 3965 3966 if (DevicePath != NULL) { 3967 FreePool (DevicePath); 3968 } 3969 3970 return Status; 3971 } 3972 3973 3974 /** 3975 This function allows the caller to request the current configuration for the 3976 entirety of the current HII database and returns the data in a 3977 null-terminated Unicode string. 3978 3979 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 3980 instance. 3981 @param Results Null-terminated Unicode string in 3982 <MultiConfigAltResp> format which has all values 3983 filled in for the entirety of the current HII 3984 database. String to be allocated by the called 3985 function. De-allocation is up to the caller. 3986 3987 @retval EFI_SUCCESS The Results string is filled with the values 3988 corresponding to all requested names. 3989 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the parts of the 3990 results that must be stored awaiting possible 3991 future protocols. 3992 @retval EFI_INVALID_PARAMETER For example, passing in a NULL for the Results 3993 parameter would result in this type of error. 3994 3995 **/ 3996 EFI_STATUS 3997 EFIAPI 3998 HiiConfigRoutingExportConfig ( 3999 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 4000 OUT EFI_STRING *Results 4001 ) 4002 { 4003 EFI_STATUS Status; 4004 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; 4005 EFI_STRING AccessResults; 4006 EFI_STRING Progress; 4007 EFI_STRING StringPtr; 4008 EFI_STRING ConfigRequest; 4009 UINTN Index; 4010 EFI_HANDLE *ConfigAccessHandles; 4011 UINTN NumberConfigAccessHandles; 4012 BOOLEAN FirstElement; 4013 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 4014 EFI_HII_HANDLE HiiHandle; 4015 EFI_STRING DefaultResults; 4016 HII_DATABASE_PRIVATE_DATA *Private; 4017 LIST_ENTRY *Link; 4018 HII_DATABASE_RECORD *Database; 4019 UINT8 *DevicePathPkg; 4020 UINT8 *CurrentDevicePath; 4021 BOOLEAN IfrDataParsedFlag; 4022 4023 if (This == NULL || Results == NULL) { 4024 return EFI_INVALID_PARAMETER; 4025 } 4026 4027 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This); 4028 4029 // 4030 // Allocate a fix length of memory to store Results. Reallocate memory for 4031 // Results if this fix length is insufficient. 4032 // 4033 *Results = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH); 4034 if (*Results == NULL) { 4035 return EFI_OUT_OF_RESOURCES; 4036 } 4037 4038 NumberConfigAccessHandles = 0; 4039 Status = gBS->LocateHandleBuffer ( 4040 ByProtocol, 4041 &gEfiHiiConfigAccessProtocolGuid, 4042 NULL, 4043 &NumberConfigAccessHandles, 4044 &ConfigAccessHandles 4045 ); 4046 if (EFI_ERROR (Status)) { 4047 return Status; 4048 } 4049 4050 FirstElement = TRUE; 4051 4052 for (Index = 0; Index < NumberConfigAccessHandles; Index++) { 4053 Status = gBS->HandleProtocol ( 4054 ConfigAccessHandles[Index], 4055 &gEfiHiiConfigAccessProtocolGuid, 4056 (VOID **) &ConfigAccess 4057 ); 4058 if (EFI_ERROR (Status)) { 4059 continue; 4060 } 4061 4062 // 4063 // Get DevicePath and HiiHandle for this ConfigAccess driver handle 4064 // 4065 IfrDataParsedFlag = FALSE; 4066 Progress = NULL; 4067 HiiHandle = NULL; 4068 DefaultResults = NULL; 4069 Database = NULL; 4070 ConfigRequest = NULL; 4071 DevicePath = DevicePathFromHandle (ConfigAccessHandles[Index]); 4072 if (DevicePath != NULL) { 4073 for (Link = Private->DatabaseList.ForwardLink; 4074 Link != &Private->DatabaseList; 4075 Link = Link->ForwardLink 4076 ) { 4077 Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE); 4078 if ((DevicePathPkg = Database->PackageList->DevicePathPkg) != NULL) { 4079 CurrentDevicePath = DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER); 4080 if (CompareMem ( 4081 DevicePath, 4082 CurrentDevicePath, 4083 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath) 4084 ) == 0) { 4085 HiiHandle = Database->Handle; 4086 break; 4087 } 4088 } 4089 } 4090 } 4091 4092 Status = ConfigAccess->ExtractConfig ( 4093 ConfigAccess, 4094 NULL, 4095 &Progress, 4096 &AccessResults 4097 ); 4098 if (EFI_ERROR (Status)) { 4099 // 4100 // Update AccessResults by getting default setting from IFR when HiiPackage is registered to HiiHandle 4101 // 4102 if (HiiHandle != NULL && DevicePath != NULL) { 4103 IfrDataParsedFlag = TRUE; 4104 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &ConfigRequest, &DefaultResults, NULL); 4105 // 4106 // Get the full request string to get the Current setting again. 4107 // 4108 if (!EFI_ERROR (Status) && ConfigRequest != NULL) { 4109 Status = ConfigAccess->ExtractConfig ( 4110 ConfigAccess, 4111 ConfigRequest, 4112 &Progress, 4113 &AccessResults 4114 ); 4115 FreePool (ConfigRequest); 4116 } else { 4117 Status = EFI_NOT_FOUND; 4118 } 4119 } 4120 } 4121 4122 if (!EFI_ERROR (Status)) { 4123 // 4124 // Update AccessResults by getting default setting from IFR when HiiPackage is registered to HiiHandle 4125 // 4126 if (!IfrDataParsedFlag && HiiHandle != NULL && DevicePath != NULL) { 4127 StringPtr = StrStr (AccessResults, L"&GUID="); 4128 if (StringPtr != NULL) { 4129 *StringPtr = 0; 4130 } 4131 if (GetElementsFromRequest (AccessResults)) { 4132 Status = GetFullStringFromHiiFormPackages (Database, DevicePath, &AccessResults, &DefaultResults, NULL); 4133 ASSERT_EFI_ERROR (Status); 4134 } 4135 if (StringPtr != NULL) { 4136 *StringPtr = L'&'; 4137 } 4138 } 4139 // 4140 // Merge the default sting from IFR code into the got setting from driver. 4141 // 4142 if (DefaultResults != NULL) { 4143 Status = MergeDefaultString (&AccessResults, DefaultResults); 4144 ASSERT_EFI_ERROR (Status); 4145 FreePool (DefaultResults); 4146 DefaultResults = NULL; 4147 } 4148 4149 // 4150 // Attach this <ConfigAltResp> to a <MultiConfigAltResp>. There is a '&' 4151 // which seperates the first <ConfigAltResp> and the following ones. 4152 // 4153 if (!FirstElement) { 4154 Status = AppendToMultiString (Results, L"&"); 4155 ASSERT_EFI_ERROR (Status); 4156 } 4157 4158 Status = AppendToMultiString (Results, AccessResults); 4159 ASSERT_EFI_ERROR (Status); 4160 4161 FirstElement = FALSE; 4162 4163 FreePool (AccessResults); 4164 AccessResults = NULL; 4165 } 4166 } 4167 FreePool (ConfigAccessHandles); 4168 4169 return EFI_SUCCESS; 4170 } 4171 4172 4173 /** 4174 This function processes the results of processing forms and routes it to the 4175 appropriate handlers or storage. 4176 4177 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 4178 instance. 4179 @param Configuration A null-terminated Unicode string in 4180 <MulltiConfigResp> format. 4181 @param Progress A pointer to a string filled in with the offset of 4182 the most recent & before the first failing name / 4183 value pair (or the beginning of the string if the 4184 failure is in the first name / value pair) or the 4185 terminating NULL if all was successful. 4186 4187 @retval EFI_SUCCESS The results have been distributed or are awaiting 4188 distribution. 4189 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the parts of the 4190 results that must be stored awaiting possible 4191 future protocols. 4192 @retval EFI_INVALID_PARAMETER Passing in a NULL for the Configuration parameter 4193 would result in this type of error. 4194 @retval EFI_NOT_FOUND Target for the specified routing data was not 4195 found. 4196 4197 **/ 4198 EFI_STATUS 4199 EFIAPI 4200 HiiConfigRoutingRouteConfig ( 4201 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 4202 IN CONST EFI_STRING Configuration, 4203 OUT EFI_STRING *Progress 4204 ) 4205 { 4206 HII_DATABASE_PRIVATE_DATA *Private; 4207 EFI_STRING StringPtr; 4208 EFI_STRING ConfigResp; 4209 UINTN Length; 4210 EFI_STATUS Status; 4211 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 4212 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; 4213 LIST_ENTRY *Link; 4214 HII_DATABASE_RECORD *Database; 4215 UINT8 *DevicePathPkg; 4216 UINT8 *CurrentDevicePath; 4217 EFI_HANDLE DriverHandle; 4218 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess; 4219 EFI_STRING AccessProgress; 4220 EFI_IFR_VARSTORE_EFI *EfiVarStoreInfo; 4221 BOOLEAN IsEfiVarstore; 4222 UINTN DevicePathSize; 4223 4224 if (This == NULL || Progress == NULL) { 4225 return EFI_INVALID_PARAMETER; 4226 } 4227 4228 if (Configuration == NULL) { 4229 *Progress = NULL; 4230 return EFI_INVALID_PARAMETER; 4231 } 4232 4233 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This); 4234 StringPtr = Configuration; 4235 *Progress = StringPtr; 4236 Database = NULL; 4237 AccessProgress = NULL; 4238 EfiVarStoreInfo= NULL; 4239 IsEfiVarstore = FALSE; 4240 4241 // 4242 // The first element of <MultiConfigResp> should be 4243 // <GuidHdr>, which is in 'GUID='<Guid> syntax. 4244 // 4245 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 4246 return EFI_INVALID_PARAMETER; 4247 } 4248 4249 while (*StringPtr != 0 && StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) == 0) { 4250 // 4251 // If parsing error, set Progress to the beginning of the <MultiConfigResp> 4252 // or most recent & before the error. 4253 // 4254 if (StringPtr == Configuration) { 4255 *Progress = StringPtr; 4256 } else { 4257 *Progress = StringPtr - 1; 4258 } 4259 4260 // 4261 // Process each <ConfigResp> of <MultiConfigResp> 4262 // 4263 Length = CalculateConfigStringLen (StringPtr); 4264 ConfigResp = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), StringPtr); 4265 if (ConfigResp == NULL) { 4266 return EFI_OUT_OF_RESOURCES; 4267 } 4268 // 4269 // Append '\0' to the end of ConfigRequest 4270 // 4271 *(ConfigResp + Length) = 0; 4272 4273 // 4274 // Get the UEFI device path 4275 // 4276 Status = GetDevicePath (ConfigResp, (UINT8 **) &DevicePath); 4277 if (EFI_ERROR (Status)) { 4278 FreePool (ConfigResp); 4279 return Status; 4280 } 4281 4282 // 4283 // Find driver which matches the routing data. 4284 // 4285 DriverHandle = NULL; 4286 for (Link = Private->DatabaseList.ForwardLink; 4287 Link != &Private->DatabaseList; 4288 Link = Link->ForwardLink 4289 ) { 4290 Database = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE); 4291 4292 if ((DevicePathPkg = Database->PackageList->DevicePathPkg) != NULL) { 4293 CurrentDevicePath = DevicePathPkg + sizeof (EFI_HII_PACKAGE_HEADER); 4294 DevicePathSize = GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) CurrentDevicePath); 4295 if ((CompareMem (DevicePath,CurrentDevicePath,DevicePathSize) == 0) && IsThisPackageList(Database, ConfigResp)) { 4296 DriverHandle = Database->DriverHandle; 4297 break; 4298 } 4299 } 4300 } 4301 4302 // 4303 // Try to find driver handle by device path. 4304 // 4305 if (DriverHandle == NULL) { 4306 TempDevicePath = DevicePath; 4307 Status = gBS->LocateDevicePath ( 4308 &gEfiDevicePathProtocolGuid, 4309 &TempDevicePath, 4310 &DriverHandle 4311 ); 4312 if (EFI_ERROR (Status) || (DriverHandle == NULL)) { 4313 // 4314 // Routing data does not match any known driver. 4315 // Set Progress to the 'G' in "GUID" of the routing header. 4316 // 4317 FreePool (DevicePath); 4318 *Progress = StringPtr; 4319 FreePool (ConfigResp); 4320 return EFI_NOT_FOUND; 4321 } 4322 } 4323 4324 FreePool (DevicePath); 4325 4326 // 4327 // Check whether this ConfigRequest is search from Efi varstore type storage. 4328 // 4329 Status = GetVarStoreType(Database, ConfigResp, &IsEfiVarstore, &EfiVarStoreInfo); 4330 if (EFI_ERROR (Status)) { 4331 return Status; 4332 } 4333 4334 if (IsEfiVarstore) { 4335 // 4336 // Call the SetVariable function to route settings. 4337 // 4338 Status = RouteConfigRespForEfiVarStore(This, EfiVarStoreInfo, ConfigResp, &AccessProgress); 4339 FreePool (EfiVarStoreInfo); 4340 } else { 4341 // 4342 // Call corresponding ConfigAccess protocol to route settings 4343 // 4344 Status = gBS->HandleProtocol ( 4345 DriverHandle, 4346 &gEfiHiiConfigAccessProtocolGuid, 4347 (VOID **) &ConfigAccess 4348 ); 4349 if (EFI_ERROR (Status)) { 4350 *Progress = StringPtr; 4351 FreePool (ConfigResp); 4352 return EFI_NOT_FOUND; 4353 } 4354 4355 Status = ConfigAccess->RouteConfig ( 4356 ConfigAccess, 4357 ConfigResp, 4358 &AccessProgress 4359 ); 4360 } 4361 if (EFI_ERROR (Status)) { 4362 ASSERT (AccessProgress != NULL); 4363 // 4364 // AccessProgress indicates the parsing progress on <ConfigResp>. 4365 // Map it to the progress on <MultiConfigResp> then return it. 4366 // 4367 *Progress = StrStr (StringPtr, AccessProgress); 4368 4369 FreePool (ConfigResp); 4370 return Status; 4371 } 4372 4373 FreePool (ConfigResp); 4374 ConfigResp = NULL; 4375 4376 // 4377 // Go to next <ConfigResp> (skip '&'). 4378 // 4379 StringPtr += Length; 4380 if (*StringPtr == 0) { 4381 *Progress = StringPtr; 4382 break; 4383 } 4384 4385 StringPtr++; 4386 4387 } 4388 4389 return EFI_SUCCESS; 4390 } 4391 4392 4393 /** 4394 This helper function is to be called by drivers to map configuration data 4395 stored in byte array ("block") formats such as UEFI Variables into current 4396 configuration strings. 4397 4398 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 4399 instance. 4400 @param ConfigRequest A null-terminated Unicode string in 4401 <ConfigRequest> format. 4402 @param Block Array of bytes defining the block's configuration. 4403 @param BlockSize Length in bytes of Block. 4404 @param Config Filled-in configuration string. String allocated 4405 by the function. Returned only if call is 4406 successful. It is <ConfigResp> string format. 4407 @param Progress A pointer to a string filled in with the offset of 4408 the most recent & before the first failing 4409 name/value pair (or the beginning of the string if 4410 the failure is in the first name / value pair) or 4411 the terminating NULL if all was successful. 4412 4413 @retval EFI_SUCCESS The request succeeded. Progress points to the null 4414 terminator at the end of the ConfigRequest 4415 string. 4416 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate Config. Progress 4417 points to the first character of ConfigRequest. 4418 @retval EFI_INVALID_PARAMETER Passing in a NULL for the ConfigRequest or 4419 Block parameter would result in this type of 4420 error. Progress points to the first character of 4421 ConfigRequest. 4422 @retval EFI_DEVICE_ERROR Block not large enough. Progress undefined. 4423 @retval EFI_INVALID_PARAMETER Encountered non <BlockName> formatted string. 4424 Block is left updated and Progress points at 4425 the "&" preceding the first non-<BlockName>. 4426 4427 **/ 4428 EFI_STATUS 4429 EFIAPI 4430 HiiBlockToConfig ( 4431 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 4432 IN CONST EFI_STRING ConfigRequest, 4433 IN CONST UINT8 *Block, 4434 IN CONST UINTN BlockSize, 4435 OUT EFI_STRING *Config, 4436 OUT EFI_STRING *Progress 4437 ) 4438 { 4439 HII_DATABASE_PRIVATE_DATA *Private; 4440 EFI_STRING StringPtr; 4441 UINTN Length; 4442 EFI_STATUS Status; 4443 EFI_STRING TmpPtr; 4444 UINT8 *TmpBuffer; 4445 UINTN Offset; 4446 UINTN Width; 4447 UINT8 *Value; 4448 EFI_STRING ValueStr; 4449 EFI_STRING ConfigElement; 4450 UINTN Index; 4451 UINT8 *TemBuffer; 4452 CHAR16 *TemString; 4453 CHAR16 TemChar; 4454 4455 TmpBuffer = NULL; 4456 4457 if (This == NULL || Progress == NULL || Config == NULL) { 4458 return EFI_INVALID_PARAMETER; 4459 } 4460 4461 if (Block == NULL || ConfigRequest == NULL) { 4462 *Progress = ConfigRequest; 4463 return EFI_INVALID_PARAMETER; 4464 } 4465 4466 4467 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This); 4468 ASSERT (Private != NULL); 4469 4470 StringPtr = ConfigRequest; 4471 ValueStr = NULL; 4472 Value = NULL; 4473 ConfigElement = NULL; 4474 4475 // 4476 // Allocate a fix length of memory to store Results. Reallocate memory for 4477 // Results if this fix length is insufficient. 4478 // 4479 *Config = (EFI_STRING) AllocateZeroPool (MAX_STRING_LENGTH); 4480 if (*Config == NULL) { 4481 return EFI_OUT_OF_RESOURCES; 4482 } 4483 4484 // 4485 // Jump <ConfigHdr> 4486 // 4487 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 4488 *Progress = StringPtr; 4489 Status = EFI_INVALID_PARAMETER; 4490 goto Exit; 4491 } 4492 while (*StringPtr != 0 && StrnCmp (StringPtr, L"PATH=", StrLen (L"PATH=")) != 0) { 4493 StringPtr++; 4494 } 4495 if (*StringPtr == 0) { 4496 *Progress = StringPtr - 1; 4497 Status = EFI_INVALID_PARAMETER; 4498 goto Exit; 4499 } 4500 4501 while (*StringPtr != L'&' && *StringPtr != 0) { 4502 StringPtr++; 4503 } 4504 if (*StringPtr == 0) { 4505 *Progress = StringPtr; 4506 4507 AppendToMultiString(Config, ConfigRequest); 4508 HiiToLower (*Config); 4509 4510 return EFI_SUCCESS; 4511 } 4512 // 4513 // Skip '&' 4514 // 4515 StringPtr++; 4516 4517 // 4518 // Copy <ConfigHdr> and an additional '&' to <ConfigResp> 4519 // 4520 TemChar = *StringPtr; 4521 *StringPtr = '\0'; 4522 AppendToMultiString(Config, ConfigRequest); 4523 *StringPtr = TemChar; 4524 4525 // 4526 // Parse each <RequestElement> if exists 4527 // Only <BlockName> format is supported by this help function. 4528 // <BlockName> ::= 'OFFSET='<Number>&'WIDTH='<Number> 4529 // 4530 while (*StringPtr != 0 && StrnCmp (StringPtr, L"OFFSET=", StrLen (L"OFFSET=")) == 0) { 4531 // 4532 // Back up the header of one <BlockName> 4533 // 4534 TmpPtr = StringPtr; 4535 4536 StringPtr += StrLen (L"OFFSET="); 4537 // 4538 // Get Offset 4539 // 4540 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 4541 if (EFI_ERROR (Status)) { 4542 *Progress = TmpPtr - 1; 4543 goto Exit; 4544 } 4545 Offset = 0; 4546 CopyMem ( 4547 &Offset, 4548 TmpBuffer, 4549 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN) 4550 ); 4551 FreePool (TmpBuffer); 4552 4553 StringPtr += Length; 4554 if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) { 4555 *Progress = TmpPtr - 1; 4556 Status = EFI_INVALID_PARAMETER; 4557 goto Exit; 4558 } 4559 StringPtr += StrLen (L"&WIDTH="); 4560 4561 // 4562 // Get Width 4563 // 4564 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 4565 if (EFI_ERROR (Status)) { 4566 *Progress = TmpPtr - 1; 4567 goto Exit; 4568 } 4569 Width = 0; 4570 CopyMem ( 4571 &Width, 4572 TmpBuffer, 4573 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN) 4574 ); 4575 FreePool (TmpBuffer); 4576 4577 StringPtr += Length; 4578 if (*StringPtr != 0 && *StringPtr != L'&') { 4579 *Progress = TmpPtr - 1; 4580 Status = EFI_INVALID_PARAMETER; 4581 goto Exit; 4582 } 4583 4584 // 4585 // Calculate Value and convert it to hex string. 4586 // 4587 if (Offset + Width > BlockSize) { 4588 *Progress = StringPtr; 4589 Status = EFI_DEVICE_ERROR; 4590 goto Exit; 4591 } 4592 4593 Value = (UINT8 *) AllocateZeroPool (Width); 4594 if (Value == NULL) { 4595 *Progress = ConfigRequest; 4596 Status = EFI_OUT_OF_RESOURCES; 4597 goto Exit; 4598 } 4599 4600 CopyMem (Value, (UINT8 *) Block + Offset, Width); 4601 4602 Length = Width * 2 + 1; 4603 ValueStr = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16)); 4604 if (ValueStr == NULL) { 4605 *Progress = ConfigRequest; 4606 Status = EFI_OUT_OF_RESOURCES; 4607 goto Exit; 4608 } 4609 4610 TemString = ValueStr; 4611 TemBuffer = Value + Width - 1; 4612 for (Index = 0; Index < Width; Index ++, TemBuffer --) { 4613 TemString += UnicodeValueToString (TemString, PREFIX_ZERO | RADIX_HEX, *TemBuffer, 2); 4614 } 4615 4616 FreePool (Value); 4617 Value = NULL; 4618 4619 // 4620 // Build a ConfigElement 4621 // 4622 Length += StringPtr - TmpPtr + 1 + StrLen (L"VALUE="); 4623 ConfigElement = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16)); 4624 if (ConfigElement == NULL) { 4625 Status = EFI_OUT_OF_RESOURCES; 4626 goto Exit; 4627 } 4628 CopyMem (ConfigElement, TmpPtr, (StringPtr - TmpPtr + 1) * sizeof (CHAR16)); 4629 if (*StringPtr == 0) { 4630 *(ConfigElement + (StringPtr - TmpPtr)) = L'&'; 4631 } 4632 *(ConfigElement + (StringPtr - TmpPtr) + 1) = 0; 4633 StrCatS (ConfigElement, Length, L"VALUE="); 4634 StrCatS (ConfigElement, Length, ValueStr); 4635 4636 AppendToMultiString (Config, ConfigElement); 4637 4638 FreePool (ConfigElement); 4639 FreePool (ValueStr); 4640 ConfigElement = NULL; 4641 ValueStr = NULL; 4642 4643 // 4644 // If '\0', parsing is finished. Otherwise skip '&' to continue 4645 // 4646 if (*StringPtr == 0) { 4647 break; 4648 } 4649 AppendToMultiString (Config, L"&"); 4650 StringPtr++; 4651 4652 } 4653 4654 if (*StringPtr != 0) { 4655 *Progress = StringPtr - 1; 4656 Status = EFI_INVALID_PARAMETER; 4657 goto Exit; 4658 } 4659 4660 HiiToLower (*Config); 4661 *Progress = StringPtr; 4662 return EFI_SUCCESS; 4663 4664 Exit: 4665 if (*Config != NULL) { 4666 FreePool (*Config); 4667 *Config = NULL; 4668 } 4669 if (ValueStr != NULL) { 4670 FreePool (ValueStr); 4671 } 4672 if (Value != NULL) { 4673 FreePool (Value); 4674 } 4675 if (ConfigElement != NULL) { 4676 FreePool (ConfigElement); 4677 } 4678 4679 return Status; 4680 4681 } 4682 4683 4684 /** 4685 This helper function is to be called by drivers to map configuration strings 4686 to configurations stored in byte array ("block") formats such as UEFI Variables. 4687 4688 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 4689 instance. 4690 @param ConfigResp A null-terminated Unicode string in <ConfigResp> 4691 format. 4692 @param Block A possibly null array of bytes representing the 4693 current block. Only bytes referenced in the 4694 ConfigResp string in the block are modified. If 4695 this parameter is null or if the *BlockSize 4696 parameter is (on input) shorter than required by 4697 the Configuration string, only the BlockSize 4698 parameter is updated and an appropriate status 4699 (see below) is returned. 4700 @param BlockSize The length of the Block in units of UINT8. On 4701 input, this is the size of the Block. On output, 4702 if successful, contains the largest index of the 4703 modified byte in the Block, or the required buffer 4704 size if the Block is not large enough. 4705 @param Progress On return, points to an element of the ConfigResp 4706 string filled in with the offset of the most 4707 recent '&' before the first failing name / value 4708 pair (or the beginning of the string if the 4709 failure is in the first name / value pair) or the 4710 terminating NULL if all was successful. 4711 4712 @retval EFI_SUCCESS The request succeeded. Progress points to the null 4713 terminator at the end of the ConfigResp string. 4714 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate Config. Progress 4715 points to the first character of ConfigResp. 4716 @retval EFI_INVALID_PARAMETER Passing in a NULL for the ConfigResp or 4717 Block parameter would result in this type of 4718 error. Progress points to the first character of 4719 ConfigResp. 4720 @retval EFI_INVALID_PARAMETER Encountered non <BlockName> formatted name / 4721 value pair. Block is left updated and 4722 Progress points at the '&' preceding the first 4723 non-<BlockName>. 4724 @retval EFI_BUFFER_TOO_SMALL Block not large enough. Progress undefined. 4725 BlockSize is updated with the required buffer size. 4726 @retval EFI_NOT_FOUND Target for the specified routing data was not found. 4727 Progress points to the "G" in "GUID" of the errant 4728 routing data. 4729 4730 **/ 4731 EFI_STATUS 4732 EFIAPI 4733 HiiConfigToBlock ( 4734 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 4735 IN CONST EFI_STRING ConfigResp, 4736 IN OUT UINT8 *Block, 4737 IN OUT UINTN *BlockSize, 4738 OUT EFI_STRING *Progress 4739 ) 4740 { 4741 HII_DATABASE_PRIVATE_DATA *Private; 4742 EFI_STRING StringPtr; 4743 EFI_STRING TmpPtr; 4744 UINTN Length; 4745 EFI_STATUS Status; 4746 UINT8 *TmpBuffer; 4747 UINTN Offset; 4748 UINTN Width; 4749 UINT8 *Value; 4750 UINTN BufferSize; 4751 UINTN MaxBlockSize; 4752 4753 TmpBuffer = NULL; 4754 4755 if (This == NULL || BlockSize == NULL || Progress == NULL) { 4756 return EFI_INVALID_PARAMETER; 4757 } 4758 4759 *Progress = ConfigResp; 4760 if (ConfigResp == NULL) { 4761 return EFI_INVALID_PARAMETER; 4762 } 4763 4764 Private = CONFIG_ROUTING_DATABASE_PRIVATE_DATA_FROM_THIS (This); 4765 ASSERT (Private != NULL); 4766 4767 StringPtr = ConfigResp; 4768 BufferSize = *BlockSize; 4769 Value = NULL; 4770 MaxBlockSize = 0; 4771 4772 // 4773 // Jump <ConfigHdr> 4774 // 4775 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 4776 *Progress = StringPtr; 4777 Status = EFI_INVALID_PARAMETER; 4778 goto Exit; 4779 } 4780 while (*StringPtr != 0 && StrnCmp (StringPtr, L"PATH=", StrLen (L"PATH=")) != 0) { 4781 StringPtr++; 4782 } 4783 if (*StringPtr == 0) { 4784 *Progress = StringPtr; 4785 Status = EFI_INVALID_PARAMETER; 4786 goto Exit; 4787 } 4788 4789 while (*StringPtr != L'&' && *StringPtr != 0) { 4790 StringPtr++; 4791 } 4792 if (*StringPtr == 0) { 4793 *Progress = StringPtr; 4794 Status = EFI_INVALID_PARAMETER; 4795 goto Exit; 4796 } 4797 4798 // 4799 // Parse each <ConfigElement> if exists 4800 // Only '&'<BlockConfig> format is supported by this help function. 4801 // <BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE='<Number> 4802 // 4803 while (*StringPtr != 0 && StrnCmp (StringPtr, L"&OFFSET=", StrLen (L"&OFFSET=")) == 0) { 4804 TmpPtr = StringPtr; 4805 StringPtr += StrLen (L"&OFFSET="); 4806 // 4807 // Get Offset 4808 // 4809 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 4810 if (EFI_ERROR (Status)) { 4811 *Progress = TmpPtr; 4812 goto Exit; 4813 } 4814 Offset = 0; 4815 CopyMem ( 4816 &Offset, 4817 TmpBuffer, 4818 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN) 4819 ); 4820 FreePool (TmpBuffer); 4821 4822 StringPtr += Length; 4823 if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) { 4824 *Progress = TmpPtr; 4825 Status = EFI_INVALID_PARAMETER; 4826 goto Exit; 4827 } 4828 StringPtr += StrLen (L"&WIDTH="); 4829 4830 // 4831 // Get Width 4832 // 4833 Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length); 4834 if (EFI_ERROR (Status)) { 4835 *Progress = TmpPtr; 4836 goto Exit; 4837 } 4838 Width = 0; 4839 CopyMem ( 4840 &Width, 4841 TmpBuffer, 4842 (((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN) 4843 ); 4844 FreePool (TmpBuffer); 4845 4846 StringPtr += Length; 4847 if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) != 0) { 4848 *Progress = TmpPtr; 4849 Status = EFI_INVALID_PARAMETER; 4850 goto Exit; 4851 } 4852 StringPtr += StrLen (L"&VALUE="); 4853 4854 // 4855 // Get Value 4856 // 4857 Status = GetValueOfNumber (StringPtr, &Value, &Length); 4858 if (EFI_ERROR (Status)) { 4859 *Progress = TmpPtr; 4860 goto Exit; 4861 } 4862 4863 StringPtr += Length; 4864 if (*StringPtr != 0 && *StringPtr != L'&') { 4865 *Progress = TmpPtr; 4866 Status = EFI_INVALID_PARAMETER; 4867 goto Exit; 4868 } 4869 4870 // 4871 // Update the Block with configuration info 4872 // 4873 if ((Block != NULL) && (Offset + Width <= BufferSize)) { 4874 CopyMem (Block + Offset, Value, Width); 4875 } 4876 if (Offset + Width > MaxBlockSize) { 4877 MaxBlockSize = Offset + Width; 4878 } 4879 4880 FreePool (Value); 4881 Value = NULL; 4882 4883 // 4884 // If '\0', parsing is finished. 4885 // 4886 if (*StringPtr == 0) { 4887 break; 4888 } 4889 } 4890 4891 // 4892 // The input string is not ConfigResp format, return error. 4893 // 4894 if (*StringPtr != 0) { 4895 *Progress = StringPtr; 4896 Status = EFI_INVALID_PARAMETER; 4897 goto Exit; 4898 } 4899 4900 *Progress = StringPtr + StrLen (StringPtr); 4901 *BlockSize = MaxBlockSize - 1; 4902 4903 if (MaxBlockSize > BufferSize) { 4904 *BlockSize = MaxBlockSize; 4905 if (Block != NULL) { 4906 return EFI_BUFFER_TOO_SMALL; 4907 } 4908 } 4909 4910 if (Block == NULL) { 4911 *Progress = ConfigResp; 4912 return EFI_INVALID_PARAMETER; 4913 } 4914 4915 return EFI_SUCCESS; 4916 4917 Exit: 4918 4919 if (Value != NULL) { 4920 FreePool (Value); 4921 } 4922 return Status; 4923 } 4924 4925 4926 /** 4927 This helper function is to be called by drivers to extract portions of 4928 a larger configuration string. 4929 4930 @param This A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL 4931 instance. 4932 @param Configuration A null-terminated Unicode string in 4933 <MultiConfigAltResp> format. 4934 @param Guid A pointer to the GUID value to search for in the 4935 routing portion of the ConfigResp string when 4936 retrieving the requested data. If Guid is NULL, 4937 then all GUID values will be searched for. 4938 @param Name A pointer to the NAME value to search for in the 4939 routing portion of the ConfigResp string when 4940 retrieving the requested data. If Name is NULL, 4941 then all Name values will be searched for. 4942 @param DevicePath A pointer to the PATH value to search for in the 4943 routing portion of the ConfigResp string when 4944 retrieving the requested data. If DevicePath is 4945 NULL, then all DevicePath values will be searched 4946 for. 4947 @param AltCfgId A pointer to the ALTCFG value to search for in the 4948 routing portion of the ConfigResp string when 4949 retrieving the requested data. If this parameter 4950 is NULL, then the current setting will be 4951 retrieved. 4952 @param AltCfgResp A pointer to a buffer which will be allocated by 4953 the function which contains the retrieved string 4954 as requested. This buffer is only allocated if 4955 the call was successful. It is <ConfigResp> format. 4956 4957 @retval EFI_SUCCESS The request succeeded. The requested data was 4958 extracted and placed in the newly allocated 4959 AltCfgResp buffer. 4960 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate AltCfgResp. 4961 @retval EFI_INVALID_PARAMETER Any parameter is invalid. 4962 @retval EFI_NOT_FOUND Target for the specified routing data was not 4963 found. 4964 4965 **/ 4966 EFI_STATUS 4967 EFIAPI 4968 HiiGetAltCfg ( 4969 IN CONST EFI_HII_CONFIG_ROUTING_PROTOCOL *This, 4970 IN CONST EFI_STRING Configuration, 4971 IN CONST EFI_GUID *Guid, 4972 IN CONST EFI_STRING Name, 4973 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, 4974 IN CONST UINT16 *AltCfgId, 4975 OUT EFI_STRING *AltCfgResp 4976 ) 4977 { 4978 EFI_STATUS Status; 4979 EFI_STRING StringPtr; 4980 EFI_STRING HdrStart; 4981 EFI_STRING HdrEnd; 4982 EFI_STRING TmpPtr; 4983 UINTN Length; 4984 EFI_STRING GuidStr; 4985 EFI_STRING NameStr; 4986 EFI_STRING PathStr; 4987 EFI_STRING AltIdStr; 4988 EFI_STRING Result; 4989 BOOLEAN GuidFlag; 4990 BOOLEAN NameFlag; 4991 BOOLEAN PathFlag; 4992 4993 HdrStart = NULL; 4994 HdrEnd = NULL; 4995 GuidStr = NULL; 4996 NameStr = NULL; 4997 PathStr = NULL; 4998 AltIdStr = NULL; 4999 Result = NULL; 5000 GuidFlag = FALSE; 5001 NameFlag = FALSE; 5002 PathFlag = FALSE; 5003 5004 if (This == NULL || Configuration == NULL || AltCfgResp == NULL) { 5005 return EFI_INVALID_PARAMETER; 5006 } 5007 5008 StringPtr = Configuration; 5009 if (StrnCmp (StringPtr, L"GUID=", StrLen (L"GUID=")) != 0) { 5010 return EFI_INVALID_PARAMETER; 5011 } 5012 5013 // 5014 // Generate the sub string for later matching. 5015 // 5016 GenerateSubStr (L"GUID=", sizeof (EFI_GUID), (VOID *) Guid, 1, &GuidStr); 5017 GenerateSubStr ( 5018 L"PATH=", 5019 GetDevicePathSize ((EFI_DEVICE_PATH_PROTOCOL *) DevicePath), 5020 (VOID *) DevicePath, 5021 1, 5022 &PathStr 5023 ); 5024 if (AltCfgId != NULL) { 5025 GenerateSubStr (L"ALTCFG=", sizeof (UINT16), (VOID *) AltCfgId, 3, &AltIdStr); 5026 } 5027 if (Name != NULL) { 5028 GenerateSubStr (L"NAME=", StrLen (Name) * sizeof (CHAR16), (VOID *) Name, 2, &NameStr); 5029 } else { 5030 GenerateSubStr (L"NAME=", 0, NULL, 2, &NameStr); 5031 } 5032 5033 while (*StringPtr != 0) { 5034 // 5035 // Try to match the GUID 5036 // 5037 if (!GuidFlag) { 5038 TmpPtr = StrStr (StringPtr, GuidStr); 5039 if (TmpPtr == NULL) { 5040 Status = EFI_NOT_FOUND; 5041 goto Exit; 5042 } 5043 HdrStart = TmpPtr; 5044 5045 // 5046 // Jump to <NameHdr> 5047 // 5048 if (Guid != NULL) { 5049 StringPtr = TmpPtr + StrLen (GuidStr); 5050 } else { 5051 StringPtr = StrStr (TmpPtr, L"NAME="); 5052 if (StringPtr == NULL) { 5053 Status = EFI_NOT_FOUND; 5054 goto Exit; 5055 } 5056 } 5057 GuidFlag = TRUE; 5058 } 5059 5060 // 5061 // Try to match the NAME 5062 // 5063 if (GuidFlag && !NameFlag) { 5064 if (StrnCmp (StringPtr, NameStr, StrLen (NameStr)) != 0) { 5065 GuidFlag = FALSE; 5066 } else { 5067 // 5068 // Jump to <PathHdr> 5069 // 5070 if (Name != NULL) { 5071 StringPtr += StrLen (NameStr); 5072 } else { 5073 StringPtr = StrStr (StringPtr, L"PATH="); 5074 if (StringPtr == NULL) { 5075 Status = EFI_NOT_FOUND; 5076 goto Exit; 5077 } 5078 } 5079 NameFlag = TRUE; 5080 } 5081 } 5082 5083 // 5084 // Try to match the DevicePath 5085 // 5086 if (GuidFlag && NameFlag && !PathFlag) { 5087 if (StrnCmp (StringPtr, PathStr, StrLen (PathStr)) != 0) { 5088 GuidFlag = FALSE; 5089 NameFlag = FALSE; 5090 } else { 5091 // 5092 // Jump to '&' before <DescHdr> or <ConfigBody> 5093 // 5094 if (DevicePath != NULL) { 5095 StringPtr += StrLen (PathStr); 5096 } else { 5097 StringPtr = StrStr (StringPtr, L"&"); 5098 if (StringPtr == NULL) { 5099 Status = EFI_NOT_FOUND; 5100 goto Exit; 5101 } 5102 StringPtr ++; 5103 } 5104 PathFlag = TRUE; 5105 HdrEnd = StringPtr; 5106 } 5107 } 5108 5109 // 5110 // Try to match the AltCfgId 5111 // 5112 if (GuidFlag && NameFlag && PathFlag) { 5113 if (AltCfgId == NULL) { 5114 // 5115 // Return Current Setting when AltCfgId is NULL. 5116 // 5117 Status = OutputConfigBody (StringPtr, &Result); 5118 goto Exit; 5119 } 5120 // 5121 // Search the <ConfigAltResp> to get the <AltResp> with AltCfgId. 5122 // 5123 if (StrnCmp (StringPtr, AltIdStr, StrLen (AltIdStr)) != 0) { 5124 GuidFlag = FALSE; 5125 NameFlag = FALSE; 5126 PathFlag = FALSE; 5127 } else { 5128 // 5129 // Skip AltIdStr and & 5130 // 5131 StringPtr = StringPtr + StrLen (AltIdStr); 5132 Status = OutputConfigBody (StringPtr, &Result); 5133 goto Exit; 5134 } 5135 } 5136 } 5137 5138 Status = EFI_NOT_FOUND; 5139 5140 Exit: 5141 *AltCfgResp = NULL; 5142 if (!EFI_ERROR (Status) && (Result != NULL)) { 5143 // 5144 // Copy the <ConfigHdr> and <ConfigBody> 5145 // 5146 Length = HdrEnd - HdrStart + StrLen (Result) + 1; 5147 *AltCfgResp = AllocateZeroPool (Length * sizeof (CHAR16)); 5148 if (*AltCfgResp == NULL) { 5149 Status = EFI_OUT_OF_RESOURCES; 5150 } else { 5151 StrnCpyS (*AltCfgResp, Length, HdrStart, HdrEnd - HdrStart); 5152 StrCatS (*AltCfgResp, Length, Result); 5153 Status = EFI_SUCCESS; 5154 } 5155 } 5156 5157 if (GuidStr != NULL) { 5158 FreePool (GuidStr); 5159 } 5160 if (NameStr != NULL) { 5161 FreePool (NameStr); 5162 } 5163 if (PathStr != NULL) { 5164 FreePool (PathStr); 5165 } 5166 if (AltIdStr != NULL) { 5167 FreePool (AltIdStr); 5168 } 5169 if (Result != NULL) { 5170 FreePool (Result); 5171 } 5172 5173 return Status; 5174 5175 } 5176 5177 5178