1 /** @file 2 3 Vfr common library functions. 4 5 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR> 6 This program and the accompanying materials 7 are licensed and made available under the terms and conditions of the BSD License 8 which accompanies this distribution. The full text of the license may be found at 9 http://opensource.org/licenses/bsd-license.php 10 11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 13 14 **/ 15 16 #include "stdio.h" 17 #include "stdlib.h" 18 #include "CommonLib.h" 19 #include "VfrUtilityLib.h" 20 #include "VfrFormPkg.h" 21 22 VOID 23 CVfrBinaryOutput::WriteLine ( 24 IN FILE *pFile, 25 IN UINT32 LineBytes, 26 IN CONST CHAR8 *LineHeader, 27 IN CHAR8 *BlkBuf, 28 IN UINT32 BlkSize 29 ) 30 { 31 UINT32 Index; 32 33 if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) { 34 return; 35 } 36 37 for (Index = 0; Index < BlkSize; Index++) { 38 if ((Index % LineBytes) == 0) { 39 fprintf (pFile, "\n%s", LineHeader); 40 } 41 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]); 42 } 43 } 44 45 VOID 46 CVfrBinaryOutput::WriteEnd ( 47 IN FILE *pFile, 48 IN UINT32 LineBytes, 49 IN CONST CHAR8 *LineHeader, 50 IN CHAR8 *BlkBuf, 51 IN UINT32 BlkSize 52 ) 53 { 54 UINT32 Index; 55 56 if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) { 57 return; 58 } 59 60 for (Index = 0; Index < BlkSize - 1; Index++) { 61 if ((Index % LineBytes) == 0) { 62 fprintf (pFile, "\n%s", LineHeader); 63 } 64 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]); 65 } 66 67 if ((Index % LineBytes) == 0) { 68 fprintf (pFile, "\n%s", LineHeader); 69 } 70 fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]); 71 } 72 73 SConfigInfo::SConfigInfo ( 74 IN UINT8 Type, 75 IN UINT16 Offset, 76 IN UINT32 Width, 77 IN EFI_IFR_TYPE_VALUE Value 78 ) 79 { 80 mNext = NULL; 81 mOffset = Offset; 82 mWidth = (UINT16)Width; 83 mValue = new UINT8[mWidth]; 84 if (mValue == NULL) { 85 return; 86 } 87 88 switch (Type) { 89 case EFI_IFR_TYPE_NUM_SIZE_8 : 90 memcpy (mValue, &Value.u8, mWidth); 91 break; 92 case EFI_IFR_TYPE_NUM_SIZE_16 : 93 memcpy (mValue, &Value.u16, mWidth); 94 break; 95 case EFI_IFR_TYPE_NUM_SIZE_32 : 96 memcpy (mValue, &Value.u32, mWidth); 97 break; 98 case EFI_IFR_TYPE_NUM_SIZE_64 : 99 memcpy (mValue, &Value.u64, mWidth); 100 break; 101 case EFI_IFR_TYPE_BOOLEAN : 102 memcpy (mValue, &Value.b, mWidth); 103 break; 104 case EFI_IFR_TYPE_TIME : 105 memcpy (mValue, &Value.time, mWidth); 106 break; 107 case EFI_IFR_TYPE_DATE : 108 memcpy (mValue, &Value.date, mWidth); 109 break; 110 case EFI_IFR_TYPE_STRING : 111 memcpy (mValue, &Value.string, mWidth); 112 break; 113 case EFI_IFR_TYPE_BUFFER : 114 memcpy (mValue, &Value.u8, mWidth); 115 break; 116 117 case EFI_IFR_TYPE_OTHER : 118 return; 119 } 120 } 121 122 SConfigInfo::~SConfigInfo ( 123 VOID 124 ) 125 { 126 BUFFER_SAFE_FREE (mValue); 127 } 128 129 SConfigItem::SConfigItem ( 130 IN CHAR8 *Name, 131 IN EFI_GUID *Guid, 132 IN CHAR8 *Id 133 ) 134 { 135 mName = NULL; 136 mGuid = NULL; 137 mId = NULL; 138 mInfoStrList = NULL; 139 mNext = NULL; 140 141 if (Name != NULL) { 142 if ((mName = new CHAR8[strlen (Name) + 1]) != NULL) { 143 strcpy (mName, Name); 144 } 145 } 146 147 if (Guid != NULL) { 148 if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) { 149 memcpy (mGuid, Guid, sizeof (EFI_GUID)); 150 } 151 } 152 153 if (Id != NULL) { 154 if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) { 155 strcpy (mId, Id); 156 } 157 } 158 } 159 160 SConfigItem::SConfigItem ( 161 IN CHAR8 *Name, 162 IN EFI_GUID *Guid, 163 IN CHAR8 *Id, 164 IN UINT8 Type, 165 IN UINT16 Offset, 166 IN UINT16 Width, 167 IN EFI_IFR_TYPE_VALUE Value 168 ) 169 { 170 mName = NULL; 171 mGuid = NULL; 172 mId = NULL; 173 mInfoStrList = NULL; 174 mNext = NULL; 175 176 if (Name != NULL) { 177 if ((mName = new CHAR8[strlen (Name) + 1]) != NULL) { 178 strcpy (mName, Name); 179 } 180 } 181 182 if (Guid != NULL) { 183 if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) { 184 memcpy (mGuid, Guid, sizeof (EFI_GUID)); 185 } 186 } 187 188 if (Id != NULL) { 189 if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) { 190 strcpy (mId, Id); 191 } 192 } 193 194 mInfoStrList = new SConfigInfo(Type, Offset, Width, Value); 195 } 196 197 SConfigItem::~SConfigItem ( 198 VOID 199 ) 200 { 201 SConfigInfo *Info; 202 203 BUFFER_SAFE_FREE (mName); 204 BUFFER_SAFE_FREE (mGuid); 205 BUFFER_SAFE_FREE (mId); 206 while (mInfoStrList != NULL) { 207 Info = mInfoStrList; 208 mInfoStrList = mInfoStrList->mNext; 209 210 BUFFER_SAFE_FREE (Info); 211 } 212 } 213 214 UINT8 215 CVfrBufferConfig::Register ( 216 IN CHAR8 *Name, 217 IN EFI_GUID *Guid, 218 IN CHAR8 *Id 219 ) 220 { 221 SConfigItem *pNew; 222 223 if (Select (Name, Guid) == 0) { 224 return 1; 225 } 226 227 if ((pNew = new SConfigItem (Name, Guid, Id)) == NULL) { 228 return 2; 229 } 230 231 if (mItemListHead == NULL) { 232 mItemListHead = pNew; 233 mItemListTail = pNew; 234 } else { 235 mItemListTail->mNext = pNew; 236 mItemListTail = pNew; 237 } 238 mItemListPos = pNew; 239 240 return 0; 241 } 242 243 VOID 244 CVfrBufferConfig::Open ( 245 VOID 246 ) 247 { 248 mItemListPos = mItemListHead; 249 } 250 251 BOOLEAN 252 CVfrBufferConfig::Eof( 253 VOID 254 ) 255 { 256 return (mItemListPos == NULL) ? TRUE : FALSE; 257 } 258 259 UINT8 260 CVfrBufferConfig::Select ( 261 IN CHAR8 *Name, 262 IN EFI_GUID *Guid, 263 IN CHAR8 *Id 264 ) 265 { 266 SConfigItem *p; 267 268 if (Name == NULL || Guid == NULL) { 269 mItemListPos = mItemListHead; 270 return 0; 271 } else { 272 for (p = mItemListHead; p != NULL; p = p->mNext) { 273 if ((strcmp (p->mName, Name) != 0) || (memcmp (p->mGuid, Guid, sizeof (EFI_GUID)) != 0)) { 274 continue; 275 } 276 277 if (Id != NULL) { 278 if (p->mId == NULL || strcmp (p->mId, Id) != 0) { 279 continue; 280 } 281 } else if (p->mId != NULL) { 282 continue; 283 } 284 285 mItemListPos = p; 286 return 0; 287 } 288 } 289 290 return 1; 291 } 292 293 UINT8 294 CVfrBufferConfig::Write ( 295 IN CONST CHAR8 Mode, 296 IN CHAR8 *Name, 297 IN EFI_GUID *Guid, 298 IN CHAR8 *Id, 299 IN UINT8 Type, 300 IN UINT16 Offset, 301 IN UINT32 Width, 302 IN EFI_IFR_TYPE_VALUE Value 303 ) 304 { 305 UINT8 Ret; 306 SConfigItem *pItem; 307 SConfigInfo *pInfo; 308 309 if ((Ret = Select (Name, Guid)) != 0) { 310 return Ret; 311 } 312 313 switch (Mode) { 314 case 'a' : // add 315 if (Select (Name, Guid, Id) != 0) { 316 if ((pItem = new SConfigItem (Name, Guid, Id, Type, Offset, (UINT16) Width, Value)) == NULL) { 317 return 2; 318 } 319 if (mItemListHead == NULL) { 320 mItemListHead = pItem; 321 mItemListTail = pItem; 322 } else { 323 mItemListTail->mNext = pItem; 324 mItemListTail = pItem; 325 } 326 mItemListPos = pItem; 327 } else { 328 // tranverse the list to find out if there's already the value for the same offset 329 for (pInfo = mItemListPos->mInfoStrList; pInfo != NULL; pInfo = pInfo->mNext) { 330 if (pInfo->mOffset == Offset) { 331 return 0; 332 } 333 } 334 if((pInfo = new SConfigInfo (Type, Offset, Width, Value)) == NULL) { 335 return 2; 336 } 337 pInfo->mNext = mItemListPos->mInfoStrList; 338 mItemListPos->mInfoStrList = pInfo; 339 } 340 break; 341 342 case 'd' : // delete 343 if (mItemListHead == mItemListPos) { 344 mItemListHead = mItemListPos->mNext; 345 delete mItemListPos; 346 break; 347 } 348 349 for (pItem = mItemListHead; pItem->mNext != mItemListPos; pItem = pItem->mNext) 350 ; 351 352 pItem->mNext = mItemListPos->mNext; 353 if (mItemListTail == mItemListPos) { 354 mItemListTail = pItem; 355 } 356 delete mItemListPos; 357 mItemListPos = pItem->mNext; 358 break; 359 360 case 'i' : // set info 361 if (mItemListPos->mId != NULL) { 362 delete mItemListPos->mId; 363 } 364 mItemListPos->mId = NULL; 365 if (Id != NULL) { 366 if ((mItemListPos->mId = new CHAR8[strlen (Id) + 1]) == NULL) { 367 return 2; 368 } 369 strcpy (mItemListPos->mId, Id); 370 } 371 break; 372 373 default : 374 return 1; 375 } 376 377 return 0; 378 } 379 380 381 VOID 382 CVfrBufferConfig::Close ( 383 VOID 384 ) 385 { 386 mItemListPos = NULL; 387 } 388 389 #define BYTES_PRE_LINE 0x10 390 391 VOID 392 CVfrBufferConfig::OutputCFile ( 393 IN FILE *pFile, 394 IN CHAR8 *BaseName 395 ) 396 { 397 CVfrBinaryOutput Output; 398 SConfigItem *Item; 399 SConfigInfo *Info; 400 UINT32 TotalLen; 401 402 if (pFile == NULL) { 403 return; 404 } 405 406 for (Item = mItemListHead; Item != NULL; Item = Item->mNext) { 407 if (Item->mId != NULL || Item->mInfoStrList == NULL) { 408 continue; 409 } 410 fprintf (pFile, "\nunsigned char %s%sBlockName[] = {", BaseName, Item->mName); 411 412 TotalLen = sizeof (UINT32); 413 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) { 414 TotalLen += sizeof (UINT16) * 2; 415 } 416 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&TotalLen, sizeof (UINT32)); 417 418 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) { 419 fprintf (pFile, "\n"); 420 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mOffset, sizeof (UINT16)); 421 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mWidth, sizeof (UINT16)); 422 } 423 fprintf (pFile, "\n};\n"); 424 } 425 426 for (Item = mItemListHead; Item != NULL; Item = Item->mNext) { 427 if (Item->mId != NULL && Item->mInfoStrList != NULL) { 428 fprintf (pFile, "\nunsigned char %s%sDefault%s[] = {", BaseName, Item->mName, Item->mId); 429 430 TotalLen = sizeof (UINT32); 431 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) { 432 TotalLen += Info->mWidth + sizeof (UINT16) * 2; 433 } 434 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&TotalLen, sizeof (UINT32)); 435 436 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) { 437 fprintf (pFile, "\n"); 438 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mOffset, sizeof (UINT16)); 439 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mWidth, sizeof (UINT16)); 440 if (Info->mNext == NULL) { 441 Output.WriteEnd (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)Info->mValue, Info->mWidth); 442 } else { 443 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)Info->mValue, Info->mWidth); 444 } 445 } 446 fprintf (pFile, "\n};\n"); 447 } 448 } 449 } 450 451 CVfrBufferConfig::CVfrBufferConfig ( 452 VOID 453 ) 454 { 455 mItemListHead = NULL; 456 mItemListTail = NULL; 457 mItemListPos = NULL; 458 } 459 460 CVfrBufferConfig::~CVfrBufferConfig ( 461 VOID 462 ) 463 { 464 SConfigItem *p; 465 466 while (mItemListHead != NULL) { 467 p = mItemListHead; 468 mItemListHead = mItemListHead->mNext; 469 delete p; 470 } 471 472 mItemListHead = NULL; 473 mItemListTail = NULL; 474 mItemListPos = NULL; 475 } 476 477 CVfrBufferConfig gCVfrBufferConfig; 478 479 static struct { 480 CONST CHAR8 *mTypeName; 481 UINT8 mType; 482 UINT32 mSize; 483 UINT32 mAlign; 484 } gInternalTypesTable [] = { 485 {"UINT64", EFI_IFR_TYPE_NUM_SIZE_64, sizeof (UINT64), sizeof (UINT64)}, 486 {"UINT32", EFI_IFR_TYPE_NUM_SIZE_32, sizeof (UINT32), sizeof (UINT32)}, 487 {"UINT16", EFI_IFR_TYPE_NUM_SIZE_16, sizeof (UINT16), sizeof (UINT16)}, 488 {"UINT8", EFI_IFR_TYPE_NUM_SIZE_8, sizeof (UINT8), sizeof (UINT8)}, 489 {"BOOLEAN", EFI_IFR_TYPE_BOOLEAN, sizeof (BOOLEAN), sizeof (BOOLEAN)}, 490 {"EFI_HII_DATE", EFI_IFR_TYPE_DATE, sizeof (EFI_HII_DATE), sizeof (UINT16)}, 491 {"EFI_STRING_ID", EFI_IFR_TYPE_STRING, sizeof (EFI_STRING_ID),sizeof (EFI_STRING_ID)}, 492 {"EFI_HII_TIME", EFI_IFR_TYPE_TIME, sizeof (EFI_HII_TIME), sizeof (UINT8)}, 493 {"EFI_HII_REF", EFI_IFR_TYPE_REF, sizeof (EFI_HII_REF), sizeof (EFI_GUID)}, 494 {NULL, EFI_IFR_TYPE_OTHER, 0, 0} 495 }; 496 497 STATIC 498 BOOLEAN 499 _IS_INTERNAL_TYPE ( 500 IN CHAR8 *TypeName 501 ) 502 { 503 UINT32 Index; 504 505 if (TypeName == NULL) { 506 return FALSE; 507 } 508 509 for (Index = 0; gInternalTypesTable[Index].mTypeName != NULL; Index++) { 510 if (strcmp (TypeName, gInternalTypesTable[Index].mTypeName) == 0) { 511 return TRUE; 512 } 513 } 514 515 return FALSE; 516 } 517 518 STATIC 519 CHAR8 * 520 TrimHex ( 521 IN CHAR8 *Str, 522 OUT bool *IsHex 523 ) 524 { 525 *IsHex = FALSE; 526 527 while (*Str && *Str == ' ') { 528 Str++; 529 } 530 while (*Str && *Str == '0') { 531 Str++; 532 } 533 if (*Str && (*Str == 'x' || *Str == 'X')) { 534 Str++; 535 *IsHex = TRUE; 536 } 537 538 return Str; 539 } 540 541 UINT32 542 _STR2U32 ( 543 IN CHAR8 *Str 544 ) 545 { 546 bool IsHex; 547 UINT32 Value; 548 CHAR8 c; 549 550 Str = TrimHex (Str, &IsHex); 551 for (Value = 0; (c = *Str) != '\0'; Str++) { 552 // 553 // BUG: does not handle overflow here 554 // 555 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10); 556 557 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) { 558 Value += (c - 'a' + 10); 559 } 560 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) { 561 Value += (c - 'A' + 10); 562 } 563 if (c >= '0' && c <= '9') { 564 Value += (c - '0'); 565 } 566 } 567 568 return Value; 569 } 570 571 VOID 572 CVfrVarDataTypeDB::RegisterNewType ( 573 IN SVfrDataType *New 574 ) 575 { 576 New->mNext = mDataTypeList; 577 mDataTypeList = New; 578 } 579 580 EFI_VFR_RETURN_CODE 581 CVfrVarDataTypeDB::ExtractStructTypeName ( 582 IN CHAR8 *&VarStr, 583 OUT CHAR8 *TName 584 ) 585 { 586 if (TName == NULL) { 587 return VFR_RETURN_FATAL_ERROR; 588 } 589 590 while((*VarStr != '\0') && (*VarStr != '.')) { 591 *TName = *VarStr; 592 VarStr++; 593 TName++; 594 } 595 *TName = '\0'; 596 if (*VarStr == '.') { 597 VarStr++; 598 } 599 600 return VFR_RETURN_SUCCESS; 601 } 602 603 EFI_VFR_RETURN_CODE 604 CVfrVarDataTypeDB::ExtractFieldNameAndArrary ( 605 IN CHAR8 *&VarStr, 606 IN CHAR8 *FName, 607 OUT UINT32 &ArrayIdx 608 ) 609 { 610 UINT32 Idx; 611 CHAR8 ArrayStr[MAX_NAME_LEN + 1]; 612 613 ArrayIdx = INVALID_ARRAY_INDEX; 614 615 if (FName == NULL) { 616 return VFR_RETURN_FATAL_ERROR; 617 } 618 619 while((*VarStr != '\0') && 620 (*VarStr != '.') && 621 (*VarStr != '[') && 622 (*VarStr != ']')) { 623 *FName = *VarStr; 624 VarStr++; 625 FName++; 626 } 627 *FName = '\0'; 628 629 switch (*VarStr) { 630 case '.' : 631 VarStr++; 632 case '\0': 633 return VFR_RETURN_SUCCESS; 634 case '[' : 635 VarStr++; 636 for (Idx = 0; (Idx < MAX_NAME_LEN) && (*VarStr != '\0') && (*VarStr != ']'); VarStr++, Idx++) { 637 ArrayStr[Idx] = *VarStr; 638 } 639 ArrayStr[Idx] = '\0'; 640 641 if ((*VarStr != ']') && (ArrayStr[0] == '\0')) { 642 return VFR_RETURN_DATA_STRING_ERROR; 643 } 644 ArrayIdx = _STR2U32 (ArrayStr); 645 if (*VarStr == ']') { 646 VarStr++; 647 } 648 if (*VarStr == '.') { 649 VarStr++; 650 } 651 return VFR_RETURN_SUCCESS; 652 case ']': 653 return VFR_RETURN_DATA_STRING_ERROR; 654 } 655 656 return VFR_RETURN_SUCCESS; 657 } 658 659 EFI_VFR_RETURN_CODE 660 CVfrVarDataTypeDB::GetTypeField ( 661 IN CONST CHAR8 *FName, 662 IN SVfrDataType *Type, 663 OUT SVfrDataField *&Field 664 ) 665 { 666 SVfrDataField *pField = NULL; 667 668 if ((FName == NULL) && (Type == NULL)) { 669 return VFR_RETURN_FATAL_ERROR; 670 } 671 672 for (pField = Type->mMembers; pField != NULL; pField = pField->mNext) { 673 // 674 // For type EFI_IFR_TYPE_TIME, because field name is not correctly wrote, 675 // add code to adjust it. 676 // 677 if (Type->mType == EFI_IFR_TYPE_TIME) { 678 if (strcmp (FName, "Hour") == 0) { 679 FName = "Hours"; 680 } else if (strcmp (FName, "Minute") == 0) { 681 FName = "Minuts"; 682 } else if (strcmp (FName, "Second") == 0) { 683 FName = "Seconds"; 684 } 685 } 686 687 if (strcmp (pField->mFieldName, FName) == 0) { 688 Field = pField; 689 return VFR_RETURN_SUCCESS; 690 } 691 } 692 693 return VFR_RETURN_UNDEFINED; 694 } 695 696 EFI_VFR_RETURN_CODE 697 CVfrVarDataTypeDB::GetFieldOffset ( 698 IN SVfrDataField *Field, 699 IN UINT32 ArrayIdx, 700 OUT UINT32 &Offset 701 ) 702 { 703 if (Field == NULL) { 704 return VFR_RETURN_FATAL_ERROR; 705 } 706 707 // 708 // Framework Vfr file Array Index is from 1. 709 // But Uefi Vfr file Array Index is from 0. 710 // 711 if (VfrCompatibleMode && ArrayIdx != INVALID_ARRAY_INDEX) { 712 if (ArrayIdx == 0) { 713 return VFR_RETURN_ERROR_ARRARY_NUM; 714 } 715 ArrayIdx = ArrayIdx - 1; 716 } 717 718 if ((ArrayIdx != INVALID_ARRAY_INDEX) && ((Field->mArrayNum == 0) || (Field->mArrayNum <= ArrayIdx))) { 719 return VFR_RETURN_ERROR_ARRARY_NUM; 720 } 721 722 // 723 // Be compatible with the current usage 724 // If ArraryIdx is not specified, the first one is used. 725 // 726 // if ArrayNum is larger than zero, ArraryIdx must be specified. 727 // 728 // if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum > 0)) { 729 // return VFR_RETURN_ERROR_ARRARY_NUM; 730 // } 731 // 732 733 Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx); 734 return VFR_RETURN_SUCCESS; 735 } 736 737 UINT8 738 CVfrVarDataTypeDB::GetFieldWidth ( 739 IN SVfrDataField *Field 740 ) 741 { 742 if (Field == NULL) { 743 return 0; 744 } 745 746 return Field->mFieldType->mType; 747 } 748 749 UINT32 750 CVfrVarDataTypeDB::GetFieldSize ( 751 IN SVfrDataField *Field, 752 IN UINT32 ArrayIdx 753 ) 754 { 755 if (Field == NULL) { 756 return VFR_RETURN_FATAL_ERROR; 757 } 758 759 if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum != 0)) { 760 return Field->mFieldType->mTotalSize * Field->mArrayNum; 761 } else { 762 return Field->mFieldType->mTotalSize; 763 } 764 } 765 766 VOID 767 CVfrVarDataTypeDB::InternalTypesListInit ( 768 VOID 769 ) 770 { 771 SVfrDataType *New = NULL; 772 UINT32 Index; 773 774 for (Index = 0; gInternalTypesTable[Index].mTypeName != NULL; Index++) { 775 New = new SVfrDataType; 776 if (New != NULL) { 777 strcpy (New->mTypeName, gInternalTypesTable[Index].mTypeName); 778 New->mType = gInternalTypesTable[Index].mType; 779 New->mAlign = gInternalTypesTable[Index].mAlign; 780 New->mTotalSize = gInternalTypesTable[Index].mSize; 781 if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_DATE") == 0) { 782 SVfrDataField *pYearField = new SVfrDataField; 783 SVfrDataField *pMonthField = new SVfrDataField; 784 SVfrDataField *pDayField = new SVfrDataField; 785 786 strcpy (pYearField->mFieldName, "Year"); 787 GetDataType ((CHAR8 *)"UINT16", &pYearField->mFieldType); 788 pYearField->mOffset = 0; 789 pYearField->mNext = pMonthField; 790 pYearField->mArrayNum = 0; 791 792 strcpy (pMonthField->mFieldName, "Month"); 793 GetDataType ((CHAR8 *)"UINT8", &pMonthField->mFieldType); 794 pMonthField->mOffset = 2; 795 pMonthField->mNext = pDayField; 796 pMonthField->mArrayNum = 0; 797 798 strcpy (pDayField->mFieldName, "Day"); 799 GetDataType ((CHAR8 *)"UINT8", &pDayField->mFieldType); 800 pDayField->mOffset = 3; 801 pDayField->mNext = NULL; 802 pDayField->mArrayNum = 0; 803 804 New->mMembers = pYearField; 805 } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_TIME") == 0) { 806 SVfrDataField *pHoursField = new SVfrDataField; 807 SVfrDataField *pMinutesField = new SVfrDataField; 808 SVfrDataField *pSecondsField = new SVfrDataField; 809 810 strcpy (pHoursField->mFieldName, "Hours"); 811 GetDataType ((CHAR8 *)"UINT8", &pHoursField->mFieldType); 812 pHoursField->mOffset = 0; 813 pHoursField->mNext = pMinutesField; 814 pHoursField->mArrayNum = 0; 815 816 strcpy (pMinutesField->mFieldName, "Minutes"); 817 GetDataType ((CHAR8 *)"UINT8", &pMinutesField->mFieldType); 818 pMinutesField->mOffset = 1; 819 pMinutesField->mNext = pSecondsField; 820 pMinutesField->mArrayNum = 0; 821 822 strcpy (pSecondsField->mFieldName, "Seconds"); 823 GetDataType ((CHAR8 *)"UINT8", &pSecondsField->mFieldType); 824 pSecondsField->mOffset = 2; 825 pSecondsField->mNext = NULL; 826 pSecondsField->mArrayNum = 0; 827 828 New->mMembers = pHoursField; 829 } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_REF") == 0) { 830 SVfrDataField *pQuestionIdField = new SVfrDataField; 831 SVfrDataField *pFormIdField = new SVfrDataField; 832 SVfrDataField *pFormSetGuidField = new SVfrDataField; 833 SVfrDataField *pDevicePathField = new SVfrDataField; 834 835 strcpy (pQuestionIdField->mFieldName, "QuestionId"); 836 GetDataType ((CHAR8 *)"UINT16", &pQuestionIdField->mFieldType); 837 pQuestionIdField->mOffset = 0; 838 pQuestionIdField->mNext = pFormIdField; 839 pQuestionIdField->mArrayNum = 0; 840 841 strcpy (pFormIdField->mFieldName, "FormId"); 842 GetDataType ((CHAR8 *)"UINT16", &pFormIdField->mFieldType); 843 pFormIdField->mOffset = 2; 844 pFormIdField->mNext = pFormSetGuidField; 845 pFormIdField->mArrayNum = 0; 846 847 strcpy (pFormSetGuidField->mFieldName, "FormSetGuid"); 848 GetDataType ((CHAR8 *)"EFI_GUID", &pFormSetGuidField->mFieldType); 849 pFormSetGuidField->mOffset = 4; 850 pFormSetGuidField->mNext = pDevicePathField; 851 pFormSetGuidField->mArrayNum = 0; 852 853 strcpy (pDevicePathField->mFieldName, "DevicePath"); 854 GetDataType ((CHAR8 *)"EFI_STRING_ID", &pDevicePathField->mFieldType); 855 pDevicePathField->mOffset = 20; 856 pDevicePathField->mNext = NULL; 857 pDevicePathField->mArrayNum = 0; 858 859 New->mMembers = pQuestionIdField; 860 } else { 861 New->mMembers = NULL; 862 } 863 New->mNext = NULL; 864 RegisterNewType (New); 865 New = NULL; 866 } 867 } 868 } 869 870 CVfrVarDataTypeDB::CVfrVarDataTypeDB ( 871 VOID 872 ) 873 { 874 mDataTypeList = NULL; 875 mNewDataType = NULL; 876 mCurrDataField = NULL; 877 mPackAlign = DEFAULT_PACK_ALIGN; 878 mPackStack = NULL; 879 mFirstNewDataTypeName = NULL; 880 881 InternalTypesListInit (); 882 } 883 884 CVfrVarDataTypeDB::~CVfrVarDataTypeDB ( 885 VOID 886 ) 887 { 888 SVfrDataType *pType; 889 SVfrDataField *pField; 890 SVfrPackStackNode *pPack; 891 892 if (mNewDataType != NULL) { 893 delete mNewDataType; 894 } 895 896 while (mDataTypeList != NULL) { 897 pType = mDataTypeList; 898 mDataTypeList = mDataTypeList->mNext; 899 while(pType->mMembers != NULL) { 900 pField = pType->mMembers; 901 pType->mMembers = pType->mMembers->mNext; 902 delete pField; 903 } 904 delete pType; 905 } 906 907 while (mPackStack != NULL) { 908 pPack = mPackStack; 909 mPackStack = mPackStack->mNext; 910 delete pPack; 911 } 912 } 913 914 EFI_VFR_RETURN_CODE 915 CVfrVarDataTypeDB::Pack ( 916 IN UINT32 LineNum, 917 IN UINT8 Action, 918 IN CHAR8 *Identifier, 919 IN UINT32 Number 920 ) 921 { 922 UINT32 PackAlign; 923 CHAR8 Msg[MAX_STRING_LEN] = {0, }; 924 925 if (Action & VFR_PACK_SHOW) { 926 sprintf (Msg, "value of pragma pack(show) == %d", mPackAlign); 927 gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Warning", Msg); 928 } 929 930 if (Action & VFR_PACK_PUSH) { 931 SVfrPackStackNode *pNew = NULL; 932 933 if ((pNew = new SVfrPackStackNode (Identifier, mPackAlign)) == NULL) { 934 return VFR_RETURN_FATAL_ERROR; 935 } 936 pNew->mNext = mPackStack; 937 mPackStack = pNew; 938 } 939 940 if (Action & VFR_PACK_POP) { 941 SVfrPackStackNode *pNode = NULL; 942 943 if (mPackStack == NULL) { 944 gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Error", "#pragma pack(pop...) : more pops than pushes"); 945 } 946 947 for (pNode = mPackStack; pNode != NULL; pNode = pNode->mNext) { 948 if (pNode->Match (Identifier) == TRUE) { 949 mPackAlign = pNode->mNumber; 950 mPackStack = pNode->mNext; 951 } 952 } 953 } 954 955 if (Action & VFR_PACK_ASSIGN) { 956 PackAlign = (Number > 1) ? Number + Number % 2 : Number; 957 if ((PackAlign == 0) || (PackAlign > 16)) { 958 gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Error", "expected pragma parameter to be '1', '2', '4', '8', or '16'"); 959 } else { 960 mPackAlign = PackAlign; 961 } 962 } 963 964 return VFR_RETURN_SUCCESS; 965 } 966 967 VOID 968 CVfrVarDataTypeDB::DeclareDataTypeBegin ( 969 VOID 970 ) 971 { 972 SVfrDataType *pNewType = NULL; 973 974 pNewType = new SVfrDataType; 975 pNewType->mTypeName[0] = '\0'; 976 pNewType->mType = EFI_IFR_TYPE_OTHER; 977 pNewType->mAlign = DEFAULT_ALIGN; 978 pNewType->mTotalSize = 0; 979 pNewType->mMembers = NULL; 980 pNewType->mNext = NULL; 981 982 mNewDataType = pNewType; 983 } 984 985 EFI_VFR_RETURN_CODE 986 CVfrVarDataTypeDB::SetNewTypeName ( 987 IN CHAR8 *TypeName 988 ) 989 { 990 SVfrDataType *pType; 991 992 if (mNewDataType == NULL) { 993 return VFR_RETURN_ERROR_SKIPED; 994 } 995 if (TypeName == NULL) { 996 return VFR_RETURN_FATAL_ERROR; 997 } 998 if (strlen(TypeName) >= MAX_NAME_LEN) { 999 return VFR_RETURN_INVALID_PARAMETER; 1000 } 1001 1002 for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) { 1003 if (strcmp(pType->mTypeName, TypeName) == 0) { 1004 return VFR_RETURN_REDEFINED; 1005 } 1006 } 1007 1008 strcpy(mNewDataType->mTypeName, TypeName); 1009 return VFR_RETURN_SUCCESS; 1010 } 1011 1012 EFI_VFR_RETURN_CODE 1013 CVfrVarDataTypeDB::DataTypeAddField ( 1014 IN CHAR8 *FieldName, 1015 IN CHAR8 *TypeName, 1016 IN UINT32 ArrayNum 1017 ) 1018 { 1019 SVfrDataField *pNewField = NULL; 1020 SVfrDataType *pFieldType = NULL; 1021 SVfrDataField *pTmp; 1022 UINT32 Align; 1023 1024 CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType), VFR_RETURN_SUCCESS); 1025 1026 if (strlen (FieldName) >= MAX_NAME_LEN) { 1027 return VFR_RETURN_INVALID_PARAMETER; 1028 } 1029 1030 for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) { 1031 if (strcmp (pTmp->mFieldName, FieldName) == 0) { 1032 return VFR_RETURN_REDEFINED; 1033 } 1034 } 1035 1036 Align = MIN (mPackAlign, pFieldType->mAlign); 1037 1038 if ((pNewField = new SVfrDataField) == NULL) { 1039 return VFR_RETURN_OUT_FOR_RESOURCES; 1040 } 1041 strcpy (pNewField->mFieldName, FieldName); 1042 pNewField->mFieldType = pFieldType; 1043 pNewField->mArrayNum = ArrayNum; 1044 if ((mNewDataType->mTotalSize % Align) == 0) { 1045 pNewField->mOffset = mNewDataType->mTotalSize; 1046 } else { 1047 pNewField->mOffset = mNewDataType->mTotalSize + ALIGN_STUFF(mNewDataType->mTotalSize, Align); 1048 } 1049 if (mNewDataType->mMembers == NULL) { 1050 mNewDataType->mMembers = pNewField; 1051 pNewField->mNext = NULL; 1052 } else { 1053 for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp = pTmp->mNext) 1054 ; 1055 pTmp->mNext = pNewField; 1056 pNewField->mNext = NULL; 1057 } 1058 1059 mNewDataType->mAlign = MIN (mPackAlign, MAX (pFieldType->mAlign, mNewDataType->mAlign)); 1060 mNewDataType->mTotalSize = pNewField->mOffset + (pNewField->mFieldType->mTotalSize) * ((ArrayNum == 0) ? 1 : ArrayNum); 1061 1062 return VFR_RETURN_SUCCESS; 1063 } 1064 1065 VOID 1066 CVfrVarDataTypeDB::DeclareDataTypeEnd ( 1067 VOID 1068 ) 1069 { 1070 if (mNewDataType->mTypeName[0] == '\0') { 1071 return; 1072 } 1073 1074 if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) { 1075 mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, mNewDataType->mAlign); 1076 } 1077 1078 RegisterNewType (mNewDataType); 1079 if (mFirstNewDataTypeName == NULL) { 1080 mFirstNewDataTypeName = mNewDataType->mTypeName; 1081 } 1082 1083 mNewDataType = NULL; 1084 } 1085 1086 EFI_VFR_RETURN_CODE 1087 CVfrVarDataTypeDB::GetDataType ( 1088 IN CHAR8 *TypeName, 1089 OUT SVfrDataType **DataType 1090 ) 1091 { 1092 SVfrDataType *pDataType = NULL; 1093 1094 if (TypeName == NULL) { 1095 return VFR_RETURN_ERROR_SKIPED; 1096 } 1097 1098 if (DataType == NULL) { 1099 return VFR_RETURN_FATAL_ERROR; 1100 } 1101 1102 *DataType = NULL; 1103 1104 for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) { 1105 if (strcmp (TypeName, pDataType->mTypeName) == 0) { 1106 *DataType = pDataType; 1107 return VFR_RETURN_SUCCESS; 1108 } 1109 } 1110 1111 return VFR_RETURN_UNDEFINED; 1112 } 1113 1114 EFI_VFR_RETURN_CODE 1115 CVfrVarDataTypeDB::GetDataTypeSize ( 1116 IN UINT8 DataType, 1117 OUT UINT32 *Size 1118 ) 1119 { 1120 SVfrDataType *pDataType = NULL; 1121 1122 if (Size == NULL) { 1123 return VFR_RETURN_FATAL_ERROR; 1124 } 1125 1126 *Size = 0; 1127 DataType = DataType & 0x0F; 1128 1129 // 1130 // For user defined data type, the size can't be got by this function. 1131 // 1132 if (DataType == EFI_IFR_TYPE_OTHER) { 1133 return VFR_RETURN_SUCCESS; 1134 } 1135 1136 for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) { 1137 if (DataType == pDataType->mType) { 1138 *Size = pDataType->mTotalSize; 1139 return VFR_RETURN_SUCCESS; 1140 } 1141 } 1142 1143 return VFR_RETURN_UNDEFINED; 1144 } 1145 1146 EFI_VFR_RETURN_CODE 1147 CVfrVarDataTypeDB::GetDataTypeSize ( 1148 IN CHAR8 *TypeName, 1149 OUT UINT32 *Size 1150 ) 1151 { 1152 SVfrDataType *pDataType = NULL; 1153 1154 if (Size == NULL) { 1155 return VFR_RETURN_FATAL_ERROR; 1156 } 1157 1158 *Size = 0; 1159 1160 for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) { 1161 if (strcmp (TypeName, pDataType->mTypeName) == 0) { 1162 *Size = pDataType->mTotalSize; 1163 return VFR_RETURN_SUCCESS; 1164 } 1165 } 1166 1167 return VFR_RETURN_UNDEFINED; 1168 } 1169 1170 EFI_VFR_RETURN_CODE 1171 CVfrVarDataTypeDB::GetDataFieldInfo ( 1172 IN CHAR8 *VarStr, 1173 OUT UINT16 &Offset, 1174 OUT UINT8 &Type, 1175 OUT UINT32 &Size 1176 ) 1177 { 1178 CHAR8 TName[MAX_NAME_LEN], FName[MAX_NAME_LEN]; 1179 UINT32 ArrayIdx, Tmp; 1180 SVfrDataType *pType = NULL; 1181 SVfrDataField *pField = NULL; 1182 1183 Offset = 0; 1184 Type = EFI_IFR_TYPE_OTHER; 1185 Size = 0; 1186 1187 CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), VFR_RETURN_SUCCESS); 1188 CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS); 1189 1190 // 1191 // if it is not struct data type 1192 // 1193 Type = pType->mType; 1194 Size = pType->mTotalSize; 1195 1196 while (*VarStr != '\0') { 1197 CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS); 1198 CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), VFR_RETURN_SUCCESS); 1199 pType = pField->mFieldType; 1200 CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp), VFR_RETURN_SUCCESS); 1201 Offset = (UINT16) (Offset + Tmp); 1202 Type = GetFieldWidth (pField); 1203 Size = GetFieldSize (pField, ArrayIdx); 1204 } 1205 return VFR_RETURN_SUCCESS; 1206 } 1207 1208 EFI_VFR_RETURN_CODE 1209 CVfrVarDataTypeDB::GetUserDefinedTypeNameList ( 1210 OUT CHAR8 ***NameList, 1211 OUT UINT32 *ListSize 1212 ) 1213 { 1214 UINT32 Index; 1215 SVfrDataType *pType; 1216 1217 if ((NameList == NULL) || (ListSize == NULL)) { 1218 return VFR_RETURN_FATAL_ERROR; 1219 } 1220 1221 *NameList = NULL; 1222 *ListSize = 0; 1223 1224 for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) { 1225 if (_IS_INTERNAL_TYPE(pType->mTypeName) == FALSE) { 1226 (*ListSize)++; 1227 } 1228 } 1229 1230 if (*ListSize == 0) { 1231 return VFR_RETURN_SUCCESS; 1232 } 1233 1234 if ((*NameList = new CHAR8*[*ListSize]) == NULL) { 1235 *ListSize = 0; 1236 return VFR_RETURN_OUT_FOR_RESOURCES; 1237 } 1238 1239 for (Index = 0, pType = mDataTypeList; pType != NULL; pType = pType->mNext, Index++) { 1240 if (_IS_INTERNAL_TYPE(pType->mTypeName) == FALSE) { 1241 (*NameList)[Index] = pType->mTypeName; 1242 } 1243 } 1244 return VFR_RETURN_SUCCESS; 1245 } 1246 1247 BOOLEAN 1248 CVfrVarDataTypeDB::IsTypeNameDefined ( 1249 IN CHAR8 *TypeName 1250 ) 1251 { 1252 SVfrDataType *pType; 1253 1254 if (TypeName == NULL) { 1255 return FALSE; 1256 } 1257 1258 for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) { 1259 if (strcmp (pType->mTypeName, TypeName) == 0) { 1260 return TRUE; 1261 } 1262 } 1263 1264 return FALSE; 1265 } 1266 1267 VOID 1268 CVfrVarDataTypeDB::Dump ( 1269 IN FILE *File 1270 ) 1271 { 1272 SVfrDataType *pTNode; 1273 SVfrDataField *pFNode; 1274 1275 fprintf (File, "\n\n***************************************************************\n"); 1276 fprintf (File, "\t\tmPackAlign = %x\n", mPackAlign); 1277 for (pTNode = mDataTypeList; pTNode != NULL; pTNode = pTNode->mNext) { 1278 fprintf (File, "\t\tstruct %s : mAlign [%d] mTotalSize [0x%x]\n\n", pTNode->mTypeName, pTNode->mAlign, pTNode->mTotalSize); 1279 fprintf (File, "\t\tstruct %s {\n", pTNode->mTypeName); 1280 for (pFNode = pTNode->mMembers; pFNode != NULL; pFNode = pFNode->mNext) { 1281 if (pFNode->mArrayNum > 0) { 1282 fprintf (File, "\t\t\t+%08d[%08x] %s[%d] <%s>\n", pFNode->mOffset, pFNode->mOffset, 1283 pFNode->mFieldName, pFNode->mArrayNum, pFNode->mFieldType->mTypeName); 1284 } else { 1285 fprintf (File, "\t\t\t+%08d[%08x] %s <%s>\n", pFNode->mOffset, pFNode->mOffset, 1286 pFNode->mFieldName, pFNode->mFieldType->mTypeName); 1287 } 1288 } 1289 fprintf (File, "\t\t};\n"); 1290 fprintf (File, "---------------------------------------------------------------\n"); 1291 } 1292 fprintf (File, "***************************************************************\n"); 1293 } 1294 1295 #ifdef CVFR_VARDATATYPEDB_DEBUG 1296 VOID 1297 CVfrVarDataTypeDB::ParserDB ( 1298 VOID 1299 ) 1300 { 1301 SVfrDataType *pTNode; 1302 SVfrDataField *pFNode; 1303 1304 printf ("***************************************************************\n"); 1305 printf ("\t\tmPackAlign = %x\n", mPackAlign); 1306 for (pTNode = mDataTypeList; pTNode != NULL; pTNode = pTNode->mNext) { 1307 printf ("\t\tstruct %s : mAlign [%x] mTotalSize [%x]\n\n", pTNode->mTypeName, pTNode->mAlign, pTNode->mTotalSize); 1308 printf ("\t\tstruct %s {\n", pTNode->mTypeName); 1309 for (pFNode = pTNode->mMembers; pFNode != NULL; pFNode = pFNode->mNext) { 1310 printf ("\t\t\t%s\t%s\n", pFNode->mFieldType->mTypeName, pFNode->mFieldName); 1311 } 1312 printf ("\t\t};\n"); 1313 printf ("---------------------------------------------------------------\n"); 1314 } 1315 printf ("***************************************************************\n"); 1316 } 1317 #endif 1318 1319 SVfrVarStorageNode::SVfrVarStorageNode ( 1320 IN EFI_GUID *Guid, 1321 IN CHAR8 *StoreName, 1322 IN EFI_VARSTORE_ID VarStoreId, 1323 IN EFI_STRING_ID VarName, 1324 IN UINT32 VarSize, 1325 IN BOOLEAN Flag 1326 ) 1327 { 1328 if (Guid != NULL) { 1329 mGuid = *Guid; 1330 } else { 1331 memset (&Guid, 0, sizeof (EFI_GUID)); 1332 } 1333 if (StoreName != NULL) { 1334 mVarStoreName = new CHAR8[strlen(StoreName) + 1]; 1335 strcpy (mVarStoreName, StoreName); 1336 } else { 1337 mVarStoreName = NULL; 1338 } 1339 mNext = NULL; 1340 mVarStoreId = VarStoreId; 1341 mVarStoreType = EFI_VFR_VARSTORE_EFI; 1342 mStorageInfo.mEfiVar.mEfiVarName = VarName; 1343 mStorageInfo.mEfiVar.mEfiVarSize = VarSize; 1344 mAssignedFlag = Flag; 1345 } 1346 1347 SVfrVarStorageNode::SVfrVarStorageNode ( 1348 IN EFI_GUID *Guid, 1349 IN CHAR8 *StoreName, 1350 IN EFI_VARSTORE_ID VarStoreId, 1351 IN SVfrDataType *DataType, 1352 IN BOOLEAN Flag 1353 ) 1354 { 1355 if (Guid != NULL) { 1356 mGuid = *Guid; 1357 } else { 1358 memset (&Guid, 0, sizeof (EFI_GUID)); 1359 } 1360 if (StoreName != NULL) { 1361 mVarStoreName = new CHAR8[strlen(StoreName) + 1]; 1362 strcpy (mVarStoreName, StoreName); 1363 } else { 1364 mVarStoreName = NULL; 1365 } 1366 mNext = NULL; 1367 mVarStoreId = VarStoreId; 1368 mVarStoreType = EFI_VFR_VARSTORE_BUFFER; 1369 mStorageInfo.mDataType = DataType; 1370 mAssignedFlag = Flag; 1371 } 1372 1373 SVfrVarStorageNode::SVfrVarStorageNode ( 1374 IN CHAR8 *StoreName, 1375 IN EFI_VARSTORE_ID VarStoreId 1376 ) 1377 { 1378 if (StoreName != NULL) { 1379 mVarStoreName = new CHAR8[strlen(StoreName) + 1]; 1380 strcpy (mVarStoreName, StoreName); 1381 } else { 1382 mVarStoreName = NULL; 1383 } 1384 mNext = NULL; 1385 mVarStoreId = VarStoreId; 1386 mVarStoreType = EFI_VFR_VARSTORE_NAME; 1387 mStorageInfo.mNameSpace.mNameTable = new EFI_VARSTORE_ID[DEFAULT_NAME_TABLE_ITEMS]; 1388 mStorageInfo.mNameSpace.mTableSize = 0; 1389 } 1390 1391 SVfrVarStorageNode::~SVfrVarStorageNode ( 1392 VOID 1393 ) 1394 { 1395 if (mVarStoreName != NULL) { 1396 delete mVarStoreName; 1397 } 1398 1399 if (mVarStoreType == EFI_VFR_VARSTORE_NAME) { 1400 delete mStorageInfo.mNameSpace.mNameTable; 1401 } 1402 } 1403 1404 CVfrDataStorage::CVfrDataStorage ( 1405 VOID 1406 ) 1407 { 1408 UINT32 Index; 1409 1410 for (Index = 0; Index < EFI_FREE_VARSTORE_ID_BITMAP_SIZE; Index++) { 1411 mFreeVarStoreIdBitMap[Index] = 0; 1412 } 1413 1414 // Question ID 0 is reserved. 1415 mFreeVarStoreIdBitMap[0] = 0x80000000; 1416 1417 mBufferVarStoreList = NULL; 1418 mEfiVarStoreList = NULL; 1419 mNameVarStoreList = NULL; 1420 mCurrVarStorageNode = NULL; 1421 mNewVarStorageNode = NULL; 1422 } 1423 1424 CVfrDataStorage::~CVfrDataStorage ( 1425 VOID 1426 ) 1427 { 1428 SVfrVarStorageNode *pNode; 1429 1430 while (mBufferVarStoreList != NULL) { 1431 pNode = mBufferVarStoreList; 1432 mBufferVarStoreList = mBufferVarStoreList->mNext; 1433 delete pNode; 1434 } 1435 while (mEfiVarStoreList != NULL) { 1436 pNode = mEfiVarStoreList; 1437 mEfiVarStoreList = mEfiVarStoreList->mNext; 1438 delete pNode; 1439 } 1440 while (mNameVarStoreList != NULL) { 1441 pNode = mNameVarStoreList; 1442 mNameVarStoreList = mNameVarStoreList->mNext; 1443 delete pNode; 1444 } 1445 if (mNewVarStorageNode != NULL) { 1446 delete mNewVarStorageNode; 1447 } 1448 } 1449 1450 EFI_VARSTORE_ID 1451 CVfrDataStorage::GetFreeVarStoreId ( 1452 EFI_VFR_VARSTORE_TYPE VarType 1453 ) 1454 { 1455 UINT32 Index, Mask, Offset; 1456 1457 // 1458 // Assign the different ID range for the different type VarStore to support Framework Vfr 1459 // 1460 Index = 0; 1461 if ((!VfrCompatibleMode) || (VarType == EFI_VFR_VARSTORE_BUFFER)) { 1462 Index = 0; 1463 } else if (VarType == EFI_VFR_VARSTORE_EFI) { 1464 Index = 1; 1465 } else if (VarType == EFI_VFR_VARSTORE_NAME) { 1466 Index = 2; 1467 } 1468 1469 for (; Index < EFI_FREE_VARSTORE_ID_BITMAP_SIZE; Index++) { 1470 if (mFreeVarStoreIdBitMap[Index] != 0xFFFFFFFF) { 1471 break; 1472 } 1473 } 1474 1475 for (Offset = 0, Mask = 0x80000000; Mask != 0; Mask >>= 1, Offset++) { 1476 if ((mFreeVarStoreIdBitMap[Index] & Mask) == 0) { 1477 mFreeVarStoreIdBitMap[Index] |= Mask; 1478 return (EFI_VARSTORE_ID)((Index << EFI_BITS_SHIFT_PER_UINT32) + Offset); 1479 } 1480 } 1481 1482 return EFI_VARSTORE_ID_INVALID; 1483 } 1484 1485 BOOLEAN 1486 CVfrDataStorage::ChekVarStoreIdFree ( 1487 IN EFI_VARSTORE_ID VarStoreId 1488 ) 1489 { 1490 UINT32 Index = (VarStoreId / EFI_BITS_PER_UINT32); 1491 UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32); 1492 1493 return (mFreeVarStoreIdBitMap[Index] & (0x80000000 >> Offset)) == 0; 1494 } 1495 1496 VOID 1497 CVfrDataStorage::MarkVarStoreIdUsed ( 1498 IN EFI_VARSTORE_ID VarStoreId 1499 ) 1500 { 1501 UINT32 Index = (VarStoreId / EFI_BITS_PER_UINT32); 1502 UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32); 1503 1504 mFreeVarStoreIdBitMap[Index] |= (0x80000000 >> Offset); 1505 } 1506 1507 VOID 1508 CVfrDataStorage::MarkVarStoreIdUnused ( 1509 IN EFI_VARSTORE_ID VarStoreId 1510 ) 1511 { 1512 UINT32 Index = (VarStoreId / EFI_BITS_PER_UINT32); 1513 UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32); 1514 1515 mFreeVarStoreIdBitMap[Index] &= ~(0x80000000 >> Offset); 1516 } 1517 1518 EFI_VFR_RETURN_CODE 1519 CVfrDataStorage::DeclareNameVarStoreBegin ( 1520 IN CHAR8 *StoreName, 1521 IN EFI_VARSTORE_ID VarStoreId 1522 ) 1523 { 1524 SVfrVarStorageNode *pNode = NULL; 1525 EFI_VARSTORE_ID TmpVarStoreId; 1526 1527 if (StoreName == NULL) { 1528 return VFR_RETURN_FATAL_ERROR; 1529 } 1530 1531 if (GetVarStoreId (StoreName, &TmpVarStoreId) == VFR_RETURN_SUCCESS) { 1532 return VFR_RETURN_REDEFINED; 1533 } 1534 1535 if (VarStoreId == EFI_VARSTORE_ID_INVALID) { 1536 VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME); 1537 } else { 1538 if (ChekVarStoreIdFree (VarStoreId) == FALSE) { 1539 return VFR_RETURN_VARSTOREID_REDEFINED; 1540 } 1541 MarkVarStoreIdUsed (VarStoreId); 1542 } 1543 1544 if ((pNode = new SVfrVarStorageNode (StoreName, VarStoreId)) == NULL) { 1545 return VFR_RETURN_UNDEFINED; 1546 } 1547 1548 mNewVarStorageNode = pNode; 1549 1550 return VFR_RETURN_SUCCESS; 1551 } 1552 1553 EFI_VFR_RETURN_CODE 1554 CVfrDataStorage::NameTableAddItem ( 1555 IN EFI_STRING_ID Item 1556 ) 1557 { 1558 EFI_VARSTORE_ID *NewTable, *OldTable; 1559 UINT32 TableSize; 1560 1561 OldTable = mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable; 1562 TableSize = mNewVarStorageNode->mStorageInfo.mNameSpace.mTableSize; 1563 1564 if ((TableSize != 0) && ((TableSize % DEFAULT_NAME_TABLE_ITEMS) == 0)) { 1565 if ((NewTable = new EFI_VARSTORE_ID[TableSize + DEFAULT_NAME_TABLE_ITEMS]) == NULL) { 1566 return VFR_RETURN_OUT_FOR_RESOURCES; 1567 } 1568 memcpy (NewTable, OldTable, TableSize); 1569 mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable = NewTable; 1570 } 1571 1572 mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable[TableSize++] = Item; 1573 mNewVarStorageNode->mStorageInfo.mNameSpace.mTableSize = TableSize; 1574 1575 return VFR_RETURN_SUCCESS; 1576 } 1577 1578 EFI_VFR_RETURN_CODE 1579 CVfrDataStorage::DeclareNameVarStoreEnd ( 1580 IN EFI_GUID *Guid 1581 ) 1582 { 1583 mNewVarStorageNode->mGuid = *Guid; 1584 mNewVarStorageNode->mNext = mNameVarStoreList; 1585 mNameVarStoreList = mNewVarStorageNode; 1586 1587 mNewVarStorageNode = NULL; 1588 1589 return VFR_RETURN_SUCCESS; 1590 } 1591 1592 EFI_VFR_RETURN_CODE 1593 CVfrDataStorage::DeclareEfiVarStore ( 1594 IN CHAR8 *StoreName, 1595 IN EFI_GUID *Guid, 1596 IN EFI_STRING_ID NameStrId, 1597 IN UINT32 VarSize, 1598 IN BOOLEAN Flag 1599 ) 1600 { 1601 SVfrVarStorageNode *pNode; 1602 EFI_VARSTORE_ID VarStoreId; 1603 1604 if ((StoreName == NULL) || (Guid == NULL)) { 1605 return VFR_RETURN_FATAL_ERROR; 1606 } 1607 1608 if (VarSize > sizeof (UINT64)) { 1609 return VFR_RETURN_EFIVARSTORE_SIZE_ERROR; 1610 } 1611 1612 if (GetVarStoreId (StoreName, &VarStoreId, Guid) == VFR_RETURN_SUCCESS) { 1613 return VFR_RETURN_REDEFINED; 1614 } 1615 1616 VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_EFI); 1617 if ((pNode = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, NameStrId, VarSize, Flag)) == NULL) { 1618 return VFR_RETURN_OUT_FOR_RESOURCES; 1619 } 1620 1621 pNode->mNext = mEfiVarStoreList; 1622 mEfiVarStoreList = pNode; 1623 1624 return VFR_RETURN_SUCCESS; 1625 } 1626 1627 EFI_VFR_RETURN_CODE 1628 CVfrDataStorage::DeclareBufferVarStore ( 1629 IN CHAR8 *StoreName, 1630 IN EFI_GUID *Guid, 1631 IN CVfrVarDataTypeDB *DataTypeDB, 1632 IN CHAR8 *TypeName, 1633 IN EFI_VARSTORE_ID VarStoreId, 1634 IN BOOLEAN Flag 1635 ) 1636 { 1637 SVfrVarStorageNode *pNew = NULL; 1638 SVfrDataType *pDataType = NULL; 1639 EFI_VARSTORE_ID TempVarStoreId; 1640 1641 if ((StoreName == NULL) || (Guid == NULL) || (DataTypeDB == NULL)) { 1642 return VFR_RETURN_FATAL_ERROR; 1643 } 1644 1645 if (GetVarStoreId (StoreName, &TempVarStoreId, Guid) == VFR_RETURN_SUCCESS) { 1646 return VFR_RETURN_REDEFINED; 1647 } 1648 1649 CHECK_ERROR_RETURN(DataTypeDB->GetDataType (TypeName, &pDataType), VFR_RETURN_SUCCESS); 1650 1651 if (VarStoreId == EFI_VARSTORE_ID_INVALID) { 1652 VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_BUFFER); 1653 } else { 1654 if (ChekVarStoreIdFree (VarStoreId) == FALSE) { 1655 return VFR_RETURN_VARSTOREID_REDEFINED; 1656 } 1657 MarkVarStoreIdUsed (VarStoreId); 1658 } 1659 1660 if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, Flag)) == NULL) { 1661 return VFR_RETURN_OUT_FOR_RESOURCES; 1662 } 1663 1664 pNew->mNext = mBufferVarStoreList; 1665 mBufferVarStoreList = pNew; 1666 1667 if (gCVfrBufferConfig.Register(StoreName, Guid) != 0) { 1668 return VFR_RETURN_FATAL_ERROR; 1669 } 1670 1671 return VFR_RETURN_SUCCESS; 1672 } 1673 1674 EFI_VFR_RETURN_CODE 1675 CVfrDataStorage::GetVarStoreByDataType ( 1676 IN CHAR8 *DataTypeName, 1677 OUT SVfrVarStorageNode **VarNode, 1678 IN EFI_GUID *VarGuid 1679 ) 1680 { 1681 SVfrVarStorageNode *pNode; 1682 SVfrVarStorageNode *MatchNode; 1683 1684 // 1685 // Framework VFR uses Data type name as varstore name, so don't need check again. 1686 // 1687 if (VfrCompatibleMode) { 1688 return VFR_RETURN_UNDEFINED; 1689 } 1690 1691 MatchNode = NULL; 1692 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1693 if (strcmp (pNode->mStorageInfo.mDataType->mTypeName, DataTypeName) != 0) { 1694 continue; 1695 } 1696 1697 if ((VarGuid != NULL)) { 1698 if (memcmp (VarGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) { 1699 *VarNode = pNode; 1700 return VFR_RETURN_SUCCESS; 1701 } 1702 } else { 1703 if (MatchNode == NULL) { 1704 MatchNode = pNode; 1705 } else { 1706 // 1707 // More than one varstores referred the same data structures. 1708 // 1709 return VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR; 1710 } 1711 } 1712 } 1713 1714 if (MatchNode == NULL) { 1715 return VFR_RETURN_UNDEFINED; 1716 } 1717 1718 *VarNode = MatchNode; 1719 return VFR_RETURN_SUCCESS; 1720 } 1721 1722 EFI_VARSTORE_ID 1723 CVfrDataStorage::CheckGuidField ( 1724 IN SVfrVarStorageNode *pNode, 1725 IN EFI_GUID *StoreGuid, 1726 IN BOOLEAN *HasFoundOne, 1727 OUT EFI_VFR_RETURN_CODE *ReturnCode 1728 ) 1729 { 1730 if (StoreGuid != NULL) { 1731 // 1732 // If has guid info, compare the guid filed. 1733 // 1734 if (memcmp (StoreGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) { 1735 // 1736 // Both name and guid are same, this this varstore. 1737 // 1738 mCurrVarStorageNode = pNode; 1739 *ReturnCode = VFR_RETURN_SUCCESS; 1740 return TRUE; 1741 } 1742 } else { 1743 // 1744 // Not has Guid field, check whether this name is the only one. 1745 // 1746 if (*HasFoundOne) { 1747 // 1748 // The name has conflict, return name redefined. 1749 // 1750 *ReturnCode = VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR; 1751 return TRUE; 1752 } 1753 1754 *HasFoundOne = TRUE; 1755 mCurrVarStorageNode = pNode; 1756 } 1757 1758 return FALSE; 1759 } 1760 1761 /** 1762 Base on the input store name and guid to find the varstore id. 1763 1764 If both name and guid are inputed, base on the name and guid to 1765 found the varstore. If only name inputed, base on the name to 1766 found the varstore and go on to check whether more than one varstore 1767 has the same name. If only has found one varstore, return this 1768 varstore; if more than one varstore has same name, return varstore 1769 name redefined error. If no varstore found by varstore name, call 1770 function GetVarStoreByDataType and use inputed varstore name as 1771 data type name to search. 1772 **/ 1773 EFI_VFR_RETURN_CODE 1774 CVfrDataStorage::GetVarStoreId ( 1775 IN CHAR8 *StoreName, 1776 OUT EFI_VARSTORE_ID *VarStoreId, 1777 IN EFI_GUID *StoreGuid 1778 ) 1779 { 1780 EFI_VFR_RETURN_CODE ReturnCode; 1781 SVfrVarStorageNode *pNode; 1782 BOOLEAN HasFoundOne = FALSE; 1783 1784 mCurrVarStorageNode = NULL; 1785 1786 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1787 if (strcmp (pNode->mVarStoreName, StoreName) == 0) { 1788 if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) { 1789 *VarStoreId = mCurrVarStorageNode->mVarStoreId; 1790 return ReturnCode; 1791 } 1792 } 1793 } 1794 1795 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1796 if (strcmp (pNode->mVarStoreName, StoreName) == 0) { 1797 if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) { 1798 *VarStoreId = mCurrVarStorageNode->mVarStoreId; 1799 return ReturnCode; 1800 } 1801 } 1802 } 1803 1804 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1805 if (strcmp (pNode->mVarStoreName, StoreName) == 0) { 1806 if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) { 1807 *VarStoreId = mCurrVarStorageNode->mVarStoreId; 1808 return ReturnCode; 1809 } 1810 } 1811 } 1812 1813 if (HasFoundOne) { 1814 *VarStoreId = mCurrVarStorageNode->mVarStoreId; 1815 return VFR_RETURN_SUCCESS; 1816 } 1817 1818 *VarStoreId = EFI_VARSTORE_ID_INVALID; 1819 1820 // 1821 // Assume that Data strucutre name is used as StoreName, and check again. 1822 // 1823 ReturnCode = GetVarStoreByDataType (StoreName, &pNode, StoreGuid); 1824 if (pNode != NULL) { 1825 mCurrVarStorageNode = pNode; 1826 *VarStoreId = pNode->mVarStoreId; 1827 } 1828 1829 return ReturnCode; 1830 } 1831 1832 EFI_VFR_RETURN_CODE 1833 CVfrDataStorage::GetBufferVarStoreDataTypeName ( 1834 IN EFI_VARSTORE_ID VarStoreId, 1835 OUT CHAR8 **DataTypeName 1836 ) 1837 { 1838 SVfrVarStorageNode *pNode; 1839 1840 if (VarStoreId == EFI_VARSTORE_ID_INVALID) { 1841 return VFR_RETURN_FATAL_ERROR; 1842 } 1843 1844 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1845 if (pNode->mVarStoreId == VarStoreId) { 1846 *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName; 1847 return VFR_RETURN_SUCCESS; 1848 } 1849 } 1850 1851 return VFR_RETURN_UNDEFINED; 1852 } 1853 1854 EFI_VFR_VARSTORE_TYPE 1855 CVfrDataStorage::GetVarStoreType ( 1856 IN EFI_VARSTORE_ID VarStoreId 1857 ) 1858 { 1859 SVfrVarStorageNode *pNode; 1860 EFI_VFR_VARSTORE_TYPE VarStoreType; 1861 1862 VarStoreType = EFI_VFR_VARSTORE_INVALID; 1863 1864 if (VarStoreId == EFI_VARSTORE_ID_INVALID) { 1865 return VarStoreType; 1866 } 1867 1868 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1869 if (pNode->mVarStoreId == VarStoreId) { 1870 VarStoreType = pNode->mVarStoreType; 1871 return VarStoreType; 1872 } 1873 } 1874 1875 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1876 if (pNode->mVarStoreId == VarStoreId) { 1877 VarStoreType = pNode->mVarStoreType; 1878 return VarStoreType; 1879 } 1880 } 1881 1882 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1883 if (pNode->mVarStoreId == VarStoreId) { 1884 VarStoreType = pNode->mVarStoreType; 1885 return VarStoreType; 1886 } 1887 } 1888 1889 return VarStoreType; 1890 } 1891 1892 EFI_GUID * 1893 CVfrDataStorage::GetVarStoreGuid ( 1894 IN EFI_VARSTORE_ID VarStoreId 1895 ) 1896 { 1897 SVfrVarStorageNode *pNode; 1898 EFI_GUID *VarGuid; 1899 1900 VarGuid = NULL; 1901 1902 if (VarStoreId == EFI_VARSTORE_ID_INVALID) { 1903 return VarGuid; 1904 } 1905 1906 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1907 if (pNode->mVarStoreId == VarStoreId) { 1908 VarGuid = &pNode->mGuid; 1909 return VarGuid; 1910 } 1911 } 1912 1913 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1914 if (pNode->mVarStoreId == VarStoreId) { 1915 VarGuid = &pNode->mGuid; 1916 return VarGuid; 1917 } 1918 } 1919 1920 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1921 if (pNode->mVarStoreId == VarStoreId) { 1922 VarGuid = &pNode->mGuid; 1923 return VarGuid; 1924 } 1925 } 1926 1927 return VarGuid; 1928 } 1929 1930 EFI_VFR_RETURN_CODE 1931 CVfrDataStorage::GetVarStoreName ( 1932 IN EFI_VARSTORE_ID VarStoreId, 1933 OUT CHAR8 **VarStoreName 1934 ) 1935 { 1936 SVfrVarStorageNode *pNode; 1937 1938 if (VarStoreName == NULL) { 1939 return VFR_RETURN_FATAL_ERROR; 1940 } 1941 1942 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1943 if (pNode->mVarStoreId == VarStoreId) { 1944 *VarStoreName = pNode->mVarStoreName; 1945 return VFR_RETURN_SUCCESS; 1946 } 1947 } 1948 1949 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1950 if (pNode->mVarStoreId == VarStoreId) { 1951 *VarStoreName = pNode->mVarStoreName; 1952 return VFR_RETURN_SUCCESS; 1953 } 1954 } 1955 1956 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) { 1957 if (pNode->mVarStoreId == VarStoreId) { 1958 *VarStoreName = pNode->mVarStoreName; 1959 return VFR_RETURN_SUCCESS; 1960 } 1961 } 1962 1963 *VarStoreName = NULL; 1964 return VFR_RETURN_UNDEFINED; 1965 } 1966 1967 EFI_VFR_RETURN_CODE 1968 CVfrDataStorage::GetEfiVarStoreInfo ( 1969 IN OUT EFI_VARSTORE_INFO *Info 1970 ) 1971 { 1972 if (Info == NULL) { 1973 return VFR_RETURN_FATAL_ERROR; 1974 } 1975 1976 if (mCurrVarStorageNode == NULL) { 1977 return VFR_RETURN_GET_EFIVARSTORE_ERROR; 1978 } 1979 1980 Info->mInfo.mVarName = mCurrVarStorageNode->mStorageInfo.mEfiVar.mEfiVarName; 1981 Info->mVarTotalSize = mCurrVarStorageNode->mStorageInfo.mEfiVar.mEfiVarSize; 1982 switch (Info->mVarTotalSize) { 1983 case 1: 1984 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_8; 1985 break; 1986 case 2: 1987 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_16; 1988 break; 1989 case 4: 1990 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_32; 1991 break; 1992 case 8: 1993 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_64; 1994 break; 1995 default : 1996 return VFR_RETURN_FATAL_ERROR; 1997 } 1998 1999 return VFR_RETURN_SUCCESS; 2000 } 2001 2002 EFI_VFR_RETURN_CODE 2003 CVfrDataStorage::GetNameVarStoreInfo ( 2004 OUT EFI_VARSTORE_INFO *Info, 2005 IN UINT32 Index 2006 ) 2007 { 2008 if (Info == NULL) { 2009 return VFR_RETURN_FATAL_ERROR; 2010 } 2011 2012 if (mCurrVarStorageNode == NULL) { 2013 return VFR_RETURN_GET_NVVARSTORE_ERROR; 2014 } 2015 2016 // 2017 // Framework Vfr file Index is from 1, but Uefi Vfr file Index is from 0. 2018 // 2019 if (VfrCompatibleMode) { 2020 if (Index == 0) { 2021 return VFR_RETURN_ERROR_ARRARY_NUM; 2022 } 2023 Index --; 2024 } 2025 2026 Info->mInfo.mVarName = mCurrVarStorageNode->mStorageInfo.mNameSpace.mNameTable[Index]; 2027 2028 return VFR_RETURN_SUCCESS; 2029 } 2030 2031 SVfrDefaultStoreNode::SVfrDefaultStoreNode ( 2032 IN EFI_IFR_DEFAULTSTORE *ObjBinAddr, 2033 IN CHAR8 *RefName, 2034 IN EFI_STRING_ID DefaultStoreNameId, 2035 IN UINT16 DefaultId 2036 ) 2037 { 2038 mObjBinAddr = ObjBinAddr; 2039 2040 if (RefName != NULL) { 2041 mRefName = new CHAR8[strlen (RefName) + 1]; 2042 strcpy (mRefName, RefName); 2043 } else { 2044 mRefName = NULL; 2045 } 2046 2047 mNext = NULL; 2048 mDefaultId = DefaultId; 2049 mDefaultStoreNameId = DefaultStoreNameId; 2050 } 2051 2052 SVfrDefaultStoreNode::~SVfrDefaultStoreNode ( 2053 VOID 2054 ) 2055 { 2056 if (mRefName != NULL) { 2057 delete mRefName; 2058 } 2059 } 2060 2061 CVfrDefaultStore::CVfrDefaultStore ( 2062 VOID 2063 ) 2064 { 2065 mDefaultStoreList = NULL; 2066 } 2067 2068 CVfrDefaultStore::~CVfrDefaultStore ( 2069 VOID 2070 ) 2071 { 2072 SVfrDefaultStoreNode *pTmp = NULL; 2073 2074 while (mDefaultStoreList != NULL) { 2075 pTmp = mDefaultStoreList; 2076 mDefaultStoreList = mDefaultStoreList->mNext; 2077 delete pTmp; 2078 } 2079 } 2080 2081 EFI_VFR_RETURN_CODE 2082 CVfrDefaultStore::RegisterDefaultStore ( 2083 IN CHAR8 *ObjBinAddr, 2084 IN CHAR8 *RefName, 2085 IN EFI_STRING_ID DefaultStoreNameId, 2086 IN UINT16 DefaultId 2087 ) 2088 { 2089 SVfrDefaultStoreNode *pNode = NULL; 2090 2091 if (RefName == NULL) { 2092 return VFR_RETURN_FATAL_ERROR; 2093 } 2094 2095 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) { 2096 if (strcmp (pNode->mRefName, RefName) == 0) { 2097 return VFR_RETURN_REDEFINED; 2098 } 2099 } 2100 2101 if ((pNode = new SVfrDefaultStoreNode ((EFI_IFR_DEFAULTSTORE *)ObjBinAddr, RefName, DefaultStoreNameId, DefaultId)) == NULL) { 2102 return VFR_RETURN_OUT_FOR_RESOURCES; 2103 } 2104 2105 pNode->mNext = mDefaultStoreList; 2106 mDefaultStoreList = pNode; 2107 2108 return VFR_RETURN_SUCCESS; 2109 } 2110 2111 /* 2112 * assign new reference name or new default store name id only if 2113 * the original is invalid 2114 */ 2115 EFI_VFR_RETURN_CODE 2116 CVfrDefaultStore::ReRegisterDefaultStoreById ( 2117 IN UINT16 DefaultId, 2118 IN CHAR8 *RefName, 2119 IN EFI_STRING_ID DefaultStoreNameId 2120 ) 2121 { 2122 SVfrDefaultStoreNode *pNode = NULL; 2123 2124 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) { 2125 if (pNode->mDefaultId == DefaultId) { 2126 break; 2127 } 2128 } 2129 2130 if (pNode == NULL) { 2131 return VFR_RETURN_UNDEFINED; 2132 } else { 2133 if (pNode->mDefaultStoreNameId == EFI_STRING_ID_INVALID) { 2134 pNode->mDefaultStoreNameId = DefaultStoreNameId; 2135 if (pNode->mObjBinAddr != NULL) { 2136 pNode->mObjBinAddr->DefaultName = DefaultStoreNameId; 2137 } 2138 } else { 2139 return VFR_RETURN_REDEFINED; 2140 } 2141 2142 if (RefName != NULL) { 2143 delete pNode->mRefName; 2144 pNode->mRefName = new CHAR8[strlen (RefName) + 1]; 2145 if (pNode->mRefName != NULL) { 2146 strcpy (pNode->mRefName, RefName); 2147 } 2148 } 2149 } 2150 2151 return VFR_RETURN_SUCCESS; 2152 } 2153 2154 BOOLEAN 2155 CVfrDefaultStore::DefaultIdRegistered ( 2156 IN UINT16 DefaultId 2157 ) 2158 { 2159 SVfrDefaultStoreNode *pNode = NULL; 2160 2161 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) { 2162 if (pNode->mDefaultId == DefaultId) { 2163 return TRUE; 2164 } 2165 } 2166 2167 return FALSE; 2168 } 2169 2170 EFI_VFR_RETURN_CODE 2171 CVfrDefaultStore::GetDefaultId ( 2172 IN CHAR8 *RefName, 2173 OUT UINT16 *DefaultId 2174 ) 2175 { 2176 SVfrDefaultStoreNode *pTmp = NULL; 2177 2178 if (DefaultId == NULL) { 2179 return VFR_RETURN_FATAL_ERROR; 2180 } 2181 2182 for (pTmp = mDefaultStoreList; pTmp != NULL; pTmp = pTmp->mNext) { 2183 if (strcmp (pTmp->mRefName, RefName) == 0) { 2184 *DefaultId = pTmp->mDefaultId; 2185 return VFR_RETURN_SUCCESS; 2186 } 2187 } 2188 2189 return VFR_RETURN_UNDEFINED; 2190 } 2191 2192 EFI_VFR_RETURN_CODE 2193 CVfrDefaultStore::BufferVarStoreAltConfigAdd ( 2194 IN EFI_VARSTORE_ID DefaultId, 2195 IN EFI_VARSTORE_INFO &Info, 2196 IN CHAR8 *VarStoreName, 2197 IN EFI_GUID *VarStoreGuid, 2198 IN UINT8 Type, 2199 IN EFI_IFR_TYPE_VALUE Value 2200 ) 2201 { 2202 SVfrDefaultStoreNode *pNode = NULL; 2203 CHAR8 NewAltCfg[2 * 2 * sizeof (UINT16) + 1] = {0,}; 2204 INTN Returnvalue = 0; 2205 2206 if (VarStoreName == NULL) { 2207 return VFR_RETURN_FATAL_ERROR; 2208 } 2209 2210 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) { 2211 if (pNode->mDefaultId == DefaultId) { 2212 break; 2213 } 2214 } 2215 2216 if (pNode == NULL) { 2217 return VFR_RETURN_UNDEFINED; 2218 } 2219 2220 gCVfrBufferConfig.Open (); 2221 2222 sprintf (NewAltCfg, "%04x", pNode->mDefaultId); 2223 if ((Returnvalue = gCVfrBufferConfig.Select(VarStoreName, VarStoreGuid)) == 0) { 2224 if ((Returnvalue = gCVfrBufferConfig.Write ('a', VarStoreName, VarStoreGuid, NewAltCfg, Type, Info.mInfo.mVarOffset, Info.mVarTotalSize, Value)) != 0) { 2225 goto WriteError; 2226 } 2227 } 2228 2229 gCVfrBufferConfig.Close (); 2230 2231 return VFR_RETURN_SUCCESS; 2232 2233 WriteError: 2234 gCVfrBufferConfig.Close (); 2235 return (EFI_VFR_RETURN_CODE)Returnvalue; 2236 } 2237 2238 SVfrRuleNode::SVfrRuleNode ( 2239 IN CHAR8 *RuleName, 2240 IN UINT8 RuleId 2241 ) 2242 { 2243 if (RuleName != NULL) { 2244 mRuleName = new CHAR8[strlen (RuleName) + 1]; 2245 strcpy (mRuleName, RuleName); 2246 } else { 2247 mRuleName = NULL; 2248 } 2249 2250 mNext = NULL; 2251 mRuleId = RuleId; 2252 } 2253 2254 SVfrRuleNode::~SVfrRuleNode ( 2255 VOID 2256 ) 2257 { 2258 if (mRuleName != NULL) { 2259 delete mRuleName; 2260 } 2261 } 2262 2263 CVfrRulesDB::CVfrRulesDB () 2264 { 2265 mRuleList = NULL; 2266 mFreeRuleId = EFI_VARSTORE_ID_START; 2267 } 2268 2269 CVfrRulesDB::~CVfrRulesDB () 2270 { 2271 SVfrRuleNode *pNode; 2272 2273 while(mRuleList != NULL) { 2274 pNode = mRuleList; 2275 mRuleList = mRuleList->mNext; 2276 delete pNode; 2277 } 2278 } 2279 2280 VOID 2281 CVfrRulesDB::RegisterRule ( 2282 IN CHAR8 *RuleName 2283 ) 2284 { 2285 SVfrRuleNode *pNew; 2286 2287 if (RuleName == NULL) { 2288 return ; 2289 } 2290 2291 if ((pNew = new SVfrRuleNode (RuleName, mFreeRuleId)) == NULL) { 2292 return ; 2293 } 2294 2295 mFreeRuleId++; 2296 2297 pNew->mNext = mRuleList; 2298 mRuleList = pNew; 2299 } 2300 2301 UINT8 2302 CVfrRulesDB::GetRuleId ( 2303 IN CHAR8 *RuleName 2304 ) 2305 { 2306 SVfrRuleNode *pNode; 2307 2308 if (RuleName == NULL) { 2309 return EFI_RULE_ID_INVALID; 2310 } 2311 2312 for (pNode = mRuleList; pNode != NULL; pNode = pNode->mNext) { 2313 if (strcmp (pNode->mRuleName, RuleName) == 0) { 2314 return pNode->mRuleId; 2315 } 2316 } 2317 2318 return EFI_RULE_ID_INVALID; 2319 } 2320 2321 CVfrRulesDB gCVfrRulesDB; 2322 2323 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO ( 2324 VOID 2325 ) 2326 { 2327 mVarStoreId = EFI_VARSTORE_ID_INVALID; 2328 mInfo.mVarName = EFI_STRING_ID_INVALID; 2329 mInfo.mVarOffset = EFI_VAROFFSET_INVALID; 2330 mVarType = EFI_IFR_TYPE_OTHER; 2331 mVarTotalSize = 0; 2332 } 2333 2334 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO ( 2335 IN EFI_VARSTORE_INFO &Info 2336 ) 2337 { 2338 mVarStoreId = Info.mVarStoreId; 2339 mInfo.mVarName = Info.mInfo.mVarName; 2340 mInfo.mVarOffset = Info.mInfo.mVarOffset; 2341 mVarType = Info.mVarType; 2342 mVarTotalSize = Info.mVarTotalSize; 2343 } 2344 2345 BOOLEAN 2346 EFI_VARSTORE_INFO::operator == ( 2347 IN EFI_VARSTORE_INFO *Info 2348 ) 2349 { 2350 if ((mVarStoreId == Info->mVarStoreId) && 2351 (mInfo.mVarName == Info->mInfo.mVarName) && 2352 (mInfo.mVarOffset == Info->mInfo.mVarOffset) && 2353 (mVarType == Info->mVarType) && 2354 (mVarTotalSize == Info->mVarTotalSize)) { 2355 return TRUE; 2356 } 2357 2358 return FALSE; 2359 } 2360 2361 static EFI_VARSTORE_INFO gEfiInvalidVarStoreInfo; 2362 2363 EFI_QUESTION_ID 2364 CVfrQuestionDB::GetFreeQuestionId ( 2365 VOID 2366 ) 2367 { 2368 UINT32 Index, Mask, Offset; 2369 2370 for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) { 2371 if (mFreeQIdBitMap[Index] != 0xFFFFFFFF) { 2372 break; 2373 } 2374 } 2375 2376 for (Offset = 0, Mask = 0x80000000; Mask != 0; Mask >>= 1, Offset++) { 2377 if ((mFreeQIdBitMap[Index] & Mask) == 0) { 2378 mFreeQIdBitMap[Index] |= Mask; 2379 return (EFI_QUESTION_ID)((Index << EFI_BITS_SHIFT_PER_UINT32) + Offset); 2380 } 2381 } 2382 2383 return EFI_QUESTION_ID_INVALID; 2384 } 2385 2386 BOOLEAN 2387 CVfrQuestionDB::ChekQuestionIdFree ( 2388 IN EFI_QUESTION_ID QId 2389 ) 2390 { 2391 UINT32 Index = (QId / EFI_BITS_PER_UINT32); 2392 UINT32 Offset = (QId % EFI_BITS_PER_UINT32); 2393 2394 return (mFreeQIdBitMap[Index] & (0x80000000 >> Offset)) == 0; 2395 } 2396 2397 VOID 2398 CVfrQuestionDB::MarkQuestionIdUsed ( 2399 IN EFI_QUESTION_ID QId 2400 ) 2401 { 2402 UINT32 Index = (QId / EFI_BITS_PER_UINT32); 2403 UINT32 Offset = (QId % EFI_BITS_PER_UINT32); 2404 2405 mFreeQIdBitMap[Index] |= (0x80000000 >> Offset); 2406 } 2407 2408 VOID 2409 CVfrQuestionDB::MarkQuestionIdUnused ( 2410 IN EFI_QUESTION_ID QId 2411 ) 2412 { 2413 UINT32 Index = (QId / EFI_BITS_PER_UINT32); 2414 UINT32 Offset = (QId % EFI_BITS_PER_UINT32); 2415 2416 mFreeQIdBitMap[Index] &= ~(0x80000000 >> Offset); 2417 } 2418 2419 SVfrQuestionNode::SVfrQuestionNode ( 2420 IN CHAR8 *Name, 2421 IN CHAR8 *VarIdStr, 2422 IN UINT32 BitMask 2423 ) 2424 { 2425 mName = NULL; 2426 mVarIdStr = NULL; 2427 mQuestionId = EFI_QUESTION_ID_INVALID; 2428 mBitMask = BitMask; 2429 mNext = NULL; 2430 mQtype = QUESTION_NORMAL; 2431 2432 if (Name == NULL) { 2433 mName = new CHAR8[strlen ("$DEFAULT") + 1]; 2434 strcpy (mName, "$DEFAULT"); 2435 } else { 2436 mName = new CHAR8[strlen (Name) + 1]; 2437 strcpy (mName, Name); 2438 } 2439 2440 if (VarIdStr != NULL) { 2441 mVarIdStr = new CHAR8[strlen (VarIdStr) + 1]; 2442 strcpy (mVarIdStr, VarIdStr); 2443 } else { 2444 mVarIdStr = new CHAR8[strlen ("$") + 1]; 2445 strcpy (mVarIdStr, "$"); 2446 } 2447 } 2448 2449 SVfrQuestionNode::~SVfrQuestionNode ( 2450 VOID 2451 ) 2452 { 2453 if (mName != NULL) { 2454 delete mName; 2455 } 2456 2457 if (mVarIdStr != NULL) { 2458 delete mVarIdStr; 2459 } 2460 } 2461 2462 CVfrQuestionDB::CVfrQuestionDB () 2463 { 2464 UINT32 Index; 2465 2466 for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) { 2467 mFreeQIdBitMap[Index] = 0; 2468 } 2469 2470 // Question ID 0 is reserved. 2471 mFreeQIdBitMap[0] = 0x80000000; 2472 mQuestionList = NULL; 2473 } 2474 2475 CVfrQuestionDB::~CVfrQuestionDB () 2476 { 2477 SVfrQuestionNode *pNode; 2478 2479 while (mQuestionList != NULL) { 2480 pNode = mQuestionList; 2481 mQuestionList = mQuestionList->mNext; 2482 delete pNode; 2483 } 2484 } 2485 2486 // 2487 // Reset to init state 2488 // 2489 VOID 2490 CVfrQuestionDB::ResetInit( 2491 IN VOID 2492 ) 2493 { 2494 UINT32 Index; 2495 SVfrQuestionNode *pNode; 2496 2497 while (mQuestionList != NULL) { 2498 pNode = mQuestionList; 2499 mQuestionList = mQuestionList->mNext; 2500 delete pNode; 2501 } 2502 2503 for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) { 2504 mFreeQIdBitMap[Index] = 0; 2505 } 2506 2507 // Question ID 0 is reserved. 2508 mFreeQIdBitMap[0] = 0x80000000; 2509 mQuestionList = NULL; 2510 } 2511 2512 VOID 2513 CVfrQuestionDB::PrintAllQuestion ( 2514 VOID 2515 ) 2516 { 2517 SVfrQuestionNode *pNode = NULL; 2518 2519 for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) { 2520 printf ("Question VarId is %s and QuesitonId is 0x%x\n", pNode->mVarIdStr, pNode->mQuestionId); 2521 } 2522 } 2523 2524 EFI_VFR_RETURN_CODE 2525 CVfrQuestionDB::RegisterQuestion ( 2526 IN CHAR8 *Name, 2527 IN CHAR8 *VarIdStr, 2528 IN OUT EFI_QUESTION_ID &QuestionId 2529 ) 2530 { 2531 SVfrQuestionNode *pNode = NULL; 2532 2533 if ((Name != NULL) && (FindQuestion(Name) == VFR_RETURN_SUCCESS)) { 2534 return VFR_RETURN_REDEFINED; 2535 } 2536 2537 if ((pNode = new SVfrQuestionNode (Name, VarIdStr)) == NULL) { 2538 return VFR_RETURN_OUT_FOR_RESOURCES; 2539 } 2540 2541 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2542 QuestionId = GetFreeQuestionId (); 2543 } else { 2544 // 2545 // For Framework Vfr, don't check question ID conflict. 2546 // 2547 if (!VfrCompatibleMode && ChekQuestionIdFree (QuestionId) == FALSE) { 2548 delete pNode; 2549 return VFR_RETURN_QUESTIONID_REDEFINED; 2550 } 2551 MarkQuestionIdUsed (QuestionId); 2552 } 2553 pNode->mQuestionId = QuestionId; 2554 2555 pNode->mNext = mQuestionList; 2556 mQuestionList = pNode; 2557 2558 gCFormPkg.DoPendingAssign (VarIdStr, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2559 2560 return VFR_RETURN_SUCCESS; 2561 } 2562 2563 VOID 2564 CVfrQuestionDB::RegisterOldDateQuestion ( 2565 IN CHAR8 *YearVarId, 2566 IN CHAR8 *MonthVarId, 2567 IN CHAR8 *DayVarId, 2568 IN OUT EFI_QUESTION_ID &QuestionId 2569 ) 2570 { 2571 SVfrQuestionNode *pNode[3] = {NULL, }; 2572 UINT32 Index; 2573 2574 if ((YearVarId == NULL) || (MonthVarId == NULL) || (DayVarId == NULL)) { 2575 return; 2576 } 2577 2578 if ((pNode[0] = new SVfrQuestionNode (NULL, YearVarId, DATE_YEAR_BITMASK)) == NULL) { 2579 goto Err; 2580 } 2581 if ((pNode[1] = new SVfrQuestionNode (NULL, MonthVarId, DATE_MONTH_BITMASK)) == NULL) { 2582 goto Err; 2583 } 2584 if ((pNode[2] = new SVfrQuestionNode (NULL, DayVarId, DATE_DAY_BITMASK)) == NULL) { 2585 goto Err; 2586 } 2587 2588 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2589 QuestionId = GetFreeQuestionId (); 2590 } else { 2591 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2592 goto Err; 2593 } 2594 MarkQuestionIdUsed (QuestionId); 2595 } 2596 2597 pNode[0]->mQuestionId = QuestionId; 2598 pNode[1]->mQuestionId = QuestionId; 2599 pNode[2]->mQuestionId = QuestionId; 2600 pNode[0]->mQtype = QUESTION_DATE; 2601 pNode[1]->mQtype = QUESTION_DATE; 2602 pNode[2]->mQtype = QUESTION_DATE; 2603 pNode[0]->mNext = pNode[1]; 2604 pNode[1]->mNext = pNode[2]; 2605 pNode[2]->mNext = mQuestionList; 2606 mQuestionList = pNode[0]; 2607 2608 gCFormPkg.DoPendingAssign (YearVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2609 gCFormPkg.DoPendingAssign (MonthVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2610 gCFormPkg.DoPendingAssign (DayVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2611 2612 return; 2613 2614 Err: 2615 for (Index = 0; Index < 3; Index++) { 2616 if (pNode[Index] != NULL) { 2617 delete pNode[Index]; 2618 } 2619 } 2620 QuestionId = EFI_QUESTION_ID_INVALID; 2621 } 2622 2623 VOID 2624 CVfrQuestionDB::RegisterNewDateQuestion ( 2625 IN CHAR8 *Name, 2626 IN CHAR8 *BaseVarId, 2627 IN OUT EFI_QUESTION_ID &QuestionId 2628 ) 2629 { 2630 SVfrQuestionNode *pNode[3] = {NULL, }; 2631 UINT32 Len; 2632 CHAR8 *VarIdStr[3] = {NULL, }; 2633 CHAR8 Index; 2634 2635 if (BaseVarId == NULL && Name == NULL) { 2636 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2637 QuestionId = GetFreeQuestionId (); 2638 } else { 2639 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2640 goto Err; 2641 } 2642 MarkQuestionIdUsed (QuestionId); 2643 } 2644 return; 2645 } 2646 2647 if (BaseVarId != NULL) { 2648 Len = strlen (BaseVarId); 2649 2650 VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1]; 2651 if (VarIdStr[0] != NULL) { 2652 strcpy (VarIdStr[0], BaseVarId); 2653 strcat (VarIdStr[0], ".Year"); 2654 } 2655 VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1]; 2656 if (VarIdStr[1] != NULL) { 2657 strcpy (VarIdStr[1], BaseVarId); 2658 strcat (VarIdStr[1], ".Month"); 2659 } 2660 VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1]; 2661 if (VarIdStr[2] != NULL) { 2662 strcpy (VarIdStr[2], BaseVarId); 2663 strcat (VarIdStr[2], ".Day"); 2664 } 2665 } else { 2666 Len = strlen (Name); 2667 2668 VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1]; 2669 if (VarIdStr[0] != NULL) { 2670 strcpy (VarIdStr[0], Name); 2671 strcat (VarIdStr[0], ".Year"); 2672 } 2673 VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1]; 2674 if (VarIdStr[1] != NULL) { 2675 strcpy (VarIdStr[1], Name); 2676 strcat (VarIdStr[1], ".Month"); 2677 } 2678 VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1]; 2679 if (VarIdStr[2] != NULL) { 2680 strcpy (VarIdStr[2], Name); 2681 strcat (VarIdStr[2], ".Day"); 2682 } 2683 } 2684 2685 if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], DATE_YEAR_BITMASK)) == NULL) { 2686 goto Err; 2687 } 2688 if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1], DATE_MONTH_BITMASK)) == NULL) { 2689 goto Err; 2690 } 2691 if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2], DATE_DAY_BITMASK)) == NULL) { 2692 goto Err; 2693 } 2694 2695 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2696 QuestionId = GetFreeQuestionId (); 2697 } else { 2698 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2699 goto Err; 2700 } 2701 MarkQuestionIdUsed (QuestionId); 2702 } 2703 2704 pNode[0]->mQuestionId = QuestionId; 2705 pNode[1]->mQuestionId = QuestionId; 2706 pNode[2]->mQuestionId = QuestionId; 2707 pNode[0]->mQtype = QUESTION_DATE; 2708 pNode[1]->mQtype = QUESTION_DATE; 2709 pNode[2]->mQtype = QUESTION_DATE; 2710 pNode[0]->mNext = pNode[1]; 2711 pNode[1]->mNext = pNode[2]; 2712 pNode[2]->mNext = mQuestionList; 2713 mQuestionList = pNode[0]; 2714 2715 for (Index = 0; Index < 3; Index++) { 2716 if (VarIdStr[Index] != NULL) { 2717 delete VarIdStr[Index]; 2718 } 2719 } 2720 2721 gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2722 gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2723 gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2724 2725 return; 2726 2727 Err: 2728 for (Index = 0; Index < 3; Index++) { 2729 if (pNode[Index] != NULL) { 2730 delete pNode[Index]; 2731 } 2732 2733 if (VarIdStr[Index] != NULL) { 2734 delete VarIdStr[Index]; 2735 } 2736 } 2737 } 2738 2739 VOID 2740 CVfrQuestionDB::RegisterOldTimeQuestion ( 2741 IN CHAR8 *HourVarId, 2742 IN CHAR8 *MinuteVarId, 2743 IN CHAR8 *SecondVarId, 2744 IN OUT EFI_QUESTION_ID &QuestionId 2745 ) 2746 { 2747 SVfrQuestionNode *pNode[3] = {NULL, }; 2748 UINT32 Index; 2749 2750 if ((HourVarId == NULL) || (MinuteVarId == NULL) || (SecondVarId == NULL)) { 2751 return; 2752 } 2753 2754 if ((pNode[0] = new SVfrQuestionNode (NULL, HourVarId, TIME_HOUR_BITMASK)) == NULL) { 2755 goto Err; 2756 } 2757 if ((pNode[1] = new SVfrQuestionNode (NULL, MinuteVarId, TIME_MINUTE_BITMASK)) == NULL) { 2758 goto Err; 2759 } 2760 if ((pNode[2] = new SVfrQuestionNode (NULL, SecondVarId, TIME_SECOND_BITMASK)) == NULL) { 2761 goto Err; 2762 } 2763 2764 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2765 QuestionId = GetFreeQuestionId (); 2766 } else { 2767 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2768 goto Err; 2769 } 2770 MarkQuestionIdUsed (QuestionId); 2771 } 2772 2773 pNode[0]->mQuestionId = QuestionId; 2774 pNode[1]->mQuestionId = QuestionId; 2775 pNode[2]->mQuestionId = QuestionId; 2776 pNode[0]->mQtype = QUESTION_TIME; 2777 pNode[1]->mQtype = QUESTION_TIME; 2778 pNode[2]->mQtype = QUESTION_TIME; 2779 pNode[0]->mNext = pNode[1]; 2780 pNode[1]->mNext = pNode[2]; 2781 pNode[2]->mNext = mQuestionList; 2782 mQuestionList = pNode[0]; 2783 2784 gCFormPkg.DoPendingAssign (HourVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2785 gCFormPkg.DoPendingAssign (MinuteVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2786 gCFormPkg.DoPendingAssign (SecondVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2787 2788 return; 2789 2790 Err: 2791 for (Index = 0; Index < 3; Index++) { 2792 if (pNode[Index] != NULL) { 2793 delete pNode[Index]; 2794 } 2795 } 2796 QuestionId = EFI_QUESTION_ID_INVALID; 2797 } 2798 2799 VOID 2800 CVfrQuestionDB::RegisterNewTimeQuestion ( 2801 IN CHAR8 *Name, 2802 IN CHAR8 *BaseVarId, 2803 IN OUT EFI_QUESTION_ID &QuestionId 2804 ) 2805 { 2806 SVfrQuestionNode *pNode[3] = {NULL, }; 2807 UINT32 Len; 2808 CHAR8 *VarIdStr[3] = {NULL, }; 2809 CHAR8 Index; 2810 2811 if (BaseVarId == NULL && Name == NULL) { 2812 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2813 QuestionId = GetFreeQuestionId (); 2814 } else { 2815 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2816 goto Err; 2817 } 2818 MarkQuestionIdUsed (QuestionId); 2819 } 2820 return; 2821 } 2822 2823 if (BaseVarId != NULL) { 2824 Len = strlen (BaseVarId); 2825 2826 VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1]; 2827 if (VarIdStr[0] != NULL) { 2828 strcpy (VarIdStr[0], BaseVarId); 2829 strcat (VarIdStr[0], ".Hour"); 2830 } 2831 VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1]; 2832 if (VarIdStr[1] != NULL) { 2833 strcpy (VarIdStr[1], BaseVarId); 2834 strcat (VarIdStr[1], ".Minute"); 2835 } 2836 VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1]; 2837 if (VarIdStr[2] != NULL) { 2838 strcpy (VarIdStr[2], BaseVarId); 2839 strcat (VarIdStr[2], ".Second"); 2840 } 2841 } else { 2842 Len = strlen (Name); 2843 2844 VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1]; 2845 if (VarIdStr[0] != NULL) { 2846 strcpy (VarIdStr[0], Name); 2847 strcat (VarIdStr[0], ".Hour"); 2848 } 2849 VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1]; 2850 if (VarIdStr[1] != NULL) { 2851 strcpy (VarIdStr[1], Name); 2852 strcat (VarIdStr[1], ".Minute"); 2853 } 2854 VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1]; 2855 if (VarIdStr[2] != NULL) { 2856 strcpy (VarIdStr[2], Name); 2857 strcat (VarIdStr[2], ".Second"); 2858 } 2859 } 2860 2861 if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], TIME_HOUR_BITMASK)) == NULL) { 2862 goto Err; 2863 } 2864 if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1], TIME_MINUTE_BITMASK)) == NULL) { 2865 goto Err; 2866 } 2867 if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2], TIME_SECOND_BITMASK)) == NULL) { 2868 goto Err; 2869 } 2870 2871 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2872 QuestionId = GetFreeQuestionId (); 2873 } else { 2874 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2875 goto Err; 2876 } 2877 MarkQuestionIdUsed (QuestionId); 2878 } 2879 2880 pNode[0]->mQuestionId = QuestionId; 2881 pNode[1]->mQuestionId = QuestionId; 2882 pNode[2]->mQuestionId = QuestionId; 2883 pNode[0]->mQtype = QUESTION_TIME; 2884 pNode[1]->mQtype = QUESTION_TIME; 2885 pNode[2]->mQtype = QUESTION_TIME; 2886 pNode[0]->mNext = pNode[1]; 2887 pNode[1]->mNext = pNode[2]; 2888 pNode[2]->mNext = mQuestionList; 2889 mQuestionList = pNode[0]; 2890 2891 for (Index = 0; Index < 3; Index++) { 2892 if (VarIdStr[Index] != NULL) { 2893 delete VarIdStr[Index]; 2894 } 2895 } 2896 2897 gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2898 gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2899 gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 2900 2901 return; 2902 2903 Err: 2904 for (Index = 0; Index < 3; Index++) { 2905 if (pNode[Index] != NULL) { 2906 delete pNode[Index]; 2907 } 2908 2909 if (VarIdStr[Index] != NULL) { 2910 delete VarIdStr[Index]; 2911 } 2912 } 2913 } 2914 2915 VOID 2916 CVfrQuestionDB::RegisterRefQuestion ( 2917 IN CHAR8 *Name, 2918 IN CHAR8 *BaseVarId, 2919 IN OUT EFI_QUESTION_ID &QuestionId 2920 ) 2921 { 2922 SVfrQuestionNode *pNode[4] = {NULL, }; 2923 UINT32 Len; 2924 CHAR8 *VarIdStr[4] = {NULL, }; 2925 CHAR8 Index; 2926 2927 if (BaseVarId == NULL && Name == NULL) { 2928 return; 2929 } 2930 2931 if (BaseVarId != NULL) { 2932 Len = strlen (BaseVarId); 2933 2934 VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1]; 2935 if (VarIdStr[0] != NULL) { 2936 strcpy (VarIdStr[0], BaseVarId); 2937 strcat (VarIdStr[0], ".QuestionId"); 2938 } 2939 VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1]; 2940 if (VarIdStr[1] != NULL) { 2941 strcpy (VarIdStr[1], BaseVarId); 2942 strcat (VarIdStr[1], ".FormId"); 2943 } 2944 VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1]; 2945 if (VarIdStr[2] != NULL) { 2946 strcpy (VarIdStr[2], BaseVarId); 2947 strcat (VarIdStr[2], ".FormSetGuid"); 2948 } 2949 VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1]; 2950 if (VarIdStr[3] != NULL) { 2951 strcpy (VarIdStr[3], BaseVarId); 2952 strcat (VarIdStr[3], ".DevicePath"); 2953 } 2954 } else { 2955 Len = strlen (Name); 2956 2957 VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1]; 2958 if (VarIdStr[0] != NULL) { 2959 strcpy (VarIdStr[0], Name); 2960 strcat (VarIdStr[0], ".QuestionId"); 2961 } 2962 VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1]; 2963 if (VarIdStr[1] != NULL) { 2964 strcpy (VarIdStr[1], Name); 2965 strcat (VarIdStr[1], ".FormId"); 2966 } 2967 VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1]; 2968 if (VarIdStr[2] != NULL) { 2969 strcpy (VarIdStr[2], Name); 2970 strcat (VarIdStr[2], ".FormSetGuid"); 2971 } 2972 VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1]; 2973 if (VarIdStr[3] != NULL) { 2974 strcpy (VarIdStr[3], Name); 2975 strcat (VarIdStr[3], ".DevicePath"); 2976 } 2977 } 2978 2979 if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0])) == NULL) { 2980 goto Err; 2981 } 2982 if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1])) == NULL) { 2983 goto Err; 2984 } 2985 if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2])) == NULL) { 2986 goto Err; 2987 } 2988 if ((pNode[3] = new SVfrQuestionNode (Name, VarIdStr[3])) == NULL) { 2989 goto Err; 2990 } 2991 2992 if (QuestionId == EFI_QUESTION_ID_INVALID) { 2993 QuestionId = GetFreeQuestionId (); 2994 } else { 2995 if (ChekQuestionIdFree (QuestionId) == FALSE) { 2996 goto Err; 2997 } 2998 MarkQuestionIdUsed (QuestionId); 2999 } 3000 3001 pNode[0]->mQuestionId = QuestionId; 3002 pNode[1]->mQuestionId = QuestionId; 3003 pNode[2]->mQuestionId = QuestionId; 3004 pNode[3]->mQuestionId = QuestionId; 3005 pNode[0]->mQtype = QUESTION_REF; 3006 pNode[1]->mQtype = QUESTION_REF; 3007 pNode[2]->mQtype = QUESTION_REF; 3008 pNode[3]->mQtype = QUESTION_REF; 3009 pNode[0]->mNext = pNode[1]; 3010 pNode[1]->mNext = pNode[2]; 3011 pNode[2]->mNext = pNode[3]; 3012 pNode[3]->mNext = mQuestionList; 3013 mQuestionList = pNode[0]; 3014 3015 gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 3016 gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 3017 gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 3018 gCFormPkg.DoPendingAssign (VarIdStr[3], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID)); 3019 3020 return; 3021 3022 Err: 3023 for (Index = 0; Index < 4; Index++) { 3024 if (pNode[Index] != NULL) { 3025 delete pNode[Index]; 3026 } 3027 3028 if (VarIdStr[Index] != NULL) { 3029 delete VarIdStr[Index]; 3030 } 3031 } 3032 } 3033 3034 EFI_VFR_RETURN_CODE 3035 CVfrQuestionDB::UpdateQuestionId ( 3036 IN EFI_QUESTION_ID QId, 3037 IN EFI_QUESTION_ID NewQId 3038 ) 3039 { 3040 SVfrQuestionNode *pNode = NULL; 3041 3042 if (QId == NewQId) { 3043 // don't update 3044 return VFR_RETURN_SUCCESS; 3045 } 3046 3047 // 3048 // For Framework Vfr, don't check question ID conflict. 3049 // 3050 if (!VfrCompatibleMode && ChekQuestionIdFree (NewQId) == FALSE) { 3051 return VFR_RETURN_REDEFINED; 3052 } 3053 3054 for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) { 3055 if (pNode->mQuestionId == QId) { 3056 break; 3057 } 3058 } 3059 3060 if (pNode == NULL) { 3061 return VFR_RETURN_UNDEFINED; 3062 } 3063 3064 MarkQuestionIdUnused (QId); 3065 pNode->mQuestionId = NewQId; 3066 MarkQuestionIdUsed (NewQId); 3067 3068 gCFormPkg.DoPendingAssign (pNode->mVarIdStr, (VOID *)&NewQId, sizeof(EFI_QUESTION_ID)); 3069 3070 return VFR_RETURN_SUCCESS; 3071 } 3072 3073 VOID 3074 CVfrQuestionDB::GetQuestionId ( 3075 IN CHAR8 *Name, 3076 IN CHAR8 *VarIdStr, 3077 OUT EFI_QUESTION_ID &QuestionId, 3078 OUT UINT32 &BitMask, 3079 OUT EFI_QUESION_TYPE *QType 3080 ) 3081 { 3082 SVfrQuestionNode *pNode; 3083 3084 QuestionId = EFI_QUESTION_ID_INVALID; 3085 BitMask = 0x00000000; 3086 if (QType != NULL) { 3087 *QType = QUESTION_NORMAL; 3088 } 3089 3090 if ((Name == NULL) && (VarIdStr == NULL)) { 3091 return ; 3092 } 3093 3094 for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) { 3095 if (Name != NULL) { 3096 if (strcmp (pNode->mName, Name) != 0) { 3097 continue; 3098 } 3099 } 3100 3101 if (VarIdStr != NULL) { 3102 if (strcmp (pNode->mVarIdStr, VarIdStr) != 0) { 3103 continue; 3104 } 3105 } 3106 3107 QuestionId = pNode->mQuestionId; 3108 BitMask = pNode->mBitMask; 3109 if (QType != NULL) { 3110 *QType = pNode->mQtype; 3111 } 3112 break; 3113 } 3114 3115 return ; 3116 } 3117 3118 EFI_VFR_RETURN_CODE 3119 CVfrQuestionDB::FindQuestion ( 3120 IN EFI_QUESTION_ID QuestionId 3121 ) 3122 { 3123 SVfrQuestionNode *pNode; 3124 3125 if (QuestionId == EFI_QUESTION_ID_INVALID) { 3126 return VFR_RETURN_INVALID_PARAMETER; 3127 } 3128 3129 for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) { 3130 if (pNode->mQuestionId == QuestionId) { 3131 return VFR_RETURN_SUCCESS; 3132 } 3133 } 3134 3135 return VFR_RETURN_UNDEFINED; 3136 } 3137 3138 EFI_VFR_RETURN_CODE 3139 CVfrQuestionDB::FindQuestion ( 3140 IN CHAR8 *Name 3141 ) 3142 { 3143 SVfrQuestionNode *pNode; 3144 3145 if (Name == NULL) { 3146 return VFR_RETURN_FATAL_ERROR; 3147 } 3148 3149 for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) { 3150 if (strcmp (pNode->mName, Name) == 0) { 3151 return VFR_RETURN_SUCCESS; 3152 } 3153 } 3154 3155 return VFR_RETURN_UNDEFINED; 3156 } 3157 3158 CVfrStringDB::CVfrStringDB () 3159 { 3160 mStringFileName = NULL; 3161 } 3162 3163 CVfrStringDB::~CVfrStringDB () 3164 { 3165 if (mStringFileName != NULL) { 3166 delete mStringFileName; 3167 } 3168 mStringFileName = NULL; 3169 } 3170 3171 3172 VOID 3173 CVfrStringDB::SetStringFileName(IN CHAR8 *StringFileName) 3174 { 3175 UINT32 FileLen = 0; 3176 3177 if (StringFileName == NULL) { 3178 return; 3179 } 3180 3181 FileLen = strlen (StringFileName) + 1; 3182 mStringFileName = new CHAR8[FileLen]; 3183 if (mStringFileName == NULL) { 3184 return; 3185 } 3186 3187 strcpy (mStringFileName, StringFileName); 3188 mStringFileName[FileLen - 1] = '\0'; 3189 } 3190 3191 3192 /** 3193 Returns TRUE or FALSE whether SupportedLanguages contains the best matching language 3194 from a set of supported languages. 3195 3196 @param[in] SupportedLanguages A pointer to a Null-terminated ASCII string that 3197 contains a set of language codes. 3198 @param[in] Language A variable that contains pointers to Null-terminated 3199 ASCII strings that contain one language codes. 3200 3201 @retval FALSE The best matching language could not be found in SupportedLanguages. 3202 @retval TRUE The best matching language could be found in SupportedLanguages. 3203 3204 **/ 3205 BOOLEAN 3206 CVfrStringDB::GetBestLanguage ( 3207 IN CONST CHAR8 *SupportedLanguages, 3208 IN CHAR8 *Language 3209 ) 3210 { 3211 UINTN CompareLength; 3212 UINTN LanguageLength; 3213 CONST CHAR8 *Supported; 3214 3215 if (SupportedLanguages == NULL || Language == NULL){ 3216 return FALSE; 3217 } 3218 3219 // 3220 // Determine the length of the first RFC 4646 language code in Language 3221 // 3222 for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++); 3223 3224 // 3225 // Trim back the length of Language used until it is empty 3226 // 3227 while (LanguageLength > 0) { 3228 // 3229 // Loop through all language codes in SupportedLanguages 3230 // 3231 for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) { 3232 // 3233 // Skip ';' characters in Supported 3234 // 3235 for (; *Supported != '\0' && *Supported == ';'; Supported++); 3236 // 3237 // Determine the length of the next language code in Supported 3238 // 3239 for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++); 3240 // 3241 // If Language is longer than the Supported, then skip to the next language 3242 // 3243 if (LanguageLength > CompareLength) { 3244 continue; 3245 } 3246 3247 // 3248 // See if the first LanguageLength characters in Supported match Language 3249 // 3250 if (strncmp (Supported, Language, LanguageLength) == 0) { 3251 return TRUE; 3252 } 3253 } 3254 3255 // 3256 // Trim Language from the right to the next '-' character 3257 // 3258 for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--); 3259 } 3260 3261 // 3262 // No matches were found 3263 // 3264 return FALSE; 3265 } 3266 3267 3268 CHAR8 * 3269 CVfrStringDB::GetVarStoreNameFormStringId ( 3270 IN EFI_STRING_ID StringId 3271 ) 3272 { 3273 FILE *pInFile = NULL; 3274 UINT32 NameOffset; 3275 UINT32 Length; 3276 UINT8 *StringPtr; 3277 CHAR8 *StringName; 3278 CHAR16 *UnicodeString; 3279 CHAR8 *VarStoreName = NULL; 3280 CHAR8 *DestTmp; 3281 UINT8 *Current; 3282 EFI_STATUS Status; 3283 CHAR8 LineBuf[EFI_IFR_MAX_LENGTH]; 3284 UINT8 BlockType; 3285 EFI_HII_STRING_PACKAGE_HDR *PkgHeader; 3286 3287 if (mStringFileName == '\0' ) { 3288 return NULL; 3289 } 3290 3291 if ((pInFile = fopen (LongFilePath (mStringFileName), "rb")) == NULL) { 3292 return NULL; 3293 } 3294 3295 // 3296 // Get file length. 3297 // 3298 fseek (pInFile, 0, SEEK_END); 3299 Length = ftell (pInFile); 3300 fseek (pInFile, 0, SEEK_SET); 3301 3302 // 3303 // Get file data. 3304 // 3305 StringPtr = new UINT8[Length]; 3306 if (StringPtr == NULL) { 3307 fclose (pInFile); 3308 return NULL; 3309 } 3310 fread ((char *)StringPtr, sizeof (UINT8), Length, pInFile); 3311 fclose (pInFile); 3312 3313 PkgHeader = (EFI_HII_STRING_PACKAGE_HDR *) StringPtr; 3314 // 3315 // Check the String package. 3316 // 3317 if (PkgHeader->Header.Type != EFI_HII_PACKAGE_STRINGS) { 3318 delete StringPtr; 3319 return NULL; 3320 } 3321 3322 // 3323 // Search the language, get best language base on RFC 4647 matching algorithm. 3324 // 3325 Current = StringPtr; 3326 while (!GetBestLanguage ("en", PkgHeader->Language)) { 3327 Current += PkgHeader->Header.Length; 3328 PkgHeader = (EFI_HII_STRING_PACKAGE_HDR *) Current; 3329 // 3330 // If can't find string package base on language, just return the first string package. 3331 // 3332 if (Current - StringPtr >= Length) { 3333 Current = StringPtr; 3334 PkgHeader = (EFI_HII_STRING_PACKAGE_HDR *) StringPtr; 3335 break; 3336 } 3337 } 3338 3339 Current += PkgHeader->HdrSize; 3340 // 3341 // Find the string block according the stringId. 3342 // 3343 Status = FindStringBlock(Current, StringId, &NameOffset, &BlockType); 3344 if (Status != EFI_SUCCESS) { 3345 delete StringPtr; 3346 return NULL; 3347 } 3348 3349 // 3350 // Get varstore name according the string type. 3351 // 3352 switch (BlockType) { 3353 case EFI_HII_SIBT_STRING_SCSU: 3354 case EFI_HII_SIBT_STRING_SCSU_FONT: 3355 case EFI_HII_SIBT_STRINGS_SCSU: 3356 case EFI_HII_SIBT_STRINGS_SCSU_FONT: 3357 StringName = (CHAR8*)(Current + NameOffset); 3358 VarStoreName = new CHAR8[strlen(StringName) + 1]; 3359 strcpy (VarStoreName, StringName); 3360 break; 3361 case EFI_HII_SIBT_STRING_UCS2: 3362 case EFI_HII_SIBT_STRING_UCS2_FONT: 3363 case EFI_HII_SIBT_STRINGS_UCS2: 3364 case EFI_HII_SIBT_STRINGS_UCS2_FONT: 3365 UnicodeString = (CHAR16*)(Current + NameOffset); 3366 Length = GetUnicodeStringTextSize ((UINT8*)UnicodeString) ; 3367 DestTmp = new CHAR8[Length / 2 + 1]; 3368 VarStoreName = DestTmp; 3369 while (*UnicodeString != '\0') { 3370 *(DestTmp++) = (CHAR8) *(UnicodeString++); 3371 } 3372 *DestTmp = '\0'; 3373 break; 3374 default: 3375 break; 3376 } 3377 3378 delete StringPtr; 3379 3380 return VarStoreName; 3381 } 3382 3383 EFI_STATUS 3384 CVfrStringDB::FindStringBlock ( 3385 IN UINT8 *StringData, 3386 IN EFI_STRING_ID StringId, 3387 OUT UINT32 *StringTextOffset, 3388 OUT UINT8 *BlockType 3389 ) 3390 { 3391 UINT8 *BlockHdr; 3392 EFI_STRING_ID CurrentStringId; 3393 UINT32 BlockSize; 3394 UINT32 Index; 3395 UINT8 *StringTextPtr; 3396 UINT32 Offset; 3397 UINT16 StringCount; 3398 UINT16 SkipCount; 3399 UINT8 Length8; 3400 EFI_HII_SIBT_EXT2_BLOCK Ext2; 3401 UINT32 Length32; 3402 UINT32 StringSize; 3403 3404 CurrentStringId = 1; 3405 3406 // 3407 // Parse the string blocks to get the string text and font. 3408 // 3409 BlockHdr = StringData; 3410 BlockSize = 0; 3411 Offset = 0; 3412 while (*BlockHdr != EFI_HII_SIBT_END) { 3413 switch (*BlockHdr) { 3414 case EFI_HII_SIBT_STRING_SCSU: 3415 Offset = sizeof (EFI_HII_STRING_BLOCK); 3416 StringTextPtr = BlockHdr + Offset; 3417 BlockSize += Offset + strlen ((CHAR8 *) StringTextPtr) + 1; 3418 CurrentStringId++; 3419 break; 3420 3421 case EFI_HII_SIBT_STRING_SCSU_FONT: 3422 Offset = sizeof (EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK) - sizeof (UINT8); 3423 StringTextPtr = BlockHdr + Offset; 3424 BlockSize += Offset + strlen ((CHAR8 *) StringTextPtr) + 1; 3425 CurrentStringId++; 3426 break; 3427 3428 case EFI_HII_SIBT_STRINGS_SCSU: 3429 memcpy (&StringCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16)); 3430 StringTextPtr = BlockHdr + sizeof (EFI_HII_SIBT_STRINGS_SCSU_BLOCK) - sizeof (UINT8); 3431 BlockSize += StringTextPtr - BlockHdr; 3432 3433 for (Index = 0; Index < StringCount; Index++) { 3434 BlockSize += strlen ((CHAR8 *) StringTextPtr) + 1; 3435 if (CurrentStringId == StringId) { 3436 *BlockType = *BlockHdr; 3437 *StringTextOffset = StringTextPtr - StringData; 3438 return EFI_SUCCESS; 3439 } 3440 StringTextPtr = StringTextPtr + strlen ((CHAR8 *) StringTextPtr) + 1; 3441 CurrentStringId++; 3442 } 3443 break; 3444 3445 case EFI_HII_SIBT_STRINGS_SCSU_FONT: 3446 memcpy ( 3447 &StringCount, 3448 BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8), 3449 sizeof (UINT16) 3450 ); 3451 StringTextPtr = BlockHdr + sizeof (EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK) - sizeof (UINT8); 3452 BlockSize += StringTextPtr - BlockHdr; 3453 3454 for (Index = 0; Index < StringCount; Index++) { 3455 BlockSize += strlen ((CHAR8 *) StringTextPtr) + 1; 3456 if (CurrentStringId == StringId) { 3457 *BlockType = *BlockHdr; 3458 *StringTextOffset = StringTextPtr - StringData; 3459 return EFI_SUCCESS; 3460 } 3461 StringTextPtr = StringTextPtr + strlen ((CHAR8 *) StringTextPtr) + 1; 3462 CurrentStringId++; 3463 } 3464 break; 3465 3466 case EFI_HII_SIBT_STRING_UCS2: 3467 Offset = sizeof (EFI_HII_STRING_BLOCK); 3468 StringTextPtr = BlockHdr + Offset; 3469 // 3470 // Use StringSize to store the size of the specified string, including the NULL 3471 // terminator. 3472 // 3473 StringSize = GetUnicodeStringTextSize (StringTextPtr); 3474 BlockSize += Offset + StringSize; 3475 CurrentStringId++; 3476 break; 3477 3478 case EFI_HII_SIBT_STRING_UCS2_FONT: 3479 Offset = sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK) - sizeof (CHAR16); 3480 StringTextPtr = BlockHdr + Offset; 3481 // 3482 // Use StrSize to store the size of the specified string, including the NULL 3483 // terminator. 3484 // 3485 StringSize = GetUnicodeStringTextSize (StringTextPtr); 3486 BlockSize += Offset + StringSize; 3487 CurrentStringId++; 3488 break; 3489 3490 case EFI_HII_SIBT_STRINGS_UCS2: 3491 Offset = sizeof (EFI_HII_SIBT_STRINGS_UCS2_BLOCK) - sizeof (CHAR16); 3492 StringTextPtr = BlockHdr + Offset; 3493 BlockSize += Offset; 3494 memcpy (&StringCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16)); 3495 for (Index = 0; Index < StringCount; Index++) { 3496 StringSize = GetUnicodeStringTextSize (StringTextPtr); 3497 BlockSize += StringSize; 3498 if (CurrentStringId == StringId) { 3499 *BlockType = *BlockHdr; 3500 *StringTextOffset = StringTextPtr - StringData; 3501 return EFI_SUCCESS; 3502 } 3503 StringTextPtr = StringTextPtr + StringSize; 3504 CurrentStringId++; 3505 } 3506 break; 3507 3508 case EFI_HII_SIBT_STRINGS_UCS2_FONT: 3509 Offset = sizeof (EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK) - sizeof (CHAR16); 3510 StringTextPtr = BlockHdr + Offset; 3511 BlockSize += Offset; 3512 memcpy ( 3513 &StringCount, 3514 BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8), 3515 sizeof (UINT16) 3516 ); 3517 for (Index = 0; Index < StringCount; Index++) { 3518 StringSize = GetUnicodeStringTextSize (StringTextPtr); 3519 BlockSize += StringSize; 3520 if (CurrentStringId == StringId) { 3521 *BlockType = *BlockHdr; 3522 *StringTextOffset = StringTextPtr - StringData; 3523 return EFI_SUCCESS; 3524 } 3525 StringTextPtr = StringTextPtr + StringSize; 3526 CurrentStringId++; 3527 } 3528 break; 3529 3530 case EFI_HII_SIBT_DUPLICATE: 3531 if (CurrentStringId == StringId) { 3532 // 3533 // Incoming StringId is an id of a duplicate string block. 3534 // Update the StringId to be the previous string block. 3535 // Go back to the header of string block to search. 3536 // 3537 memcpy ( 3538 &StringId, 3539 BlockHdr + sizeof (EFI_HII_STRING_BLOCK), 3540 sizeof (EFI_STRING_ID) 3541 ); 3542 CurrentStringId = 1; 3543 BlockSize = 0; 3544 } else { 3545 BlockSize += sizeof (EFI_HII_SIBT_DUPLICATE_BLOCK); 3546 CurrentStringId++; 3547 } 3548 break; 3549 3550 case EFI_HII_SIBT_SKIP1: 3551 SkipCount = (UINT16) (*(BlockHdr + sizeof (EFI_HII_STRING_BLOCK))); 3552 CurrentStringId = (UINT16) (CurrentStringId + SkipCount); 3553 BlockSize += sizeof (EFI_HII_SIBT_SKIP1_BLOCK); 3554 break; 3555 3556 case EFI_HII_SIBT_SKIP2: 3557 memcpy (&SkipCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16)); 3558 CurrentStringId = (UINT16) (CurrentStringId + SkipCount); 3559 BlockSize += sizeof (EFI_HII_SIBT_SKIP2_BLOCK); 3560 break; 3561 3562 case EFI_HII_SIBT_EXT1: 3563 memcpy ( 3564 &Length8, 3565 BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8), 3566 sizeof (UINT8) 3567 ); 3568 BlockSize += Length8; 3569 break; 3570 3571 case EFI_HII_SIBT_EXT2: 3572 memcpy (&Ext2, BlockHdr, sizeof (EFI_HII_SIBT_EXT2_BLOCK)); 3573 BlockSize += Ext2.Length; 3574 break; 3575 3576 case EFI_HII_SIBT_EXT4: 3577 memcpy ( 3578 &Length32, 3579 BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8), 3580 sizeof (UINT32) 3581 ); 3582 3583 BlockSize += Length32; 3584 break; 3585 3586 default: 3587 break; 3588 } 3589 3590 if (StringId > 0 && StringId != (EFI_STRING_ID)(-1)) { 3591 *StringTextOffset = BlockHdr - StringData + Offset; 3592 *BlockType = *BlockHdr; 3593 3594 if (StringId == CurrentStringId - 1) { 3595 // 3596 // if only one skip item, return EFI_NOT_FOUND. 3597 // 3598 if(*BlockType == EFI_HII_SIBT_SKIP2 || *BlockType == EFI_HII_SIBT_SKIP1) { 3599 return EFI_NOT_FOUND; 3600 } else { 3601 return EFI_SUCCESS; 3602 } 3603 } 3604 3605 if (StringId < CurrentStringId - 1) { 3606 return EFI_NOT_FOUND; 3607 } 3608 } 3609 BlockHdr = StringData + BlockSize; 3610 } 3611 3612 return EFI_NOT_FOUND; 3613 } 3614 3615 UINT32 3616 CVfrStringDB::GetUnicodeStringTextSize ( 3617 IN UINT8 *StringSrc 3618 ) 3619 { 3620 UINT32 StringSize; 3621 CHAR16 *StringPtr; 3622 3623 StringSize = sizeof (CHAR16); 3624 StringPtr = (UINT16*)StringSrc; 3625 while (*StringPtr++ != L'\0') { 3626 StringSize += sizeof (CHAR16); 3627 } 3628 3629 return StringSize; 3630 } 3631 3632 BOOLEAN VfrCompatibleMode = FALSE; 3633 3634 CVfrVarDataTypeDB gCVfrVarDataTypeDB; 3635 3636 3637
