static EFI_STATUS
get_info(CHAR16 *name, update_table *info_out)
{
EFI_STATUS rc;
update_info *info = NULL;
UINTN info_size = 0;
UINT32 attributes = 0;
void *info_ptr = NULL;
rc = read_variable(name, fwupdate_guid, &info_ptr, &info_size,
&attributes);
if (EFI_ERROR(rc))
return rc;
info = (update_info *)info_ptr;
if (info_size < sizeof (*info)) {
Print(L"Update \"%s\" is is too small.\n", name);
delete_variable(name, fwupdate_guid, attributes);
return EFI_INVALID_PARAMETER;
}
if (info_size - sizeof (EFI_DEVICE_PATH) <= sizeof (*info)) {
Print(L"Update \"%s\" is malformed, "
L"and cannot hold a file path.\n", name);
delete_variable(name, fwupdate_guid, attributes);
return EFI_INVALID_PARAMETER;
}
EFI_DEVICE_PATH *hdr = (EFI_DEVICE_PATH *)&info->dp;
INTN is = EFI_FIELD_OFFSET(update_info, dp);
if (is > (INTN)info_size) {
Print(L"Update \"%s\" has an invalid file path.\n"
L"Device path offset is %d, but total size is %d\n",
name, is, info_size);
delete_variable(name, fwupdate_guid, attributes);
return EFI_INVALID_PARAMETER;
}
is = info_size - is;
INTN sz = dp_size(hdr, info_size);
if (sz < 0 || is < 0) {
invalid_size:
Print(L"Update \"%s\" has an invalid file path.\n"
L"update info size: %d dp size: %d size for dp: %d\n",
name, info_size, sz, is);
delete_variable(name, fwupdate_guid, attributes);
return EFI_INVALID_PARAMETER;
}
if (is > (INTN)info_size)
goto invalid_size;
if (is != sz)
goto invalid_size;
info_out->info = info;
info_out->size = info_size;
info_out->attributes = attributes;
return EFI_SUCCESS;
}
void CRegRequirementList::Free()
{
reglist::iterator it;
varlist::iterator vit;
reg_item *item;
var_item *vitem;
int i;
for(i = m_rlist.size(), it = m_rlist.begin(); i; i--, it++){
item = &(*it);
free_reg(&item->addr, item->length);
}
for(i = m_vlist.size(), vit = m_vlist.begin(); i; i--, vit++){
vitem = &(vit->second);
if(vitem->var->blk == sections){
//
// reference to a global variable
//
vitem->var->ref_count -= vitem->ref_count;
}else{
vitem->var->blk_uuid = vitem->blk_id;
delete_variable(vitem->var);
}
}
m_rlist.clear();
m_vlist.clear();
}
int delete_variable(variable* p)
{
if(p==NULL) return 0;
delete_variable(p->next);
delete_qualifier(p->qualifiers);
delete_curve(p->curves);
delete_drange(p->dranges);
delete_location(p->location_data);
delete_orientation(p->orientation_data);
free(p->length);
free(p->kind);
free(p->name);
free(p->qualifier);
free(p->id);
free(p->range_min);
free(p->range_max);
free(p->default_value);
free(p->precision);
free(p->units);
free(p->accuracy);
free(p->scale_factor);
free(p->scale_units);
free(p->format);
free(p->description);
free(p->interface_name);
free(p->interface_id);
free(p->r_low);
free(p->r_high);
free(p->y_low);
free(p->y_high);
free(p->invalid_value);
free(p);
return 1;
}
void pa_policy_context_free(struct pa_policy_context *ctx)
{
if (ctx != NULL) {
while (ctx->variables != NULL)
delete_variable(ctx, ctx->variables);
while (ctx->activities != NULL)
delete_activity(ctx, ctx->activities);
pa_xfree(ctx);
}
}
int delete_interface(interface* p)
{
if(p==NULL) return 0;
delete_interface(p->next);
delete_qualifier(p->qualifiers);
delete_variable(p->variables);
delete_command(p->commands);
delete_notification(p->notifications);
delete_request(p->requests);
free(p->name);
free(p->extends);
free(p->id);
free(p->description);
free(p);
return 1;
}
/**
* Assign a value to a variable or delete the variable if no assignment is given.
* List all variables if no arguments are given.
*/
void cmd_let(char *args) {
unsigned char token;
unsigned int var_name;
unsigned char var_type;
skip_whitespace(args);
if (*args == '\0') {
print_all_variables();
print_ready();
return;
}
if (args = parse_variable(args, &var_name, &var_type)) {
if (next_token(args) == TOKEN_ASSIGN) {
token = next_token(args);
args = consume_token(args, token);
switch (var_type) {
case VAR_TYPE_INTEGER: {
int value;
if (parse_number_expression(args, &value)) {
create_variable(var_name, var_type, &value);
}
break;
}
case VAR_TYPE_STRING: {
char *value;
if (parse_string_expression(args, &value)) {
create_variable(var_name, var_type, value);
}
break;
}
}
} else {
if (*args == '\0') {
delete_variable(var_name, var_type);
}
}
} else {
syntax_error();
}
}
static void
parse_args(int argc, char **argv)
{
int ch, i;
while ((ch = getopt_long(argc, argv, "aAbdDf:gHlLNn:OpRt:uw",
longopts, NULL)) != -1) {
switch (ch) {
case 'a':
aflag++;
break;
case 'A':
Aflag++;
break;
case 'b':
bflag++;
break;
case 'd':
dflag++;
break;
case 'D':
Dflag++;
break;
case 'g':
gflag++;
break;
case 'H':
Hflag++;
break;
case 'l':
lflag++;
break;
case 'L':
Lflag++;
break;
case 'n':
varname = optarg;
break;
case 'N':
Nflag++;
break;
case 'O':
load_opt_flag++;
break;
case 'p':
pflag++;
break;
case 'R':
Rflag++;
break;
case 't':
attrib = strtoul(optarg, NULL, 16);
break;
case 'u':
uflag++;
break;
case 'w':
wflag++;
break;
case 'f':
case 0:
errx(1, "unknown or unimplemented option\n");
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 1)
varname = argv[0];
if (aflag + Dflag + wflag > 1) {
warnx("Can only use one of -a (--append), "
"-D (--delete) and -w (--write)");
usage();
}
if (aflag + Dflag + wflag > 0 && varname == NULL) {
warnx("Must specify a variable for -a (--append), "
"-D (--delete) or -w (--write)");
usage();
}
if (aflag)
append_variable(varname, NULL);
else if (Dflag)
delete_variable(varname);
else if (wflag)
write_variable(varname, NULL);
else if (Lflag)
print_known_guid();
else if (varname) {
pflag++;
print_variable(varname);
} else if (argc > 0) {
pflag++;
for (i = 0; i < argc; i++)
print_variable(argv[i]);
} else
print_variables();
}
inline bool delete_variable(const string& Name) {
return delete_variable(Name.data());
}
