EFI_STATUS
BBTestBlockToConfigFunctionTestCheckpoint1 (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting
)
{
EFI_TEST_ASSERTION AssertionType;
EFI_STATUS Status;
EFI_STRING Req;
EFI_STRING Config = NULL;
EFI_STRING Progress = NULL;
UINT8 Block[6] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
UINTN BlockSize = 6;
Req = L"GUID=970eb94aa0d449f7b980bdaa47d42527&NAME=006a0069006e0039&PATH=000acf&OFFSET=3&WIDTH=1&OFFSET=0&WIDTH=2";
Status = HIIConfigRouting->BlockToConfig(
HIIConfigRouting,
Req,
Block,
BlockSize,
&Config,
&Progress
);
if ( EFI_SUCCESS == Status ) {
if ((Progress != (Req + StrLen(Req))) ||
(NULL == EfiStrStr(Config, L"OFFSET=3&WIDTH=1&VALUE=03")) ||
(NULL == EfiStrStr(Config, L"OFFSET=0&WIDTH=2&VALUE=0100")) ){
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
gtBS->FreePool (Config);
}
} else if ( (EFI_OUT_OF_RESOURCES == Status) && (Progress == Req) ){
AssertionType = EFI_TEST_ASSERTION_WARNING;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gHIIConfigRoutingBBTestFunctionAssertionGuid004,
L"HII_CONFIG_ROUTING_PROTOCOL.BlockToConfig - BlockToConfig() returns EFI_SUCCESS with valid input.",
L"%a:%d: Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
EFI_STATUS
BBTestExtractConfigConformanceTestCheckpoint1 (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
)
{
EFI_STATUS Status;
EFI_TEST_ASSERTION AssertionType;
EFI_STRING Progress = NULL;
EFI_STRING Results = NULL;
EFI_STRING ResultsPtr = NULL;
UINTN Len = 0;
EFI_STRING Pointer = NULL;
UINT8 IfMulti = 0;
EFI_STRING Request = NULL;
//
// Call ExtractConfig with Request been <MultiConfigRequest>
//
Status = HIIConfigAccess->ExtractConfig (
HIIConfigAccess,
NULL,
&Progress,
&Results
);
if ( Status == EFI_SUCCESS ) {
Len = StrLen(Results);
//
// Make sure the size of Request is enough to hold <MultiConfigRequest>
// if original Results is not Multi
//
Request = (EFI_STRING) AllocateZeroPool ( 2 * Len + 2 + 256);
if (Request == NULL) {
FreePool(Results);
return EFI_OUT_OF_RESOURCES;
}
} else {
return Status;
}
Status = MultiAltRespToMultiReq (Results, Request);
ResultsPtr = Request;
FreePool(Results);
Results = NULL;
if ( EfiStrStr(Request, L"GUID=") != NULL ) {
Pointer = EfiStrStr(Request, L"GUID=");
Pointer++;
if ( EfiStrStr(Pointer, L"GUID=") != NULL )
IfMulti = 1;
}
if ( IfMulti == 0 ) {
EfiStrCat( Request, L"&GUID=970eb94aa0d449f7b980bdaa47d42527&NAME=006a0069006e0039&PATH=000acf&grag&star");
}
Status = HIIConfigAccess->ExtractConfig (
HIIConfigAccess,
Request,
&Progress,
&Results
);
if ( (EFI_INVALID_PARAMETER != Status) || (EfiStrnCmp (Progress, L"&GUID=", 6) != 0) ) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gHIIConfigAccessBBTestConformanceAssertionGuid001,
L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig - ExtractConfig() returns EFI_INVALID_PARAMETER with Request been <MultiConfigRequest>.",
L"%a:%d: Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
FreePool(Request);
return EFI_SUCCESS;
}
EFI_STATUS
BBTestExtractConfigFunctionTestCheckpoint1 (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting
)
{
EFI_TEST_ASSERTION AssertionType;
EFI_STATUS Status;
UINTN Len = 0;
EFI_STRING MultiConfigAltResp = NULL;
EFI_STRING Request = NULL;
EFI_STRING Progress = NULL;
EFI_STRING Results = NULL;
Status = HIIConfigRouting->ExportConfig(
HIIConfigRouting,
&MultiConfigAltResp
);
if ( EFI_SUCCESS != Status ) {
return Status;
}
Len = StrLen (MultiConfigAltResp);
Request = (EFI_STRING) AllocateZeroPool (2 * Len + 2);
if (Request == NULL) {
goto FUNC_EXIT;
}
//
// <MultiConfigAltResp> to <MultiConfigRequest>
//
Status = MultiAltRespToMultiReq (MultiConfigAltResp, Request);
if (Status != EFI_SUCCESS) {
goto FUNC_EXIT;
}
Status = HIIConfigRouting->ExtractConfig(
HIIConfigRouting,
Request,
&Progress,
&Results
);
// if ( (EFI_SUCCESS == Status) && (Progress == Request + StrLen (Request)) && (0 == EfiStrCmp(Results, Resp)) ) {
if ( (EFI_SUCCESS == Status) && (Progress == Request + StrLen (Request)) ) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else if ( EFI_OUT_OF_RESOURCES == Status ){
AssertionType = EFI_TEST_ASSERTION_WARNING;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gHIIConfigRoutingBBTestFunctionAssertionGuid001,
L"HII_CONFIG_ROUTING_PROTOCOL.ExtractConfig - ExtractConfig() returns EFI_SUCCESS with no NULL Results.",
L"%a:%d: Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
//
// Since ExtractConfig may not append <AltResp> at string tail.
// We check whether Results is a substring of MultiConfigAltResp from ExportConfig
//
if (Status == EFI_SUCCESS && EfiStrStr(MultiConfigAltResp, Results) != 0) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else if (EFI_OUT_OF_RESOURCES == Status){
AssertionType = EFI_TEST_ASSERTION_WARNING;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gHIIConfigRoutingBBTestFunctionAssertionGuid011,
L"HII_CONFIG_ROUTING_PROTOCOL.ExtractConfig - ExtractConfig() Check if Results is in <MultiConfigAltResp> format.",
L"%a:%d:",
__FILE__,
(UINTN)__LINE__
);
FUNC_EXIT:
if (Request != NULL) {
gtBS->FreePool(Request);
}
if (MultiConfigAltResp != NULL) {
gtBS->FreePool(MultiConfigAltResp);
}
if (Results != NULL) {
gtBS->FreePool(Results);
}
return EFI_SUCCESS;
}
EFI_STATUS
MultiAltRespToMultiResp (
IN EFI_STRING Resp1,
IN OUT EFI_STRING Resp2
)
{
EFI_STRING Pointer1 = Resp1;
EFI_STRING Pointer2 = NULL;
EFI_STRING Pointer3 = Resp2;
EFI_STRING CfgHdr = NULL;
EFI_STRING FreePtr = NULL;
CHAR8 Flag = 0;
if (EfiStrnCmp (Pointer1, L"GUID=", 5) != 0) {
return EFI_INVALID_PARAMETER;
}
Pointer2 = (EFI_STRING) AllocateZeroPool (2 * StrLen(Resp1) + 2);
if (Pointer2 == NULL) {
return EFI_OUT_OF_RESOURCES;
}
FreePtr = Pointer2;
while (*Pointer1) {
if (EfiStrnCmp (Pointer1, L"GUID=", 5) == 0) {
CfgHdr = Pointer2;
*(Pointer2++) = *(Pointer1++);
while (*Pointer1 != L'&') {
*(Pointer2++) = *(Pointer1++);
}
}
if (EfiStrnCmp (Pointer1, L"&GUID=", 6) == 0) {
*(Pointer2++) = *(Pointer1++);
CfgHdr = Pointer2;
while (*Pointer1 != L'&') {
*(Pointer2++) = *(Pointer1++);
}
}
if (EfiStrnCmp (Pointer1, L"&NAME=", 6) == 0) {
*(Pointer2++) = *(Pointer1++);
while (*Pointer1 != L'&') {
*(Pointer2++) = *(Pointer1++);
}
}
if (EfiStrnCmp (Pointer1, L"&PATH=", 6) == 0) {
*(Pointer2++) = *(Pointer1++);
while (*Pointer1 != L'&') {
*(Pointer2++) = *(Pointer1++);
}
if (NULL == EfiStrStr(Resp2, CfgHdr)){
if (*Resp2 == L'G')
*(Pointer3++) = L'&';
EfiStrCat(Resp2, CfgHdr);
Pointer3 += StrLen(CfgHdr);
Flag = 1;
} else {
Flag = 0;
}
}
while ((Flag == 1) && (EfiStrnCmp (Pointer1, L"&GUID=", 6) != 0) && *Pointer1) {
if (EfiStrnCmp (Pointer1, L"&OFFSET=", 8) == 0) {
*(Pointer3++) = *(Pointer1++);
while (*Pointer1 != L'&') {
*(Pointer3++) = *(Pointer1++);
}
}
if (EfiStrnCmp (Pointer1, L"&WIDTH=", 7) == 0) {
*(Pointer3++) = *(Pointer1++);
while (*Pointer1 != L'&') {
*(Pointer3++) = *(Pointer1++);
}
}
if (EfiStrnCmp (Pointer1, L"&VALUE=", 7) == 0) {
*(Pointer3++) = *(Pointer1++);
while (*Pointer1 != L'&' && *Pointer1) {
*(Pointer3++) = *(Pointer1++);
}
}
if (EfiStrnCmp (Pointer1, L"&ALTCFG=", 8) == 0) {
Pointer1 += 8;
while (*Pointer1 != L'&' && *Pointer1) {
Pointer1++;
}
}
if ((*Pointer1 == L'&') && (EfiStrnCmp (Pointer1, L"&GUID=", 6) != 0)) {
*(Pointer3++) = *(Pointer1++);
while (*Pointer1 != L'=') {
*(Pointer3++) = *(Pointer1++);
}
while (*Pointer1 != L'&' && *Pointer1) {
*(Pointer3++) = *(Pointer1++);
}
}
}
Pointer1++;
}
FreePool(FreePtr);
return EFI_SUCCESS;
}
//
// TDS
//
EFI_STATUS
BBTestReceiveDataConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib = NULL;
EFI_STATUS Status;
EFI_STORAGE_SECURITY_COMMAND_PROTOCOL *StorageSecurityCommand = NULL;
EFI_STORAGE_SECURITY_COMMAND_PROTOCOL *StorageSecurityTemp = NULL;
EFI_BLOCK_IO_PROTOCOL *BlockIo = NULL;
EFI_DEVICE_PATH_PROTOCOL *DevicePath = NULL;
EFI_DEVICE_PATH_PROTOCOL *DevPathNode = NULL;
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevicePathToText = NULL;
EFI_STRING DevicePathNodeStr = NULL;
UINTN Index;
UINTN NoHandles;
EFI_HANDLE *HandleBuffer = NULL;
EFI_TEST_ASSERTION AssertionType;
UINT8 *DataBuffer = NULL;
UINTN RcvDataSize;
EFI_HANDLE Handle = NULL;
BOOLEAN IsAtaDevice = FALSE;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
StorageSecurityCommand = (EFI_STORAGE_SECURITY_COMMAND_PROTOCOL *)ClientInterface;
//
// Locate Block IO protocol on same handler to get media info
//
Status = gtBS->LocateHandleBuffer (
ByProtocol,
&gEfiStorageSecurityCommandProtocolGuid,
NULL,
&NoHandles,
&HandleBuffer
);
for (Index = 0; Index < NoHandles; Index++) {
Status = gtBS->HandleProtocol (
HandleBuffer[Index],
&gEfiStorageSecurityCommandProtocolGuid,
&StorageSecurityTemp
);
if (Status == EFI_SUCCESS && StorageSecurityTemp == StorageSecurityCommand) {
Status = gtBS->HandleProtocol (
HandleBuffer[Index],
&gEfiBlockIoProtocolGuid,
&BlockIo
);
Handle = HandleBuffer[Index];
if (Status != EFI_SUCCESS) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"Can not Locate BlockIo Protocol on Current Handler",
L"%a:%d:",
__FILE__,
(UINTN)__LINE__
);
goto EXIT;
}
}
}
//
// both ATA8-ACS & SPC-4 security protocol payload are in 512 incremenet
//
DataBuffer = AllocateZeroPool(512);
if (DataBuffer == NULL) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocateMemory - Allocate Memory Fail",
L"%a:%d:",
__FILE__,
(UINTN)__LINE__
);
goto EXIT;
}
if (BlockIo->Media->MediaPresent) {
//
// EFI_WARN_BUFFER_TOO_SMALL
//
Status = gtBS->HandleProtocol (
Handle,
&gEfiDevicePathProtocolGuid,
&DevicePath
);
if (!EFI_ERROR(Status)) {
Status = gtBS->LocateProtocol (
&gEfiDevicePathToTextProtocolGuid,
NULL,
&DevicePathToText
);
if (!EFI_ERROR(Status)) {
//
// Search for Ata device Node in devicepath
//
DevPathNode = DevicePath;
while (!IsDevicePathEnd(DevPathNode)) {
DevicePathNodeStr = DevicePathToText->ConvertDeviceNodeToText (
DevPathNode,
FALSE,
FALSE
);
if ((DevicePathNodeStr != NULL) && ((EfiStrStr(DevicePathNodeStr, L"Ata(") != NULL) || (EfiStrStr(DevicePathNodeStr, L"Sata(") != NULL))) {
IsAtaDevice = TRUE;
FreePool(DevicePathNodeStr);
DevicePathNodeStr = NULL;
break;
}
FreePool(DevicePathNodeStr);
DevicePathNodeStr = NULL;
DevPathNode = NextDevicePathNode(DevPathNode);
}
}
}
//
// According to TCG definition, when the Security Protocol field is set to 00h, and SP
// Specific is set to 0000h in a TRUSTED RECEIVE command, return security protocol
// information. This Command is not associated with a security send command
//
Status = StorageSecurityCommand->ReceiveData (
StorageSecurityCommand,
BlockIo->Media->MediaId,
100000000, // Timeout 10-sec
0, // SecurityProtocol
0, // SecurityProtocolSpecifcData
10, // PayloadBufferSize,
DataBuffer, // PayloadBuffer
&RcvDataSize
);
//
// for ATA8-ACS SecurityProtocol, 512 byte is a request
//
if (IsAtaDevice) {
if((Status == EFI_DEVICE_ERROR) || (Status == EFI_WARN_BUFFER_TOO_SMALL)){
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
} else {
if((!EFI_ERROR(Status)) || (Status == EFI_WARN_BUFFER_TOO_SMALL)){
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
}
if (IsAtaDevice) {
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gStorageSecurityCommandConformanceTestAssertionGuid001,
L"EFI_STORAGE_SECURITY_COMMAND.ReceiveData - TRUSTED RECEIVE to get Ata device basic information with limited data buffer",
L"%a:%d: Status: %r ExpectedStatus: %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_DEVICE_ERROR
);
} else {
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gStorageSecurityCommandConformanceTestAssertionGuid001,
L"EFI_STORAGE_SECURITY_COMMAND.ReceiveData - TRUSTED RECEIVE to get Non-Ata device basic information with limited data buffer",
L"%a:%d: Status: %r ExpectedStatus: %r or %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_WARN_BUFFER_TOO_SMALL,
EFI_SUCCESS
);
}
//
// EFI_MEDIA_CHANGED
//
Status = StorageSecurityCommand->ReceiveData (
StorageSecurityCommand,
BlockIo->Media->MediaId + 1,
100000000, // Timeout 10-sec
0, // SecurityProtocol
0, // SecurityProtocolSpecifcData
512, // PayloadBufferSize,
DataBuffer, // PayloadBuffer
&RcvDataSize
);
if (Status == EFI_MEDIA_CHANGED) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gStorageSecurityCommandConformanceTestAssertionGuid002,
L"EFI_STORAGE_SECURITY_COMMAND.ReceiveData - TRUSTED RECEIVE to get device basic information with invalid Media ID",
L"%a:%d: Status: %r ExpectedStatus: %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_MEDIA_CHANGED
);
//
// EFI_INVALID_PARAMETER
//
//
// NULL PayloadBuffer
//
Status = StorageSecurityCommand->ReceiveData (
StorageSecurityCommand,
BlockIo->Media->MediaId,
100000000, // Timeout 10-sec
0, // SecurityProtocol
0, // SecurityProtocolSpecifcData
512, // PayloadBufferSize,
NULL, // PayloadBuffer
&RcvDataSize
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gStorageSecurityCommandConformanceTestAssertionGuid003,
L"EFI_STORAGE_SECURITY_COMMAND.ReceiveData - TRUSTED RECEIVE to get device basic information with NULL Payload buffer",
L"%a:%d: Status: %r ExpectedStatus: %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_INVALID_PARAMETER
);
//
// NULL PayloadTransferSize
//
Status = StorageSecurityCommand->ReceiveData (
StorageSecurityCommand,
BlockIo->Media->MediaId,
100000000, // Timeout 10-sec
0, // SecurityProtocol
0, // SecurityProtocolSpecifcData
512, // PayloadBufferSize,
DataBuffer, // PayloadBuffer
NULL
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gStorageSecurityCommandConformanceTestAssertionGuid004,
L"EFI_STORAGE_SECURITY_COMMAND.ReceiveData - TRUSTED RECEIVE to get device basic information with NULL PayloadTransferSize",
L"%a:%d: Status: %r ExpectedStatus: %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_INVALID_PARAMETER
);
} else {
//
// EFI_NO_MEDIA
//
Status = StorageSecurityCommand->ReceiveData (
StorageSecurityCommand,
BlockIo->Media->MediaId,
100000000, // Timeout 10-sec
0, // SecurityProtocol
0, // SecurityProtocolSpecifcData
512, // PayloadBufferSize,
DataBuffer, // PayloadBuffer
&RcvDataSize
);
if (Status == EFI_NO_MEDIA) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gStorageSecurityCommandConformanceTestAssertionGuid005,
L"EFI_STORAGE_SECURITY_COMMAND.ReceiveData - TRUSTED RECEIVE to get device basic information on a non-existing media",
L"%a:%d: Status: %r ExpectedStatus: %r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_NO_MEDIA
);
}
EXIT:
if (HandleBuffer != NULL) {
gtBS->FreePool (HandleBuffer);
}
if (DataBuffer != NULL) {
gtBS->FreePool(DataBuffer);
}
return EFI_SUCCESS;
}
EFI_STATUS
IfrFind (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Format,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_FIND.
Arguments:
FormSet - Formset which contains this opcode.
Format - Case sensitive or insensitive.
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[2];
UINTN Base;
CHAR16 *StringPtr;
UINTN Index;
if (Format > EFI_IFR_FF_CASE_INSENSITIVE) {
return EFI_UNSUPPORTED;
}
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Base = (UINTN) Value.Value.u64;
//
// String[0] - sub-string
// String[1] - The string to search
//
String[0] = NULL;
String[1] = NULL;
for (Index = 0; Index < 2; Index++) {
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
goto Done;
}
if (Value.Type != EFI_IFR_TYPE_STRING) {
Status = EFI_UNSUPPORTED;
goto Done;
}
String[Index] = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String== NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
if (Format == EFI_IFR_FF_CASE_INSENSITIVE) {
//
// Case insensitive, convert both string to upper case
//
IfrStrToUpper (String[Index]);
}
}
Result->Type = EFI_IFR_TYPE_NUM_SIZE_64;
if (Base >= EfiStrLen (String[1])) {
Result->Value.u64 = 0xFFFFFFFFFFFFFFFF;
} else {
StringPtr = EfiStrStr (String[1] + Base, String[0]);
Result->Value.u64 = (StringPtr == NULL) ? 0xFFFFFFFFFFFFFFFF : (StringPtr - String[1]);
}
Done:
EfiLibSafeFreePool (String[0]);
EfiLibSafeFreePool (String[1]);
return Status;
}
EFI_STATUS
IfrToUint (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_TO_UINT.
Arguments:
FormSet - Formset which contains this opcode.
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 *StringPtr;
UINTN BufferSize;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type >= EFI_IFR_TYPE_OTHER) {
return EFI_UNSUPPORTED;
}
Status = EFI_SUCCESS;
if (Value.Type == EFI_IFR_TYPE_STRING) {
String = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String == NULL) {
return EFI_NOT_FOUND;
}
IfrStrToUpper (String);
StringPtr = EfiStrStr (String, L"0X");
if (StringPtr != NULL) {
//
// Hex string
//
BufferSize = sizeof (UINT64);
Status = HexStringToBuf ((UINT8 *) &Result->Value.u64, &BufferSize, StringPtr + 2, NULL);
} else {
//
// BUGBUG: Need handle decimal string
//
}
gBS->FreePool (String);
} else {
EfiCopyMem (Result, &Value, sizeof (EFI_HII_VALUE));
}
Result->Type = EFI_IFR_TYPE_NUM_SIZE_64;
return Status;
}
EFI_STATUS
IfrToken (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_TOKEN.
Arguments:
FormSet - Formset which contains this opcode.
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[2];
UINTN Count;
CHAR16 *Delimiter;
CHAR16 *SubString;
CHAR16 *StringPtr;
UINTN Index;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Count = (UINTN) Value.Value.u64;
//
// String[0] - Delimiter
// String[1] - The string to search
//
String[0] = NULL;
String[1] = NULL;
for (Index = 0; Index < 2; Index++) {
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
goto Done;
}
if (Value.Type != EFI_IFR_TYPE_STRING) {
Status = EFI_UNSUPPORTED;
goto Done;
}
String[Index] = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String== NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
}
Delimiter = String[0];
SubString = String[1];
while (Count > 0) {
SubString = EfiStrStr (SubString, Delimiter);
if (SubString != NULL) {
//
// Skip over the delimiter
//
SubString = SubString + EfiStrLen (Delimiter);
} else {
break;
}
Count--;
}
if (SubString == NULL) {
//
// nth delimited sub-string not found, push an empty string
//
SubString = gEmptyString;
} else {
//
// Put a NULL terminator for nth delimited sub-string
//
StringPtr = EfiStrStr (SubString, Delimiter);
if (StringPtr != NULL) {
*StringPtr = L'\0';
}
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (SubString, FormSet->HiiHandle);
Done:
EfiLibSafeFreePool (String[0]);
EfiLibSafeFreePool (String[1]);
return Status;
}