proxmox-mirrors/efi-boot-shim
1
0
Fork 0
mirror of https://git.proxmox.com/git/efi-boot-shim synced 2025-08-02 13:31:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

lib: Use EFI_ERROR() instead of comparing to EFI_SUCCESS everywhere.

Browse Source 
Also consistently name our status variable "efi_status" unless there's a
good reason not to, such as already having another one of those.

Signed-off-by: Peter Jones <pjones@redhat.com>
This commit is contained in:
Peter Jones 2017-10-19 15:02:41 -04:00 committed by Peter Jones
parent 4816cd7533
commit a55b4d6688
6 changed files with 184 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
lib/console.c
View File

@ -39,14 +39,16 @@ EFI_STATUS
console_get_keystroke(EFI_INPUT_KEY *key)
{
UINTN EventIndex;
EFI_STATUS status;
EFI_STATUS efi_status;
do {
uefi_call_wrapper(BS->WaitForEvent, 3, 1, &ST->ConIn->WaitForKey, &EventIndex);
status = uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn, key);
} while (status == EFI_NOT_READY);
uefi_call_wrapper(BS->WaitForEvent, 3, 1,
&ST->ConIn->WaitForKey, &EventIndex);
efi_status = uefi_call_wrapper(ST->ConIn->ReadKeyStroke,
2, ST->ConIn, key);
} while (efi_status == EFI_NOT_READY);
return status;
return efi_status;
}
void
@ -183,7 +185,7 @@ console_select(CHAR16 *title[], CHAR16* selectors[], unsigned int start)
SIMPLE_TEXT_OUTPUT_MODE SavedConsoleMode;
SIMPLE_TEXT_OUTPUT_INTERFACE *co = ST->ConOut;
EFI_INPUT_KEY k;
EFI_STATUS status;
EFI_STATUS efi_status;
int selector;
unsigned int selector_lines = count_lines(selectors);
int selector_max_cols = 0;
@ -236,9 +238,9 @@ console_select(CHAR16 *title[], CHAR16* selectors[], unsigned int start)
size_cols, size_rows, 0, lines);
do {
status = console_get_keystroke(&k);
if (EFI_ERROR (status)) {
Print(L"Failed to read the keystroke: %r", status);
efi_status = console_get_keystroke(&k);
if (EFI_ERROR (efi_status)) {
Print(L"Failed to read the keystroke: %r", efi_status);
selector = -1;
break;
}
@ -365,13 +367,13 @@ static struct {
static CHAR16 *
err_string (
IN EFI_STATUS Status
IN EFI_STATUS efi_status
)
{
UINTN Index;
for (Index = 0; error_table[Index].Desc; Index +=1) {
if (error_table[Index].Code == Status) {
if (error_table[Index].Code == efi_status) {
return error_table[Index].Desc;
}
}
@ -380,7 +382,7 @@ err_string (
}
void
console_error(CHAR16 *err, EFI_STATUS status)
console_error(CHAR16 *err, EFI_STATUS efi_status)
{
CHAR16 **err_arr = (CHAR16 *[]){
L"ERROR",
@ -390,8 +392,8 @@ console_error(CHAR16 *err, EFI_STATUS status)
};
CHAR16 str[512];
SPrint(str, sizeof(str), L"%s: (0x%x) %s", err, status, err_string(status));
SPrint(str, sizeof(str), L"%s: (0x%x) %s", err, efi_status,
err_string(efi_status));
err_arr[2] = str;
@ -414,38 +416,38 @@ UINT8 verbose;
VOID
setup_verbosity(VOID)
{
EFI_STATUS status;
EFI_STATUS efi_status;
UINT8 verbose_check;
UINTN verbose_check_size;
verbose_check_size = 1;
status = get_variable(L"SHIM_VERBOSE", (void *)&verbose_check,
efi_status = get_variable(L"SHIM_VERBOSE", (void *)&verbose_check,
&verbose_check_size, SHIM_LOCK_GUID);
verbose = 0;
if (!EFI_ERROR(status))
if (!EFI_ERROR(efi_status))
verbose = verbose_check;
}
VOID setup_console (int text)
{
EFI_STATUS status;
EFI_STATUS efi_status;
EFI_CONSOLE_CONTROL_PROTOCOL *concon;
static EFI_CONSOLE_CONTROL_SCREEN_MODE mode =
EfiConsoleControlScreenGraphics;
EFI_CONSOLE_CONTROL_SCREEN_MODE new_mode;
status = LibLocateProtocol(&EFI_CONSOLE_CONTROL_GUID,
(VOID **)&concon);
if (status != EFI_SUCCESS)
efi_status = LibLocateProtocol(&EFI_CONSOLE_CONTROL_GUID,
(VOID **)&concon);
if (EFI_ERROR(efi_status))
return;
if (text) {
new_mode = EfiConsoleControlScreenText;
status = uefi_call_wrapper(concon->GetMode, 4, concon, &mode,
0, 0);
efi_status = uefi_call_wrapper(concon->GetMode, 4, concon,
&mode, 0, 0);
/* If that didn't work, assume it's graphics */
if (status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
mode = EfiConsoleControlScreenGraphics;
} else {
new_mode = mode;
@ -463,15 +465,16 @@ print_errors_cb(const char *str, size_t len, void *u)
}
EFI_STATUS
print_crypto_errors(EFI_STATUS rc, char *file, const char *func, int line)
print_crypto_errors(EFI_STATUS efi_status,
char *file, const char *func, int line)
{
if (!(verbose && EFI_ERROR(rc)))
return rc;
if (!(verbose && EFI_ERROR(efi_status)))
return efi_status;
Print(L"SSL Error: %a:%d %a(): %r\n", file, line, func, rc);
Print(L"SSL Error: %a:%d %a(): %r\n", file, line, func, efi_status);
ERR_print_errors_cb(print_errors_cb, NULL);
return rc;
return efi_status;
}
VOID

30
lib/execute.c
View File

@ -95,32 +95,32 @@ error:
EFI_STATUS
execute(EFI_HANDLE image, CHAR16 *name)
{
EFI_STATUS status;
EFI_STATUS efi_status;
EFI_HANDLE h;
EFI_LOADED_IMAGE *li;
EFI_DEVICE_PATH *devpath;
CHAR16 *PathName;
status = uefi_call_wrapper(BS->HandleProtocol, 3, image,
&IMAGE_PROTOCOL, (void **)&li);
if (status != EFI_SUCCESS)
return status;
efi_status = uefi_call_wrapper(BS->HandleProtocol, 3, image,
&IMAGE_PROTOCOL, (void **)&li);
if (EFI_ERROR(efi_status))
return efi_status;
status = generate_path(name, li, &devpath, &PathName);
if (status != EFI_SUCCESS)
return status;
status = uefi_call_wrapper(BS->LoadImage, 6, FALSE, image,
devpath, NULL, 0, &h);
if (status != EFI_SUCCESS)
efi_status = generate_path(name, li, &devpath, &PathName);
if (EFI_ERROR(efi_status))
return efi_status;
efi_status = uefi_call_wrapper(BS->LoadImage, 6, FALSE, image,
devpath, NULL, 0, &h);
if (EFI_ERROR(efi_status))
goto out;
status = uefi_call_wrapper(BS->StartImage, 3, h, NULL, NULL);
efi_status = uefi_call_wrapper(BS->StartImage, 3, h, NULL, NULL);
uefi_call_wrapper(BS->UnloadImage, 1, h);
out:
FreePool(PathName);
FreePool(devpath);
return status;
return efi_status;
}

85
lib/security_policy.c
View File

@ -80,16 +80,15 @@ security2_policy_authentication (
BOOLEAN BootPolicy
)
{
EFI_STATUS status, auth;
EFI_STATUS efi_status, auth;
/* Chain original security policy */
status = uefi_call_wrapper(es2fa, 5, This, DevicePath, FileBuffer,
FileSize, BootPolicy);
efi_status = uefi_call_wrapper(es2fa, 5, This, DevicePath, FileBuffer,
FileSize, BootPolicy);
/* if OK, don't bother with MOK check */
if (status == EFI_SUCCESS)
return status;
if (!EFI_ERROR(efi_status))
return efi_status;
if (extra_check)
auth = extra_check(FileBuffer, FileSize);
@ -100,7 +99,7 @@ security2_policy_authentication (
/* return previous status, which is the correct one
* for the platform: may be either EFI_ACCESS_DENIED
* or EFI_SECURITY_VIOLATION */
return status;
return efi_status;
return auth;
}
@ -112,7 +111,7 @@ security_policy_authentication (
const EFI_DEVICE_PATH_PROTOCOL *DevicePathConst
)
{
EFI_STATUS status, fail_status;
EFI_STATUS efi_status, fail_status;
EFI_DEVICE_PATH *DevPath
= DuplicateDevicePath((EFI_DEVICE_PATH *)DevicePathConst),
*OrigDevPath = DevPath;
@ -123,48 +122,48 @@ security_policy_authentication (
CHAR16* DevPathStr;
/* Chain original security policy */
status = uefi_call_wrapper(esfas, 3, This, AuthenticationStatus,
DevicePathConst);
efi_status = uefi_call_wrapper(esfas, 3, This, AuthenticationStatus,
DevicePathConst);
/* if OK avoid checking MOK: It's a bit expensive to
* read the whole file in again (esfas already did this) */
if (status == EFI_SUCCESS)
if (!EFI_ERROR(efi_status))
goto out;
/* capture failure status: may be either EFI_ACCESS_DENIED or
* EFI_SECURITY_VIOLATION */
fail_status = status;
fail_status = efi_status;
status = uefi_call_wrapper(BS->LocateDevicePath, 3,
&SIMPLE_FS_PROTOCOL, &DevPath, &h);
if (status != EFI_SUCCESS)
efi_status = uefi_call_wrapper(BS->LocateDevicePath, 3,
&SIMPLE_FS_PROTOCOL, &DevPath, &h);
if (EFI_ERROR(efi_status))
goto out;
DevPathStr = DevicePathToStr(DevPath);
status = simple_file_open_by_handle(h, DevPathStr, &f,
EFI_FILE_MODE_READ);
efi_status = simple_file_open_by_handle(h, DevPathStr, &f,
EFI_FILE_MODE_READ);
FreePool(DevPathStr);
if (status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
goto out;
status = simple_file_read_all(f, &FileSize, &FileBuffer);
efi_status = simple_file_read_all(f, &FileSize, &FileBuffer);
simple_file_close(f);
if (status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
goto out;
if (extra_check)
status = extra_check(FileBuffer, FileSize);
efi_status = extra_check(FileBuffer, FileSize);
else
status = EFI_SECURITY_VIOLATION;
efi_status = EFI_SECURITY_VIOLATION;
FreePool(FileBuffer);
if (status == EFI_ACCESS_DENIED || status == EFI_SECURITY_VIOLATION)
if (efi_status == EFI_ACCESS_DENIED ||
efi_status == EFI_SECURITY_VIOLATION)
/* return what the platform originally said */
status = fail_status;
efi_status = fail_status;
out:
FreePool(OrigDevPath);
return status;
return efi_status;
}
@ -265,7 +264,7 @@ security_policy_install(SecurityHook hook)
{
EFI_SECURITY_PROTOCOL *security_protocol;
EFI_SECURITY2_PROTOCOL *security2_protocol = NULL;
EFI_STATUS status;
EFI_STATUS efi_status;
if (esfas)
/* Already Installed */
@ -278,16 +277,16 @@ security_policy_install(SecurityHook hook)
&SECURITY2_PROTOCOL_GUID, NULL,
(VOID **) &security2_protocol);
status = uefi_call_wrapper(BS->LocateProtocol, 3,
efi_status = uefi_call_wrapper(BS->LocateProtocol, 3,
&SECURITY_PROTOCOL_GUID, NULL,
(VOID **) &security_protocol);
if (status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
/* This one is mandatory, so there's a serious problem */
return status;
return efi_status;
if (security2_protocol) {
es2fa = security2_protocol->FileAuthentication;
security2_protocol->FileAuthentication =
security2_protocol->FileAuthentication =
(EFI_SECURITY2_FILE_AUTHENTICATION) thunk_security2_policy_authentication;
}
@ -304,17 +303,16 @@ security_policy_install(SecurityHook hook)
EFI_STATUS
security_policy_uninstall(void)
{
EFI_STATUS status;
EFI_STATUS efi_status;
if (esfas) {
EFI_SECURITY_PROTOCOL *security_protocol;
status = uefi_call_wrapper(BS->LocateProtocol, 3,
&SECURITY_PROTOCOL_GUID, NULL,
(VOID **) &security_protocol);
if (status != EFI_SUCCESS)
return status;
efi_status = uefi_call_wrapper(BS->LocateProtocol, 3,
&SECURITY_PROTOCOL_GUID, NULL,
(VOID **) &security_protocol);
if (EFI_ERROR(efi_status))
return efi_status;
security_protocol->FileAuthenticationState = esfas;
esfas = NULL;
@ -326,12 +324,11 @@ security_policy_uninstall(void)
if (es2fa) {
EFI_SECURITY2_PROTOCOL *security2_protocol;
status = uefi_call_wrapper(BS->LocateProtocol, 3,
&SECURITY2_PROTOCOL_GUID, NULL,
(VOID **) &security2_protocol);
if (status != EFI_SUCCESS)
return status;
efi_status = uefi_call_wrapper(BS->LocateProtocol, 3,
&SECURITY2_PROTOCOL_GUID, NULL,
(VOID **) &security2_protocol);
if (EFI_ERROR(efi_status))
return efi_status;
security2_protocol->FileAuthentication = es2fa;
es2fa = NULL;

9
lib/shell.c
View File

@ -14,16 +14,17 @@ EFI_STATUS
argsplit(EFI_HANDLE image, int *argc, CHAR16*** ARGV)
{
unsigned int i, count = 1;
EFI_STATUS status;
EFI_STATUS efi_status;
EFI_LOADED_IMAGE *info;
CHAR16 *start;
*argc = 0;
status = uefi_call_wrapper(BS->HandleProtocol, 3, image, &LoadedImageProtocol, (VOID **) &info);
if (EFI_ERROR(status)) {
efi_status = uefi_call_wrapper(BS->HandleProtocol, 3, image,
&LoadedImageProtocol, (VOID **) &info);
if (EFI_ERROR(efi_status)) {
Print(L"Failed to get arguments\n");
return status;
return efi_status;
}
for (i = 0; i < info->LoadOptionsSize; i += 2) {

83
lib/simple_file.c
View File

@ -19,14 +19,14 @@ simple_file_open_by_handle(EFI_HANDLE device, CHAR16 *name, EFI_FILE **file, UIN
efi_status = uefi_call_wrapper(BS->HandleProtocol, 3, device,
&EFI_SIMPLE_FILE_SYSTEM_GUID, (void **)&drive);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
Print(L"Unable to find simple file protocol (%d)\n", efi_status);
goto error;
}
efi_status = uefi_call_wrapper(drive->OpenVolume, 2, drive, &root);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
Print(L"Failed to open drive volume (%d)\n", efi_status);
goto error;
}
@ -50,12 +50,12 @@ simple_file_open(EFI_HANDLE image, CHAR16 *name, EFI_FILE **file, UINT64 mode)
efi_status = uefi_call_wrapper(BS->HandleProtocol, 3, image,
&IMAGE_PROTOCOL, (void **)&li);
if (efi_status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
return simple_file_open_by_handle(image, name, file, mode);
efi_status = generate_path(name, li, &loadpath, &PathName);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
Print(L"Unable to generate load path for %s\n", name);
return efi_status;
}
@ -74,28 +74,28 @@ EFI_STATUS
simple_dir_read_all_by_handle(EFI_HANDLE image, EFI_FILE *file, CHAR16* name, EFI_FILE_INFO **entries,
int *count)
{
EFI_STATUS status;
EFI_STATUS efi_status;
char buf[4096];
UINTN size = sizeof(buf);
EFI_FILE_INFO *fi = (void *)buf;
status = uefi_call_wrapper(file->GetInfo, 4, file, &EFI_FILE_INFO_GUID,
&size, fi);
if (status != EFI_SUCCESS) {
efi_status = uefi_call_wrapper(file->GetInfo, 4, file, &EFI_FILE_INFO_GUID,
&size, fi);
if (EFI_ERROR(efi_status)) {
Print(L"Failed to get file info\n");
goto out;
}
if ((fi->Attribute & EFI_FILE_DIRECTORY) == 0) {
Print(L"Not a directory %s\n", name);
status = EFI_INVALID_PARAMETER;
efi_status = EFI_INVALID_PARAMETER;
goto out;
}
size = 0;
*count = 0;
for (;;) {
UINTN len = sizeof(buf);
status = uefi_call_wrapper(file->Read, 3, file, &len, buf);
if (status != EFI_SUCCESS || len == 0)
efi_status = uefi_call_wrapper(file->Read, 3, file, &len, buf);
if (EFI_ERROR(efi_status) || len == 0)
break;
(*count)++;
size += len;
@ -113,14 +113,14 @@ simple_dir_read_all_by_handle(EFI_HANDLE image, EFI_FILE *file, CHAR16* name, EF
ptr += len;
size -= len;
}
status = EFI_SUCCESS;
efi_status = EFI_SUCCESS;
out:
simple_file_close(file);
if (status != EFI_SUCCESS && *entries) {
if (EFI_ERROR(efi_status) && *entries) {
FreePool(*entries);
*entries = NULL;
}
return status;
return efi_status;
}
EFI_STATUS
@ -128,12 +128,12 @@ simple_dir_read_all(EFI_HANDLE image, CHAR16 *name, EFI_FILE_INFO **entries,
int *count)
{
EFI_FILE *file;
EFI_STATUS status;
EFI_STATUS efi_status;
status = simple_file_open(image, name, &file, EFI_FILE_MODE_READ);
if (status != EFI_SUCCESS) {
Print(L"failed to open file %s: %d\n", name, status);
return status;
efi_status = simple_file_open(image, name, &file, EFI_FILE_MODE_READ);
if (EFI_ERROR(efi_status)) {
Print(L"failed to open file %s: %d\n", name, efi_status);
return efi_status;
}
return simple_dir_read_all_by_handle(image, file, name, entries, count);
@ -151,7 +151,7 @@ simple_file_read_all(EFI_FILE *file, UINTN *size, void **buffer)
efi_status = uefi_call_wrapper(file->GetInfo, 4, file,
&EFI_FILE_INFO_GUID, size, fi);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
Print(L"Failed to get file info\n");
return efi_status;
}
@ -190,7 +190,7 @@ simple_volume_selector(CHAR16 **title, CHAR16 **selected, EFI_HANDLE *h)
{
UINTN count, i;
EFI_HANDLE *vol_handles = NULL;
EFI_STATUS status;
EFI_STATUS efi_status;
CHAR16 **entries;
int val;
@ -212,20 +212,22 @@ simple_volume_selector(CHAR16 **title, CHAR16 **selected, EFI_HANDLE *h)
CHAR16 *name;
EFI_FILE_IO_INTERFACE *drive;
status = uefi_call_wrapper(BS->HandleProtocol, 3,
vol_handles[i],
&EFI_SIMPLE_FILE_SYSTEM_GUID,
(void **)&drive);
if (status != EFI_SUCCESS || !drive)
efi_status = uefi_call_wrapper(BS->HandleProtocol, 3,
vol_handles[i],
&EFI_SIMPLE_FILE_SYSTEM_GUID,
(void **)&drive);
if (EFI_ERROR(efi_status) || !drive)
continue;
status = uefi_call_wrapper(drive->OpenVolume, 2, drive, &root);
if (status != EFI_SUCCESS)
efi_status = uefi_call_wrapper(drive->OpenVolume, 2, drive,
&root);
if (EFI_ERROR(efi_status))
continue;
status = uefi_call_wrapper(root->GetInfo, 4, root,
&EFI_FILE_SYSTEM_INFO_GUID, &size, fi);
if (status != EFI_SUCCESS)
efi_status = uefi_call_wrapper(root->GetInfo, 4, root,
&EFI_FILE_SYSTEM_INFO_GUID,
&size, fi);
if (EFI_ERROR(efi_status))
continue;
name = fi->VolumeLabel;
@ -266,7 +268,7 @@ EFI_STATUS
simple_dir_filter(EFI_HANDLE image, CHAR16 *name, CHAR16 *filter,
CHAR16 ***result, int *count, EFI_FILE_INFO **entries)
{
EFI_STATUS status;
EFI_STATUS efi_status;
int tot, offs = StrLen(filter), i, c, filtercount = 1;
EFI_FILE_INFO *next;
void *ptr;
@ -297,8 +299,8 @@ simple_dir_filter(EFI_HANDLE image, CHAR16 *name, CHAR16 *filter,
*count = 0;
status = simple_dir_read_all(image, name, entries, &tot);
if (status != EFI_SUCCESS)
efi_status = simple_dir_read_all(image, name, entries, &tot);
if (EFI_ERROR(efi_status))
goto out;
ptr = next = *entries;
@ -375,10 +377,10 @@ simple_dir_filter(EFI_HANDLE image, CHAR16 *name, CHAR16 *filter,
(*result)[(*count)++] = L"./";
}
(*result)[*count] = NULL;
status = EFI_SUCCESS;
efi_status = EFI_SUCCESS;
out:
if (status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
if (*entries)
FreePool(*entries);
*entries = NULL;
@ -386,7 +388,7 @@ simple_dir_filter(EFI_HANDLE image, CHAR16 *name, CHAR16 *filter,
FreePool(*result);
*result = NULL;
}
return status;
return efi_status;
}
static void
@ -402,7 +404,7 @@ void
simple_file_selector(EFI_HANDLE * im, CHAR16 ** title, CHAR16 * name,
CHAR16 * filter, CHAR16 ** result)
{
EFI_STATUS status;
EFI_STATUS efi_status;
CHAR16 **entries = NULL;
EFI_FILE_INFO *dmp = NULL;
int count, select, len;
@ -432,8 +434,9 @@ simple_file_selector(EFI_HANDLE * im, CHAR16 ** title, CHAR16 * name,
name = newname;
redo:
status = simple_dir_filter(*im, name, filter, &entries, &count, &dmp);
if (status != EFI_SUCCESS)
efi_status = simple_dir_filter(*im, name, filter, &entries, &count,
&dmp);
if (EFI_ERROR(efi_status))
goto out_free;
select = console_select(title, entries, 0);

93
lib/variables.c
View File

@ -54,7 +54,7 @@ variable_create_esl(void *cert, int cert_len, EFI_GUID *type, EFI_GUID *owner,
EFI_STATUS
CreateTimeBasedPayload(IN OUT UINTN * DataSize, IN OUT UINT8 ** Data)
{
EFI_STATUS Status;
EFI_STATUS efi_status;
UINT8 *NewData;
UINT8 *Payload;
UINTN PayloadSize;
@ -65,12 +65,13 @@ CreateTimeBasedPayload(IN OUT UINTN * DataSize, IN OUT UINT8 ** Data)
if (Data == NULL || DataSize == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// In Setup mode or Custom mode, the variable does not need to be signed but the
// parameters to the SetVariable() call still need to be prepared as authenticated
// variable. So we create EFI_VARIABLE_AUTHENTICATED_2 descriptor without certificate
// data in it.
//
/*
* In Setup mode or Custom mode, the variable does not need to be
* signed but the
* parameters to the SetVariable() call still need to be prepared as
* authenticated variable. So we create EFI_VARIABLE_AUTHENTICATED_2
* descriptor without certificate data in it.
*/
Payload = *Data;
PayloadSize = *DataSize;
@ -88,10 +89,10 @@ CreateTimeBasedPayload(IN OUT UINTN * DataSize, IN OUT UINT8 ** Data)
DescriptorData = (EFI_VARIABLE_AUTHENTICATION_2 *) (NewData);
ZeroMem(&Time, sizeof(EFI_TIME));
Status = uefi_call_wrapper(RT->GetTime, 2, &Time, NULL);
if (EFI_ERROR(Status)) {
efi_status = uefi_call_wrapper(RT->GetTime, 2, &Time, NULL);
if (EFI_ERROR(efi_status)) {
FreePool(NewData);
return Status;
return efi_status;
}
Time.Pad1 = 0;
Time.Nanosecond = 0;
@ -106,8 +107,10 @@ CreateTimeBasedPayload(IN OUT UINTN * DataSize, IN OUT UINT8 ** Data)
DescriptorData->AuthInfo.Hdr.wCertificateType = WIN_CERT_TYPE_EFI_GUID;
DescriptorData->AuthInfo.CertType = EFI_CERT_TYPE_PKCS7_GUID;
/* we're expecting an EFI signature list, so don't free the input since
* it might not be in a pool */
/*
* we're expecting an EFI signature list, so don't free the input
* since it might not be in a pool
*/
#if 0
if (Payload != NULL) {
FreePool(Payload);
@ -137,7 +140,7 @@ SetSecureVariable(CHAR16 *var, UINT8 *Data, UINTN len, EFI_GUID owner,
int ds;
efi_status = variable_create_esl(Data, len, &X509_GUID, NULL,
(void **)&Cert, &ds);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
Print(L"Failed to create %s certificate %d\n", var, efi_status);
return efi_status;
}
@ -149,7 +152,7 @@ SetSecureVariable(CHAR16 *var, UINT8 *Data, UINTN len, EFI_GUID owner,
DataSize = len;
}
efi_status = CreateTimeBasedPayload(&DataSize, (UINT8 **)&Cert);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
Print(L"Failed to create time based payload %d\n", efi_status);
return efi_status;
}
@ -173,7 +176,7 @@ GetOSIndications(void)
EFI_STATUS efi_status;
efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"OsIndicationsSupported", &GV_GUID, NULL, &DataSize, &indications);
if (efi_status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
return 0;
return indications;
@ -188,11 +191,11 @@ SETOSIndicationsAndReboot(UINT64 indications)
efi_status = uefi_call_wrapper(RT->SetVariable, 5, L"OsIndications",
&GV_GUID,
EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS,
DataSize, &indications);
if (efi_status != EFI_SUCCESS)
if (EFI_ERROR(efi_status))
return efi_status;
uefi_call_wrapper(RT->ResetSystem, 4, EfiResetWarm, EFI_SUCCESS, 0, NULL);
@ -223,8 +226,7 @@ get_variable_attr(CHAR16 *var, UINT8 **data, UINTN *len, EFI_GUID owner,
efi_status = uefi_call_wrapper(RT->GetVariable, 5, var, &owner,
attributes, len, *data);
if (efi_status != EFI_SUCCESS) {
if (EFI_ERROR(efi_status)) {
FreePool(*data);
*data = NULL;
}
@ -259,17 +261,17 @@ find_in_variable_esl(CHAR16* var, EFI_GUID owner, UINT8 *key, UINTN keylen)
{
UINTN DataSize = 0;
UINT8 *Data = NULL;
EFI_STATUS status;
EFI_STATUS efi_status;
status = get_variable(var, &Data, &DataSize, owner);
if (status != EFI_SUCCESS)
return status;
efi_status = get_variable(var, &Data, &DataSize, owner);
if (EFI_ERROR(efi_status))
return efi_status;
status = find_in_esl(Data, DataSize, key, keylen);
efi_status = find_in_esl(Data, DataSize, key, keylen);
FreePool(Data);
return status;
return efi_status;
}
int
@ -278,11 +280,11 @@ variable_is_setupmode(int default_return)
/* set to 1 because we return true if SetupMode doesn't exist */
UINT8 SetupMode = default_return;
UINTN DataSize = sizeof(SetupMode);
EFI_STATUS status;
EFI_STATUS efi_status;
status = uefi_call_wrapper(RT->GetVariable, 5, L"SetupMode", &GV_GUID, NULL,
&DataSize, &SetupMode);
if (EFI_ERROR(status))
efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"SetupMode",
&GV_GUID, NULL, &DataSize, &SetupMode);
if (EFI_ERROR(efi_status))
return default_return;
return SetupMode;
@ -294,12 +296,12 @@ variable_is_secureboot(void)
/* return false if variable doesn't exist */
UINT8 SecureBoot = 0;
UINTN DataSize;
EFI_STATUS status;
EFI_STATUS efi_status;
DataSize = sizeof(SecureBoot);
status = uefi_call_wrapper(RT->GetVariable, 5, L"SecureBoot", &GV_GUID, NULL,
&DataSize, &SecureBoot);
if (EFI_ERROR(status))
efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"SecureBoot",
&GV_GUID, NULL, &DataSize, &SecureBoot);
if (EFI_ERROR(efi_status))
return 0;
return SecureBoot;
@ -309,14 +311,15 @@ EFI_STATUS
variable_enroll_hash(CHAR16 *var, EFI_GUID owner,
UINT8 hash[SHA256_DIGEST_SIZE])
{
EFI_STATUS status;
EFI_STATUS efi_status;
if (find_in_variable_esl(var, owner, hash, SHA256_DIGEST_SIZE)
== EFI_SUCCESS)
efi_status = find_in_variable_esl(var, owner, hash, SHA256_DIGEST_SIZE);
if (!EFI_ERROR(efi_status))
/* hash already present */
return EFI_ALREADY_STARTED;
UINT8 sig[sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_SIGNATURE_DATA) - 1 + SHA256_DIGEST_SIZE];
UINT8 sig[sizeof(EFI_SIGNATURE_LIST)
+ sizeof(EFI_SIGNATURE_DATA) - 1 + SHA256_DIGEST_SIZE];
EFI_SIGNATURE_LIST *l = (void *)sig;
EFI_SIGNATURE_DATA *d = (void *)sig + sizeof(EFI_SIGNATURE_LIST);
SetMem(sig, 0, sizeof(sig));
@ -327,13 +330,13 @@ variable_enroll_hash(CHAR16 *var, EFI_GUID owner,
d->SignatureOwner = SHIM_LOCK_GUID;
if (CompareGuid(&owner, &SIG_DB) == 0)
status = SetSecureVariable(var, sig, sizeof(sig), owner,
EFI_VARIABLE_APPEND_WRITE, 0);
efi_status = SetSecureVariable(var, sig, sizeof(sig), owner,
EFI_VARIABLE_APPEND_WRITE, 0);
else
status = uefi_call_wrapper(RT->SetVariable, 5, var, &owner,
EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_APPEND_WRITE,
sizeof(sig), sig);
return status;
efi_status = uefi_call_wrapper(RT->SetVariable, 5, var, &owner,
EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_APPEND_WRITE,
sizeof(sig), sig);
return efi_status;
}