Attachment #321730 for bug #431984

View | Details | Raw Unified | Return to bug 431984
Collapse All | Expand All




#include <dirent.h>
#include <unistd.h>
#include <getopt.h>
#include <sys/utsname.h>
#include "list.h"
#include "efi.h"
#include "efichar.h"

static	LIST_HEAD(boot_entry_list);
static	LIST_HEAD(blk_list);
efibootmgr_opt_t opts;
efi_var_type_t efi_var_type;

static inline void
var_num_from_name(const char *pattern, char *name, uint16_t *num)

	int num, num_boot_names=0;
	efi_status_t ret=0;

	struct utsname u;
	uname(&u);
	if (strcmp(u.machine,"i386") == 0) {	
		efi_var_type = EFI_VAR_TYPE_32;
	}
	else if (strcmp(u.machine,"i486") == 0) {	
		efi_var_type = EFI_VAR_TYPE_32;
	}
	else if (strcmp(u.machine,"i586") == 0) {	
		efi_var_type = EFI_VAR_TYPE_32;
	}
	else if (strcmp(u.machine,"i686") == 0) {	
		efi_var_type = EFI_VAR_TYPE_32;
	}
	else if (strcmp(u.machine,"ia64") == 0) {	
		efi_var_type = EFI_VAR_TYPE_64;
	}
	else if (strcmp(u.machine,"x86_64") == 0) {	
		efi_var_type = EFI_VAR_TYPE_64;
	}
	else {
		efi_var_type = EFI_VAR_TYPE_UNKNOWN;
		fprintf(stderr, "Unknown kernel machine type %s, variable readings may not corrent\n", u.machine);
	}

	set_default_opts();
	parse_opts(argc, argv);
	if (opts.showversion) {




} __attribute__((packed)) efi_variable_t;


typedef struct _efi32_variable_t {
        efi_char16_t  VariableName[1024/sizeof(efi_char16_t)];
        efi_guid_t    VendorGuid;
        uint32_t      DataSize;
        uint8_t          Data[1024];
	efi_status_t  Status;
        uint32_t         Attributes;
} __attribute__((packed)) efi32_variable_t;


typedef struct _efi64_variable_t {
        efi_char16_t  VariableName[1024/sizeof(efi_char16_t)];
        efi_guid_t    VendorGuid;
        uint64_t      DataSize;
        uint8_t          Data[1024];
	efi_status_t  Status;
        uint32_t         Attributes;
} __attribute__((packed)) efi64_variable_t;


typedef struct {
	uint8_t  type;
	uint8_t  subtype;

Lines 55-61 Link Here

(-)efibootmgr-0.5.4.orig/src/include/efibootmgr.h (+6 lines)
55	unsigned short int timeout;	55	unsigned short int timeout;
56	} efibootmgr_opt_t;	56	} efibootmgr_opt_t;
57		57
		58	typedef enum {
		59	EFI_VAR_TYPE_UNKNOWN,
		60	EFI_VAR_TYPE_32,
		61	EFI_VAR_TYPE_64,
		62	} efi_var_type_t;
58		63
59	extern efibootmgr_opt_t opts;	64	extern efibootmgr_opt_t opts;
		65	extern efi_var_type_t efi_var_type;
