sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3d06e1898879c46b854338e7e61a6dfc78e60c12
system76-edk2/ShellPkg/Library/UefiShellDebug1CommandsLib/SetVar.c
Dandan Bi 6877b9bd04 ShellPkg/SetVar: Fix typo in comments 
Cc: Ruiyu Ni <ruiyu.ni@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Dandan Bi <dandan.bi@intel.com>
Reviewed-by: Ruiyu Ni <ruiyu.ni@intel.com>
2017-04-07 14:15:47 +08:00

472 lines
15 KiB
C
Raw Blame History

/** @file
Main file for SetVar shell Debug1 function.
(C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "UefiShellDebug1CommandsLib.h"
STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
{L"-guid", TypeValue},
{L"-bs", TypeFlag},
{L"-rt", TypeFlag},
{L"-nv", TypeFlag},
{NULL, TypeMax}
};
typedef enum {
DataTypeHexNumber = 0,
DataTypeHexArray = 1,
DataTypeAscii = 2,
DataTypeUnicode = 3,
DataTypeDevicePath = 4,
DataTypeUnKnow = 5
} DATA_TYPE;
typedef union {
UINT8 HexNumber8;
UINT16 HexNumber16;
UINT32 HexNumber32;
UINT64 HexNumber64;
} HEX_NUMBER;
/**
Check if the input is a (potentially empty) string of hexadecimal nibbles.
@param[in] String The CHAR16 string to check.
@retval FALSE A character has been found in String for which
ShellIsHexaDecimalDigitCharacter() returned FALSE.
@retval TRUE Otherwise. (Note that this covers the case when String is
empty.)
**/
BOOLEAN
IsStringOfHexNibbles (
IN CONST CHAR16 *String
)
{
CONST CHAR16 *Pos;
for (Pos = String; *Pos != L'\0'; ++Pos) {
if (!ShellIsHexaDecimalDigitCharacter (*Pos)) {
return FALSE;
}
}
return TRUE;
}
/**
Function to check the TYPE of Data.
@param[in] Data The Data to be check.
@retval DATA_TYPE The TYPE of Data.
**/
DATA_TYPE
TestDataType (
IN CONST CHAR16 *Data
)
{
if (Data[0] == L'0' && (Data[1] == L'x' || Data[1] == L'X')) {
if (IsStringOfHexNibbles (Data+2) && StrLen (Data + 2) <= 16) {
return DataTypeHexNumber;
} else {
return DataTypeUnKnow;
}
} else if (Data[0] == L'H') {
if (IsStringOfHexNibbles (Data + 1) && StrLen (Data + 1) % 2 == 0) {
return DataTypeHexArray;
} else {
return DataTypeUnKnow;
}
} else if (Data[0] == L'S') {
return DataTypeAscii;
} else if (Data[0] == L'L') {
return DataTypeUnicode;
} else if (Data[0] == L'P' || StrnCmp (Data, L"--", 2) == 0) {
return DataTypeDevicePath;
}
if (IsStringOfHexNibbles (Data) && StrLen (Data) % 2 == 0) {
return DataTypeHexArray;
}
return DataTypeAscii;
}
/**
Function to parse the Data by the type of Data, and save in the Buffer.
@param[in] Data A pointer to a buffer to be parsed.
@param[out] Buffer A pointer to a buffer to hold the return data.
@param[in,out] BufferSize On input, indicates the size of Buffer in bytes.
On output,indicates the size of data return in Buffer.
Or the size in bytes of the buffer needed to obtain.
@retval EFI_INVALID_PARAMETER The Buffer or BufferSize is NULL.
@retval EFI_BUFFER_TOO_SMALL The Buffer is too small to hold the data.
@retval EFI_OUT_OF_RESOURCES A memory allcation failed.
@retval EFI_SUCCESS The Data parsed successful and save in the Buffer.
**/
EFI_STATUS
ParseParameterData (
IN CONST CHAR16 *Data,
OUT VOID *Buffer,
IN OUT UINTN *BufferSize
)
{
UINT64 HexNumber;
UINTN HexNumberLen;
UINTN Size;
CHAR8 *AsciiBuffer;
DATA_TYPE DataType;
EFI_DEVICE_PATH_PROTOCOL *DevPath;
EFI_STATUS Status;
HexNumber = 0;
HexNumberLen = 0;
Size = 0;
AsciiBuffer = NULL;
DevPath = NULL;
Status = EFI_SUCCESS;
if (Data == NULL || BufferSize == NULL) {
return EFI_INVALID_PARAMETER;
}
DataType = TestDataType (Data);
if (DataType == DataTypeHexNumber) {
//
// hex number
//
StrHexToUint64S (Data + 2, NULL, &HexNumber);
HexNumberLen = StrLen (Data + 2);
if (HexNumberLen >= 1 && HexNumberLen <= 2) {
Size = 1;
} else if (HexNumberLen >= 3 && HexNumberLen <= 4) {
Size = 2;
} else if (HexNumberLen >= 5 && HexNumberLen <= 8) {
Size = 4;
} else if (HexNumberLen >= 9 && HexNumberLen <= 16) {
Size = 8;
}
if (Buffer != NULL && *BufferSize >= Size) {
CopyMem(Buffer, (VOID *)&HexNumber, Size);
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*BufferSize = Size;
} else if (DataType == DataTypeHexArray) {
//
// hex array
//
if (*Data == L'H') {
Data = Data + 1;
}
Size = StrLen (Data) / 2;
if (Buffer != NULL && *BufferSize >= Size) {
StrHexToBytes(Data, StrLen (Data), (UINT8 *)Buffer, Size);
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*BufferSize = Size;
} else if (DataType == DataTypeAscii) {
//
// ascii text
//
if (*Data == L'S') {
Data = Data + 1;
}
AsciiBuffer = AllocateZeroPool (StrSize (Data) / 2);
if (AsciiBuffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
AsciiSPrint (AsciiBuffer, StrSize (Data) / 2, "%s", (CHAR8 *)Data);
Size = StrSize (Data) / 2 - 1;
if (Buffer != NULL && *BufferSize >= Size) {
CopyMem (Buffer, AsciiBuffer, Size);
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*BufferSize = Size;
}
SHELL_FREE_NON_NULL (AsciiBuffer);
} else if (DataType == DataTypeUnicode) {
//
// unicode text
//
if (*Data == L'L') {
Data = Data + 1;
}
Size = StrSize (Data) - sizeof (CHAR16);
if (Buffer != NULL && *BufferSize >= Size) {
CopyMem (Buffer, Data, Size);
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*BufferSize = Size;
} else if (DataType == DataTypeDevicePath) {
if (*Data == L'P') {
Data = Data + 1;
} else if (StrnCmp (Data, L"--", 2) == 0) {
Data = Data + 2;
}
DevPath = ConvertTextToDevicePath (Data);
if (DevPath == NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, L"setvar");
Status = EFI_INVALID_PARAMETER;
} else {
Size = GetDevicePathSize (DevPath);
if (Buffer != NULL && *BufferSize >= Size) {
CopyMem (Buffer, DevPath, Size);
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*BufferSize = Size;
}
SHELL_FREE_NON_NULL (DevPath);
} else {
Status = EFI_INVALID_PARAMETER;
}
return Status;
}
/**
Function to get each data from parameters.
@param[in] Package The package of checked values.
@param[out] Buffer A pointer to a buffer to hold the return data.
@param[out] BufferSize Indicates the size of data in bytes return in Buffer.
@retval EFI_INVALID_PARAMETER Buffer or BufferSize is NULL.
@retval EFI_OUT_OF_RESOURCES A memory allcation failed.
@retval EFI_SUCCESS Get each parameter data was successful.
**/
EFI_STATUS
GetVariableDataFromParameter (
IN CONST LIST_ENTRY *Package,
OUT UINT8 **Buffer,
OUT UINTN *BufferSize
)
{
CONST CHAR16 *TempData;
UINTN Index;
UINTN TotalSize;
UINTN Size;
UINT8 *BufferWalker;
EFI_STATUS Status;
TotalSize = 0;
Size = 0;
Status = EFI_SUCCESS;
if (BufferSize == NULL || Buffer == NULL || ShellCommandLineGetCount (Package) < 3) {
return EFI_INVALID_PARAMETER;
}
for (Index = 2; Index < ShellCommandLineGetCount (Package); Index++) {
TempData = ShellCommandLineGetRawValue (Package, Index);
ASSERT (TempData != NULL);
if (TempData[0] != L'=') {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"setvar", TempData);
return EFI_INVALID_PARAMETER;
}
TempData = TempData + 1;
Size = 0;
Status = ParseParameterData (TempData, NULL, &Size);
if (EFI_ERROR (Status)) {
if (Status == EFI_BUFFER_TOO_SMALL) {
//
// We expect return EFI_BUFFER_TOO_SMALL when pass 'NULL' as second parameter to the function ParseParameterData.
//
TotalSize += Size;
} else {
if (Status == EFI_INVALID_PARAMETER) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"setvar", TempData);
} else if (Status == EFI_NOT_FOUND) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, L"setvar");
}
return Status;
}
}
}
*BufferSize = TotalSize;
*Buffer = AllocateZeroPool (TotalSize);
if (*Buffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
BufferWalker = *Buffer;
for (Index = 2; Index < ShellCommandLineGetCount (Package); Index++) {
TempData = ShellCommandLineGetRawValue (Package, Index);
TempData = TempData + 1;
Size = TotalSize;
Status = ParseParameterData (TempData, (VOID *)BufferWalker, &Size);
if (!EFI_ERROR (Status)) {
BufferWalker = BufferWalker + Size;
TotalSize = TotalSize - Size;
} else {
return Status;
}
}
}
return EFI_SUCCESS;
}
/**
Function for 'setvar' command.
@param[in] ImageHandle Handle to the Image (NULL if Internal).
@param[in] SystemTable Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunSetVar (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
RETURN_STATUS RStatus;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST CHAR16 *VariableName;
EFI_GUID Guid;
CONST CHAR16 *StringGuid;
UINT32 Attributes;
VOID *Buffer;
UINTN Size;
UINTN LoopVar;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
Buffer = NULL;
Size = 0;
Attributes = 0;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
Status = CommandInit();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
if (EFI_ERROR(Status)) {
if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, L"setvar", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
if (ShellCommandLineGetCount(Package) < 2) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"setvar");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
VariableName = ShellCommandLineGetRawValue(Package, 1);
if (!ShellCommandLineGetFlag(Package, L"-guid")){
CopyGuid(&Guid, &gEfiGlobalVariableGuid);
} else {
StringGuid = ShellCommandLineGetValue(Package, L"-guid");
RStatus = StrToGuid (StringGuid, &Guid);
if (RETURN_ERROR (RStatus) || (StringGuid[GUID_STRING_LENGTH] != L'\0')) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"setvar", StringGuid);
ShellStatus = SHELL_INVALID_PARAMETER;
}
}
if (ShellCommandLineGetCount(Package) == 2) {
//
// Display
//
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
Buffer = AllocateZeroPool(Size);
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
}
if (!EFI_ERROR(Status) && Buffer != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_SETVAR_PRINT), gShellDebug1HiiHandle, &Guid, VariableName, Size);
for (LoopVar = 0; LoopVar < Size; LoopVar++) {
ShellPrintEx(-1, -1, L"%02x ", ((UINT8*)Buffer)[LoopVar]);
}
ShellPrintEx(-1, -1, L"\r\n");
} else {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_GET), gShellDebug1HiiHandle, L"setvar", &Guid, VariableName);
ShellStatus = SHELL_ACCESS_DENIED;
}
} else {
//
// Create, Delete or Modify.
//
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
Buffer = AllocateZeroPool(Size);
Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes, &Size, Buffer);
}
if (EFI_ERROR(Status) || Buffer == NULL) {
//
// Creating a new variable. determine attributes from command line.
//
Attributes = 0;
if (ShellCommandLineGetFlag(Package, L"-bs")) {
Attributes |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
}
if (ShellCommandLineGetFlag(Package, L"-rt")) {
Attributes |= EFI_VARIABLE_RUNTIME_ACCESS |
EFI_VARIABLE_BOOTSERVICE_ACCESS;
}
if (ShellCommandLineGetFlag(Package, L"-nv")) {
Attributes |= EFI_VARIABLE_NON_VOLATILE;
}
}
SHELL_FREE_NON_NULL(Buffer);
Size = 0;
Status = GetVariableDataFromParameter(Package, (UINT8 **)&Buffer, &Size);
if (!EFI_ERROR(Status)) {
Status = gRT->SetVariable((CHAR16*)VariableName, &Guid, Attributes, Size, Buffer);
}
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_SETVAR_ERROR_SET), gShellDebug1HiiHandle, L"setvar", &Guid, VariableName);
ShellStatus = SHELL_ACCESS_DENIED;
} else {
ASSERT(ShellStatus == SHELL_SUCCESS);
}
}
}
ShellCommandLineFreeVarList (Package);
}
if (Buffer != NULL) {
FreePool(Buffer);
}
return (ShellStatus);
}
Reference in New Issue View Git Blame Copy Permalink