EFI_STATUS EFIAPI StslRecordAssertion ( IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *This, IN EFI_TEST_ASSERTION Type, IN EFI_GUID EventId, IN CHAR16 *Description, IN CHAR16 *Detail, ... ) /*++ Routine Description: Records the test result. Arguments: This - Standard test library protocol instance. Type - Test result. EventId - GUID for the checkpoint. Description - Simple description for the checkpoint. Detail - Format string for the detail test information. Returns: EFI_SUCCESS - record the assertion successfully. EFI_BAD_BUFFER_SIZE - the Description string is too long. EFI_INVALID_PARAMETER - invalid Type. --*/ { EFI_STATUS Status; VA_LIST Marker; CHAR16 Buffer[EFI_MAX_PRINT_BUFFER]; CHAR16 AssertionType[10]; STANDARD_TEST_PRIVATE_DATA *Private; Private = STANDARD_TEST_PRIVATE_DATA_FROM_STSL (This); // // Check the parameter // if (EfiStrLen (Description) + 14 > EFI_MAX_PRINT_BUFFER) { return EFI_BAD_BUFFER_SIZE; } // // Write log file detail data // switch (Type) { case EFI_TEST_ASSERTION_PASSED: EfiStrCpy (AssertionType, L"PASS"); Private->PassCount ++; break; case EFI_TEST_ASSERTION_WARNING: EfiStrCpy (AssertionType, L"WARNING"); Private->WarningCount ++; break; case EFI_TEST_ASSERTION_FAILED: EfiStrCpy (AssertionType, L"FAILURE"); Private->FailCount ++; break; default: return EFI_INVALID_PARAMETER; break; } SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s -- %s\n", Description, AssertionType); Status = StslWriteLogFile (Private, Buffer); if (EFI_ERROR (Status)) { return Status; } SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%g\n", &EventId); Status = StslWriteLogFile (Private, Buffer); if (EFI_ERROR (Status)) { return Status; } VA_START(Marker, Detail); VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Detail, Marker); VA_END (Marker); if ( EfiStrLen (Buffer) + 5 < EFI_MAX_PRINT_BUFFER ) { EfiStrCat (Buffer, L"\r\n\r\n"); } Status = StslWriteLogFile (Private, Buffer); if (EFI_ERROR (Status)) { return Status; } // // write key file detail line // SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%g:%s|%s:", &EventId, AssertionType, Description); Status = StslWriteKeyFile (Private, Buffer); if (EFI_ERROR (Status)) { return Status; } VA_START(Marker, Detail); VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Detail, Marker); VA_END (Marker); if ( EfiStrLen (Buffer) + 3 < EFI_MAX_PRINT_BUFFER ) { EfiStrCat (Buffer, L"\r\n"); } Status = StslWriteKeyFile (Private, Buffer); if (EFI_ERROR (Status)) { return Status; } return Status; }
EFI_STATUS EFIAPI StslBeginLogging ( IN EFI_STANDARD_TSL_PRIVATE_INTERFACE *This ) /*++ Routine Description: One private interface function of the StandardTestLibrary to begin logging. Arguments: This - the private interface instance structure. Returns: EFI_SUCCESS - begin logging successfully. --*/ { EFI_STATUS Status; STANDARD_TEST_PRIVATE_DATA *Private; CHAR16 Buffer[EFI_MAX_PRINT_BUFFER]; EFI_TEST_OUTPUT_LIBRARY_PROTOCOL *Output; EFI_LIB_CONFIG_FILE_HANDLE *FileConf; EFI_GUID *Guid; EFI_TIME *CurrentTime; Private = STANDARD_TEST_PRIVATE_DATA_FROM_PI (This); Output = Private->OutputProtocol; StslCloseAllFiles (Private); // // Open log and key files // // // Open system log file // FileConf = &Private->SystemLogFile; Status = Output->Open ( Output, FileConf->DevicePath, FileConf->FileName, FileConf->OverwriteFile, &FileConf->FileHandle ); if (EFI_ERROR (Status)) { StslCloseAllFiles (Private); return Status; } // // Open system key file // FileConf = &Private->SystemKeyFile; Status = Output->Open ( Output, FileConf->DevicePath, FileConf->FileName, FileConf->OverwriteFile, &FileConf->FileHandle ); if (EFI_ERROR (Status)) { StslCloseAllFiles (Private); return Status; } // // Open case log file // FileConf = &Private->CaseLogFile; Status = Output->Open ( Output, FileConf->DevicePath, FileConf->FileName, FileConf->OverwriteFile, &FileConf->FileHandle ); if (EFI_ERROR (Status)) { StslCloseAllFiles (Private); return Status; } // // Open case key file // FileConf = &Private->CaseKeyFile; Status = Output->Open ( Output, FileConf->DevicePath, FileConf->FileName, FileConf->OverwriteFile, &FileConf->FileHandle ); if (EFI_ERROR (Status)) { StslCloseAllFiles (Private); return Status; } // // Write log file header data // if (Private->IsRecovery) { // // ---------------------------------- // StslWriteLogFile (Private, DashLine); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" *********RECOVERY*********\n"); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); CurrentTime = &Private->StartTime; gRT->GetTime (CurrentTime, NULL); } else { // // ---------------------------------- // StslWriteLogFile (Private, DashLine); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->EntryName); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Revision 0x%08x\n", Private->TestRevision); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Entry Point GUID: %g\n", &Private->EntryId); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Support Library GUIDs: \n"); StslWriteLogFile (Private, Buffer); Guid = Private->SupportProtocols; while (EfiCompareMem (Guid, &gEfiNullGuid, sizeof(EFI_GUID) ) != 0) { SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" %g\n", Guid); StslWriteLogFile (Private, Buffer); Guid ++; } // // ---------------------------------- // StslWriteLogFile (Private, DashLine); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->BiosId); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Configuration #%d\n", Private->ConfigurationNumber); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->EntryDescription); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); StslWriteLogFileName (Private); CurrentTime = &Private->StartTime; gRT->GetTime (CurrentTime, NULL); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Started: %t\n", CurrentTime); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); // // Write key file header line // SPrint ( Buffer, EFI_MAX_PRINT_BUFFER, L"|HEAD|||%d|%s|%02d-%02d-%04d|%02d:%02d:%02d|%g|0x%08lx|%s|%s|%s|%s\n", Private->ConfigurationNumber, Private->ScenarioString, CurrentTime->Day, CurrentTime->Month, CurrentTime->Year, CurrentTime->Hour, CurrentTime->Minute, CurrentTime->Second, &Private->EntryId, Private->TestRevision, Private->EntryName, Private->TestName, Private->TestCategory, Private->DevicePath ); StslWriteKeyFile (Private, Buffer); } // // Initial private data // Private->BeginLogging = TRUE; return EFI_SUCCESS; }
EFI_STATUS EFIAPI StslEndLogging ( IN EFI_STANDARD_TSL_PRIVATE_INTERFACE *This, IN EFI_STATUS TestStatus ) /*++ Routine Description: One private interface function of the StandardTestLibrary to end logging. Arguments: This - the private interface instance structure. Returns: EFI_SUCCESS - end logging successfully. --*/ { STANDARD_TEST_PRIVATE_DATA *Private; CHAR16 Buffer[EFI_MAX_PRINT_BUFFER]; EFI_TIME CurrentTime; UINT32 SecondsElapsed; UINT32 DaysElapsed; UINT32 HoursElapsed; UINT32 MunitesElapsed; Private = STANDARD_TEST_PRIVATE_DATA_FROM_PI (This); // // Write log file terminator data // SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"\nReturned Status Code: %r\n", TestStatus); StslWriteLogFile (Private, Buffer); if ((Private->PassCount > 0 ) && (Private->WarningCount == 0) && (Private->FailCount == 0)) { SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"\n%s: [PASSED]\n", Private->EntryName); } else if ((Private->PassCount > 0 ) && (Private->WarningCount > 0 ) && (Private->FailCount == 0)) { SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"\n%s: [PASSED WITH WARNINGS]\n", Private->EntryName); } else if ((Private->PassCount >= 0) && (Private->WarningCount >= 0) && (Private->FailCount > 0 )) { SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"\n%s: [FAILED]\n", Private->EntryName); } else { SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"\n%s: [NOT SUPPORTED]\n", Private->EntryName); } StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" Passes........... %d\n", Private->PassCount); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" Warnings......... %d\n", Private->WarningCount); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" Errors........... %d\n", Private->FailCount); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->BiosId); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Revision 0x%08x\n", Private->TestRevision); StslWriteLogFile (Private, Buffer); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Entry Point GUID: %g\n", &Private->EntryId); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); StslWriteLogFileName (Private); gRT->GetTime (&CurrentTime, NULL); SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Finished: %t\n", &CurrentTime); StslWriteLogFile (Private, Buffer); SecondsElapsed = SecondsElapsedFromBaseYear ( Private->StartTime.Year, CurrentTime.Year, CurrentTime.Month, CurrentTime.Day, CurrentTime.Hour, CurrentTime.Minute, CurrentTime.Second ) - SecondsElapsedFromBaseYear ( Private->StartTime.Year, Private->StartTime.Year, Private->StartTime.Month, Private->StartTime.Day, Private->StartTime.Hour, Private->StartTime.Minute, Private->StartTime.Second ); DaysElapsed = SecondsElapsed / SECS_PER_DAY; SecondsElapsed -= DaysElapsed * SECS_PER_DAY; HoursElapsed = SecondsElapsed / SECS_PER_HOUR; SecondsElapsed -= HoursElapsed * SECS_PER_HOUR; MunitesElapsed = SecondsElapsed / SECS_PER_MIN; SecondsElapsed -= MunitesElapsed * SECS_PER_MIN; SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Elapsed Time: %d Days %02d:%02d:%02d\n", DaysElapsed, HoursElapsed, MunitesElapsed, SecondsElapsed); StslWriteLogFile (Private, Buffer); // // ---------------------------------- // StslWriteLogFile (Private, DashLine); // // Write key file terminator line // SPrint ( Buffer, EFI_MAX_PRINT_BUFFER, L"|TERM|%04x|%02d-%02d-%04d|%02d:%02d:%02d|%d %02d:%02d:%02d\n", (UINT16)(TestStatus & 0xFFFF), CurrentTime.Day, CurrentTime.Month, CurrentTime.Year, CurrentTime.Hour, CurrentTime.Minute, CurrentTime.Second, DaysElapsed, HoursElapsed, MunitesElapsed, SecondsElapsed ); StslWriteKeyFile (Private, Buffer); // // Close log and key files // StslCloseAllFiles (Private); Private->BeginLogging = FALSE; return EFI_SUCCESS; }
EFI_STATUS IfrToString ( IN FORM_BROWSER_FORMSET *FormSet, IN UINT8 Format, OUT EFI_HII_VALUE *Result ) /*++ Routine Description: Evaluate opcode EFI_IFR_TO_STRING. Arguments: FormSet - Formset which contains this opcode. Format - String format in EFI_IFR_TO_STRING. Result - Evaluation result for this opcode. Returns: EFI_SUCCESS - Opcode evaluation success. Other - Opcode evaluation failed. --*/ { EFI_STATUS Status; EFI_HII_VALUE Value; CHAR16 *String; CHAR16 *PrintFormat; CHAR16 Buffer[CHARACTER_NUMBER_FOR_VALUE]; UINTN BufferSize; Status = PopExpression (&Value); if (EFI_ERROR (Status)) { return Status; } switch (Value.Type) { case EFI_IFR_TYPE_NUM_SIZE_8: case EFI_IFR_TYPE_NUM_SIZE_16: case EFI_IFR_TYPE_NUM_SIZE_32: case EFI_IFR_TYPE_NUM_SIZE_64: BufferSize = CHARACTER_NUMBER_FOR_VALUE * sizeof (CHAR16); switch (Format) { case EFI_IFR_STRING_UNSIGNED_DEC: case EFI_IFR_STRING_SIGNED_DEC: PrintFormat = L"%ld"; break; case EFI_IFR_STRING_LOWERCASE_HEX: PrintFormat = L"%lx"; break; case EFI_IFR_STRING_UPPERCASE_HEX: PrintFormat = L"%lX"; break; default: return EFI_UNSUPPORTED; } SPrint (Buffer, BufferSize, PrintFormat, Value.Value.u64); String = Buffer; break; case EFI_IFR_TYPE_STRING: EfiCopyMem (Result, &Value, sizeof (EFI_HII_VALUE)); return EFI_SUCCESS; case EFI_IFR_TYPE_BOOLEAN: String = (Value.Value.b) ? L"True" : L"False"; break; default: return EFI_UNSUPPORTED; } Result->Type = EFI_IFR_TYPE_STRING; Result->Value.string = NewString (String, FormSet->HiiHandle); return EFI_SUCCESS; }
void parse_db(UINT8 *data, UINTN len, EFI_HANDLE image, CHAR16 *name, int save_file) { EFI_SIGNATURE_LIST *CertList = (EFI_SIGNATURE_LIST *)data; EFI_SIGNATURE_DATA *Cert; UINTN count = 0, DataSize = len; EFI_FILE *file; CHAR16 *buf = AllocatePool(StrSize(name) + 4 + 2 + 4 + 8 +100); CHAR16 *ext; EFI_STATUS status; int size; certlist_for_each_certentry(CertList, data, size, DataSize) { int Index = 0; count++; if (CompareGuid(&CertList->SignatureType, &X509_GUID) == 0) { ext = L"X509"; } else if (CompareGuid(&CertList->SignatureType, &RSA2048_GUID) == 0) { ext = L"RSA2048"; } else if (CompareGuid(&CertList->SignatureType, &PKCS7_GUID) == 0) { ext = L"PKCS7"; } else if (CompareGuid(&CertList->SignatureType, &EFI_CERT_SHA256_GUID) == 0) { ext = L"SHA256"; } else { ext = L"Unknown"; } Print(L"%s: List %d, type %s\n", name, count, ext); certentry_for_each_cert(Cert, CertList) { Print(L" Signature %d, size %d, owner %g\n", Index++, CertList->SignatureSize, &Cert->SignatureOwner); if (StrCmp(ext, L"X509") == 0) { CHAR16 buf1[4096]; x509_to_str(Cert->SignatureData, CertList->SignatureSize, X509_OBJ_SUBJECT, buf1, sizeof(buf1)); Print(L" Subject: %s\n", buf1); x509_to_str(Cert->SignatureData, CertList->SignatureSize, X509_OBJ_ISSUER, buf1, sizeof(buf1)); Print(L" Issuer: %s\n", buf1); } else if (StrCmp(ext, L"SHA256") == 0) { CHAR16 buf1[256]; StrCpy(buf1, L"Hash: "); sha256_StrCat_hash(buf1, Cert->SignatureData); Print(L" %s\n", buf1); } if (save_file) { SPrint(buf, 0, L"%s-%d-%d-%s-%g", name, count, Index, ext, &Cert->SignatureOwner); Print(L"Writing to file %s\n", buf); status = simple_file_open(image, buf, &file, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE); if (status != EFI_SUCCESS) { Print(L"Failed to open file %s: %d\n", buf, status); continue; } status = simple_file_write_all(file, CertList->SignatureSize-sizeof(EFI_GUID), Cert->SignatureData); simple_file_close(file); if (status != EFI_SUCCESS) { Print(L"Failed to write signature to file %s: %d\n", buf, status); continue; } } }
VOID UpdateSetLegacyDeviceOrderPage ( IN UINT16 UpdatePageId, IN BMM_CALLBACK_DATA *CallbackData ) { BM_LEGACY_DEV_ORDER_CONTEXT *DevOrder; BM_MENU_OPTION *OptionMenu; BM_MENU_ENTRY *NewMenuEntry; IFR_OPTION *IfrOptionList; EFI_STRING_ID StrRef; EFI_STRING_ID StrRefHelp; BBS_TYPE BbsType; UINTN VarSize; UINTN Pos; UINTN Bit; UINT16 Index; UINT16 Key; CHAR16 String[100]; CHAR16 *TypeStr; CHAR16 *TypeStrHelp; UINT16 VarDevOrder; UINT8 *VarData; UINT8 *OriginalPtr; UINT8 *LegacyOrder; UINT8 *OldData; UINT8 *DisMap; OptionMenu = NULL; Key = 0; StrRef = 0; StrRefHelp = 0; TypeStr = NULL; TypeStrHelp = NULL; BbsType = BBS_FLOPPY; LegacyOrder = NULL; OldData = NULL; DisMap = NULL; CallbackData->BmmAskSaveOrNot = TRUE; UpdatePageStart (CallbackData); DisMap = CallbackData->BmmOldFakeNVData.DisableMap; EfiSetMem (DisMap, 32, 0); // // Create oneof option list // switch (UpdatePageId) { case FORM_SET_FD_ORDER_ID: OptionMenu = (BM_MENU_OPTION *) &LegacyFDMenu; Key = LEGACY_FD_QUESTION_ID; TypeStr = StrFloppy; TypeStrHelp = StrFloppyHelp; BbsType = BBS_FLOPPY; LegacyOrder = CallbackData->BmmFakeNvData.LegacyFD; OldData = CallbackData->BmmOldFakeNVData.LegacyFD; break; case FORM_SET_HD_ORDER_ID: OptionMenu = (BM_MENU_OPTION *) &LegacyHDMenu; Key = LEGACY_HD_QUESTION_ID; TypeStr = StrHardDisk; TypeStrHelp = StrHardDiskHelp; BbsType = BBS_HARDDISK; LegacyOrder = CallbackData->BmmFakeNvData.LegacyHD; OldData = CallbackData->BmmOldFakeNVData.LegacyHD; break; case FORM_SET_CD_ORDER_ID: OptionMenu = (BM_MENU_OPTION *) &LegacyCDMenu; Key = LEGACY_CD_QUESTION_ID; TypeStr = StrCDROM; TypeStrHelp = StrCDROMHelp; BbsType = BBS_CDROM; LegacyOrder = CallbackData->BmmFakeNvData.LegacyCD; OldData = CallbackData->BmmOldFakeNVData.LegacyCD; break; case FORM_SET_NET_ORDER_ID: OptionMenu = (BM_MENU_OPTION *) &LegacyNETMenu; Key = LEGACY_NET_QUESTION_ID; TypeStr = StrNET; TypeStrHelp = StrNETHelp; BbsType = BBS_EMBED_NETWORK; LegacyOrder = CallbackData->BmmFakeNvData.LegacyNET; OldData = CallbackData->BmmOldFakeNVData.LegacyNET; break; case FORM_SET_BEV_ORDER_ID: OptionMenu = (BM_MENU_OPTION *) &LegacyBEVMenu; Key = LEGACY_BEV_QUESTION_ID; TypeStr = StrBEV; TypeStrHelp = StrBEVHelp; BbsType = BBS_BEV_DEVICE; LegacyOrder = CallbackData->BmmFakeNvData.LegacyBEV; OldData = CallbackData->BmmOldFakeNVData.LegacyBEV; break; } CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu); IfrOptionList = EfiAllocateZeroPool (sizeof (IFR_OPTION) * (OptionMenu->MenuNumber + 1)); if (NULL == IfrOptionList) { return ; } for (Index = 0; Index < OptionMenu->MenuNumber; Index++) { NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index); IfrOptionList[Index].Flags = 0; if (0 == Index) { IfrOptionList[Index].Flags |= EFI_IFR_OPTION_DEFAULT; } IfrOptionList[Index].StringToken = NewMenuEntry->DisplayStringToken; IfrOptionList[Index].Value.u8 = (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index; } // // for item "Disabled" // IfrOptionList[Index].Flags = 0; IfrOptionList[Index].StringToken = STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE); IfrOptionList[Index].Value.u8 = 0xFF; // // Get Device Order from variable // VarData = BdsLibGetVariableAndSize ( VarLegacyDevOrder, &EfiLegacyDevOrderGuid, &VarSize ); if (NULL != VarData) { OriginalPtr = VarData; DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData; while (VarData < VarData + VarSize) { if (DevOrder->BbsType == BbsType) { break; } VarData += sizeof (BBS_TYPE); VarData += *(UINT16 *) VarData; DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData; } // // Create oneof tag here for FD/HD/CD #1 #2 // for (Index = 0; Index < OptionMenu->MenuNumber; Index++) { // // Create the string for oneof tag // SPrint (String, sizeof (String), TypeStr, Index); StrRef = 0; IfrLibNewString (CallbackData->BmmHiiHandle, &StrRef, String); SPrint (String, sizeof (String), TypeStrHelp, Index); StrRefHelp = 0; IfrLibNewString (CallbackData->BmmHiiHandle, &StrRefHelp, String); CreateOneOfOpCode ( Key + Index, VARSTORE_ID_BOOT_MAINT, Key + Index - CONFIG_OPTION_OFFSET, StrRef, StrRefHelp, EFI_IFR_FLAG_CALLBACK, EFI_IFR_NUMERIC_SIZE_1, IfrOptionList, OptionMenu->MenuNumber + 1, &gUpdateData ); VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16)); if (0xFF00 == (VarDevOrder & 0xFF00)) { LegacyOrder[Index] = 0xFF; Pos = (VarDevOrder & 0xFF) / 8; Bit = 7 - ((VarDevOrder & 0xFF) % 8); DisMap[Pos] |= (UINT8) (1 << Bit); } else { LegacyOrder[Index] = (UINT8) (VarDevOrder & 0xFF); } } } EfiCopyMem (OldData, LegacyOrder, 100); if (IfrOptionList != NULL) { SafeFreePool (IfrOptionList); IfrOptionList = NULL; } UpdatePageEnd (CallbackData); }
VOID * GetLegacyBootOptionVar ( IN UINTN DeviceType, OUT UINTN *OptionIndex, OUT UINTN *OptionSize ) { EFI_DEVICE_PATH_PROTOCOL *DevicePath; VOID *OptionBuffer; UINTN OrderSize; UINTN Index; UINT32 Attribute; UINT16 *OrderBuffer; CHAR16 StrTemp[100]; UINT16 FilePathSize; CHAR16 *Description; UINT8 *Ptr; UINT8 *OptionalData; // // Get Boot Option number from the size of BootOrder // OrderBuffer = BdsLibGetVariableAndSize ( L"BootOrder", &gEfiGlobalVariableGuid, &OrderSize ); for (Index = 0; Index < OrderSize / sizeof (UINT16); Index++) { SPrint (StrTemp, 100, L"Boot%04x", OrderBuffer[Index]); OptionBuffer = BdsLibGetVariableAndSize ( StrTemp, &gEfiGlobalVariableGuid, OptionSize ); if (NULL == OptionBuffer) { continue; } Ptr = (UINT8 *) OptionBuffer; Attribute = *(UINT32 *) Ptr; Ptr += sizeof (UINT32); FilePathSize = *(UINT16 *) Ptr; Ptr += sizeof (UINT16); Description = (CHAR16 *) Ptr; Ptr += EfiStrSize ((CHAR16 *) Ptr); // // Now Ptr point to Device Path // DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr; Ptr += FilePathSize; // // Now Ptr point to Optional Data // OptionalData = Ptr; if ((DeviceType == ((BBS_TABLE *) OptionalData)->DeviceType) && (BBS_DEVICE_PATH == DevicePath->Type) && (BBS_BBS_DP == DevicePath->SubType) ) { *OptionIndex = OrderBuffer[Index]; SafeFreePool (OrderBuffer); return OptionBuffer; } else { SafeFreePool (OptionBuffer); } } SafeFreePool (OrderBuffer); return NULL; }