60		66
61	#endif	67	#endif




	char buffer[PATH_MAX+40];
	if (!name || !var) return EFI_INVALID_PARAMETER;
	memset(buffer, 0, sizeof(buffer));
	efi32_variable_t *var32;
	efi64_variable_t *var64;
	size_t varsize;

	snprintf(filename, PATH_MAX-1, "%s/%s/raw_var", SYSFS_DIR_EFI_VARS,name);
	fd = open(filename, O_RDONLY);
	if (fd == -1) {
		return EFI_NOT_FOUND;
	}

	/* Fix if kernel efi_variable_t not match */
	switch (efi_var_type) {
		case EFI_VAR_TYPE_32:
			varsize = sizeof(*var32);
			var32 = malloc(varsize);
			if (! var32) return EFI_OUT_OF_RESOURCES;
			readsize = read(fd, var32, varsize);
		break;
		case EFI_VAR_TYPE_64:
			varsize = sizeof(*var64);
			var64 = malloc(varsize);
			if (! var64) return EFI_OUT_OF_RESOURCES;
			readsize = read(fd, var64, varsize);
		break;
		default:
			varsize = sizeof(*var);
			readsize = read(fd, var, varsize);
		break;
	}

	if (readsize != varsize) {
		close(fd);
		return EFI_INVALID_PARAMETER;
	}
	close(fd);
        
	if (efi_var_type == EFI_VAR_TYPE_32) {
		memcpy(&var->VariableName,&var32->VariableName,sizeof(var32->VariableName));
		var->DataSize = var32->DataSize;
		memcpy(&var->Data,&var32->Data,sizeof(var32->Data));
		var->Status = var32->Status;
		var->Attributes = var32->Attributes;
	}
	else if (efi_var_type == EFI_VAR_TYPE_64) {
		memcpy(&var->VariableName,&var64->VariableName,sizeof(var64->VariableName));
		var->DataSize = var64->DataSize;
		memcpy(&var->Data,&var64->Data,sizeof(var64->Data));
		var->Status = var64->Status;
		var->Attributes = var64->Attributes;
	}

	return var->Status;
}


	int fd;
	size_t writesize;
	char buffer[PATH_MAX+40];
	efi32_variable_t *var32;
	efi64_variable_t *var64;
	size_t varsize;

	if (!filename || !var) return EFI_INVALID_PARAMETER;
	memset(buffer, 0, sizeof(buffer));

	if (fd == -1) {
		return EFI_INVALID_PARAMETER;
	}
	
	/* Fix if kernel efi_variable_t not match */
	if (efi_var_type == EFI_VAR_TYPE_32) {
		varsize = sizeof(*var32);
		var32 = malloc(varsize);
		if (! var32) return EFI_OUT_OF_RESOURCES;
		memcpy(&var32->VariableName,&var->VariableName,sizeof(var32->VariableName));
		var32->DataSize = var->DataSize;
		memcpy(&var32->Data,&var->Data,sizeof(var32->Data));
		var32->Status = var->Status;
		var32->Attributes = var->Attributes;
		writesize = write(fd, var32, sizeof(*var32));
		free(var32);
	}
	else if (efi_var_type == EFI_VAR_TYPE_64) {
		varsize = sizeof(*var64);
		var64 = malloc(varsize);
		if (! var64) return EFI_OUT_OF_RESOURCES;
		memcpy(&var64->VariableName,&var->VariableName,sizeof(var64->VariableName));
		var64->DataSize = var->DataSize;
		memcpy(&var64->Data,&var->Data,sizeof(var64->Data));
		var64->Status = var->Status;
		var64->Attributes = var->Attributes;
		writesize = write(fd, var64, sizeof(*var64));
		free(var64);
	} else {
		varsize = sizeof(*var);
		writesize = write(fd, var, sizeof(*var));
	}
	
	if (writesize != varsize) {
		close(fd);
		return EFI_INVALID_PARAMETER;
	}

Return to bug 431984

Lines 43-48 Link Here

(-)efibootmgr-0.5.4.orig/src/efibootmgr/efibootmgr.c (+27 lines)
43	#include <dirent.h>	43	#include <dirent.h>
44	#include <unistd.h>	44	#include <unistd.h>
45	#include <getopt.h>	45	#include <getopt.h>
		46	#include <sys/utsname.h>
46	#include "list.h"	47	#include "list.h"
47	#include "efi.h"	48	#include "efi.h"
48	#include "efichar.h"	49	#include "efichar.h"
Lines 68-73 Link Here
68	static LIST_HEAD(boot_entry_list);	69	static LIST_HEAD(boot_entry_list);
69	static LIST_HEAD(blk_list);	70	static LIST_HEAD(blk_list);
70	efibootmgr_opt_t opts;	71	efibootmgr_opt_t opts;
		72	efi_var_type_t efi_var_type;
71		73
72	static inline void	74	static inline void
73	var_num_from_name(const char pattern, char name, uint16_t *num)	75	var_num_from_name(const char pattern, char name, uint16_t *num)
Lines 1029-1034 Link Here
1029	int num, num_boot_names=0;	1031	int num, num_boot_names=0;
1030	efi_status_t ret=0;	1032	efi_status_t ret=0;
1031		1033
		1034	struct utsname u;
		1035	uname(&u);
		1036	if (strcmp(u.machine,"i386") == 0) {
		1037	efi_var_type = EFI_VAR_TYPE_32;
		1038	}
		1039	else if (strcmp(u.machine,"i486") == 0) {
		1040	efi_var_type = EFI_VAR_TYPE_32;
		1041	}
		1042	else if (strcmp(u.machine,"i586") == 0) {
		1043	efi_var_type = EFI_VAR_TYPE_32;
		1044	}
		1045	else if (strcmp(u.machine,"i686") == 0) {
		1046	efi_var_type = EFI_VAR_TYPE_32;
		1047	}
		1048	else if (strcmp(u.machine,"ia64") == 0) {
		1049	efi_var_type = EFI_VAR_TYPE_64;
		1050	}
		1051	else if (strcmp(u.machine,"x86_64") == 0) {
		1052	efi_var_type = EFI_VAR_TYPE_64;
		1053	}
		1054	else {
		1055	efi_var_type = EFI_VAR_TYPE_UNKNOWN;
		1056	fprintf(stderr, "Unknown kernel machine type %s, variable readings may not corrent\n", u.machine);
		1057	}
		1058
1032	set_default_opts();	1059	set_default_opts();
1033	parse_opts(argc, argv);	1060	parse_opts(argc, argv);
1034	if (opts.showversion) {	1061	if (opts.showversion) {

Lines 105-110 Link Here

(-)efibootmgr-0.5.4.orig/src/include/efi.h (+20 lines)
105	} __attribute__((packed)) efi_variable_t;	105	} __attribute__((packed)) efi_variable_t;
106		106
107		107
		108	typedef struct _efi32_variable_t {
		109	efi_char16_t VariableName[1024/sizeof(efi_char16_t)];
		110	efi_guid_t VendorGuid;
		111	uint32_t DataSize;
		112	uint8_t Data[1024];
		113	efi_status_t Status;
		114	uint32_t Attributes;
		115	} __attribute__((packed)) efi32_variable_t;
		116
		117
		118	typedef struct _efi64_variable_t {
		119	efi_char16_t VariableName[1024/sizeof(efi_char16_t)];
		120	efi_guid_t VendorGuid;
		121	uint64_t DataSize;
		122	uint8_t Data[1024];
		123	efi_status_t Status;
		124	uint32_t Attributes;
		125	} __attribute__((packed)) efi64_variable_t;
		126
		127
108	typedef struct {	128	typedef struct {
109	uint8_t type;	129	uint8_t type;
110	uint8_t subtype;	130	uint8_t subtype;

Lines 43-60 Link Here

(-)efibootmgr-0.5.4.orig/src/lib/efivars_sysfs.c (-4 / +75 lines)
43	char buffer[PATH_MAX+40];	43	char buffer[PATH_MAX+40];
44	if (!name \|\| !var) return EFI_INVALID_PARAMETER;	44	if (!name \|\| !var) return EFI_INVALID_PARAMETER;
45	memset(buffer, 0, sizeof(buffer));	45	memset(buffer, 0, sizeof(buffer));
		46	efi32_variable_t *var32;
		47	efi64_variable_t *var64;
		48	size_t varsize;
46		49
47	snprintf(filename, PATH_MAX-1, "%s/%s/raw_var", SYSFS_DIR_EFI_VARS,name);	50	snprintf(filename, PATH_MAX-1, "%s/%s/raw_var", SYSFS_DIR_EFI_VARS,name);
48	fd = open(filename, O_RDONLY);	51	fd = open(filename, O_RDONLY);
49	if (fd == -1) {	52	if (fd == -1) {
50	return EFI_NOT_FOUND;	53	return EFI_NOT_FOUND;
51	}	54	}
52	readsize = read(fd, var, sizeof(*var));	55
53	if (readsize != sizeof(*var)) {	56	/* Fix if kernel efi_variable_t not match */
		57	switch (efi_var_type) {
		58	case EFI_VAR_TYPE_32:
		59	varsize = sizeof(*var32);
		60	var32 = malloc(varsize);
		61	if (! var32) return EFI_OUT_OF_RESOURCES;
		62	readsize = read(fd, var32, varsize);
		63	break;
		64	case EFI_VAR_TYPE_64:
		65	varsize = sizeof(*var64);
		66	var64 = malloc(varsize);
		67	if (! var64) return EFI_OUT_OF_RESOURCES;
		68	readsize = read(fd, var64, varsize);
		69	break;
		70	default:
		71	varsize = sizeof(*var);
		72	readsize = read(fd, var, varsize);
		73	break;
		74	}
		75
		76	if (readsize != varsize) {
54	close(fd);	77	close(fd);
55	return EFI_INVALID_PARAMETER;	78	return EFI_INVALID_PARAMETER;
56	}	79	}
57	close(fd);	80	close(fd);
		81
		82	if (efi_var_type == EFI_VAR_TYPE_32) {
		83	memcpy(&var->VariableName,&var32->VariableName,sizeof(var32->VariableName));
		84	var->DataSize = var32->DataSize;
		85	memcpy(&var->Data,&var32->Data,sizeof(var32->Data));
		86	var->Status = var32->Status;
		87	var->Attributes = var32->Attributes;
		88	}
		89	else if (efi_var_type == EFI_VAR_TYPE_64) {
		90	memcpy(&var->VariableName,&var64->VariableName,sizeof(var64->VariableName));
		91	var->DataSize = var64->DataSize;
		92	memcpy(&var->Data,&var64->Data,sizeof(var64->Data));
		93	var->Status = var64->Status;
		94	var->Attributes = var64->Attributes;
		95	}
		96
58	return var->Status;	97	return var->Status;
59	}	98	}
60		99
Lines 64-69 Link Here
64	int fd;	103	int fd;
65	size_t writesize;	104	size_t writesize;
66	char buffer[PATH_MAX+40];	105	char buffer[PATH_MAX+40];
		106	efi32_variable_t *var32;
		107	efi64_variable_t *var64;
		108	size_t varsize;
67		109
68	if (!filename \|\| !var) return EFI_INVALID_PARAMETER;	110	if (!filename \|\| !var) return EFI_INVALID_PARAMETER;
69	memset(buffer, 0, sizeof(buffer));	111	memset(buffer, 0, sizeof(buffer));
Lines 72-79 Link Here
72	if (fd == -1) {	114	if (fd == -1) {
73	return EFI_INVALID_PARAMETER;	115	return EFI_INVALID_PARAMETER;
74	}	116	}
75	writesize = write(fd, var, sizeof(*var));	117
76	if (writesize != sizeof(*var)) {	118	/* Fix if kernel efi_variable_t not match */
		119	if (efi_var_type == EFI_VAR_TYPE_32) {
		120	varsize = sizeof(*var32);
		121	var32 = malloc(varsize);
		122	if (! var32) return EFI_OUT_OF_RESOURCES;
		123	memcpy(&var32->VariableName,&var->VariableName,sizeof(var32->VariableName));
		124	var32->DataSize = var->DataSize;
		125	memcpy(&var32->Data,&var->Data,sizeof(var32->Data));
		126	var32->Status = var->Status;
		127	var32->Attributes = var->Attributes;
		128	writesize = write(fd, var32, sizeof(*var32));
		129	free(var32);
		130	}
		131	else if (efi_var_type == EFI_VAR_TYPE_64) {
		132	varsize = sizeof(*var64);
		133	var64 = malloc(varsize);
		134	if (! var64) return EFI_OUT_OF_RESOURCES;
		135	memcpy(&var64->VariableName,&var->VariableName,sizeof(var64->VariableName));
		136	var64->DataSize = var->DataSize;
		137	memcpy(&var64->Data,&var->Data,sizeof(var64->Data));
		138	var64->Status = var->Status;
		139	var64->Attributes = var->Attributes;
		140	writesize = write(fd, var64, sizeof(*var64));
		141	free(var64);
		142	} else {
		143	varsize = sizeof(*var);
		144	writesize = write(fd, var, sizeof(*var));
		145	}
		146
		147	if (writesize != varsize) {
77	close(fd);	148	close(fd);
78	return EFI_INVALID_PARAMETER;	149	return EFI_INVALID_PARAMETER;
79	}	150	}