[people/ms/u-boot.git] / common / env_flags.c

/*
 * (C) Copyright 2012
 * Joe Hershberger, National Instruments, joe.hershberger@ni.com
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <linux/string.h>
#include <linux/ctype.h>

#ifdef USE_HOSTCC /* Eliminate "ANSI does not permit..." warnings */
#include <stdint.h>
#include <stdio.h>
#include "fw_env.h"
#include <env_attr.h>
#include <env_flags.h>
#define getenv fw_getenv
#else
#include <common.h>
#include <environment.h>
#endif

#ifdef CONFIG_CMD_NET
#define ENV_FLAGS_NET_VARTYPE_REPS "im"
#else
#define ENV_FLAGS_NET_VARTYPE_REPS ""
#endif

static const char env_flags_vartype_rep[] = "sdxb" ENV_FLAGS_NET_VARTYPE_REPS;
static const char env_flags_varaccess_rep[] = "aroc";
static const int env_flags_varaccess_mask[] = {
	0,
	ENV_FLAGS_VARACCESS_PREVENT_DELETE |
		ENV_FLAGS_VARACCESS_PREVENT_CREATE |
		ENV_FLAGS_VARACCESS_PREVENT_OVERWR,
	ENV_FLAGS_VARACCESS_PREVENT_DELETE |
		ENV_FLAGS_VARACCESS_PREVENT_OVERWR,
	ENV_FLAGS_VARACCESS_PREVENT_DELETE |
		ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR};

#ifdef CONFIG_CMD_ENV_FLAGS
static const char * const env_flags_vartype_names[] = {
	"string",
	"decimal",
	"hexadecimal",
	"boolean",
#ifdef CONFIG_CMD_NET
	"IP address",
	"MAC address",
#endif
};
static const char * const env_flags_varaccess_names[] = {
	"any",
	"read-only",
	"write-once",
	"change-default",
};

/*
 * Print the whole list of available type flags.
 */
void env_flags_print_vartypes(void)
{
	enum env_flags_vartype curtype = (enum env_flags_vartype)0;

	while (curtype != env_flags_vartype_end) {
		printf("\t%c   -\t%s\n", env_flags_vartype_rep[curtype],
			env_flags_vartype_names[curtype]);
		curtype++;
	}
}

/*
 * Print the whole list of available access flags.
 */
void env_flags_print_varaccess(void)
{
	enum env_flags_varaccess curaccess = (enum env_flags_varaccess)0;

	while (curaccess != env_flags_varaccess_end) {
		printf("\t%c   -\t%s\n", env_flags_varaccess_rep[curaccess],
			env_flags_varaccess_names[curaccess]);
		curaccess++;
	}
}

/*
 * Return the name of the type.
 */
const char *env_flags_get_vartype_name(enum env_flags_vartype type)
{
	return env_flags_vartype_names[type];
}

/*
 * Return the name of the access.
 */
const char *env_flags_get_varaccess_name(enum env_flags_varaccess access)
{
	return env_flags_varaccess_names[access];
}
#endif /* CONFIG_CMD_ENV_FLAGS */

/*
 * Parse the flags string from a .flags attribute list into the vartype enum.
 */
enum env_flags_vartype env_flags_parse_vartype(const char *flags)
{
	char *type;

	if (strlen(flags) <= ENV_FLAGS_VARTYPE_LOC)
		return env_flags_vartype_string;

	type = strchr(env_flags_vartype_rep,
		flags[ENV_FLAGS_VARTYPE_LOC]);

	if (type != NULL)
		return (enum env_flags_vartype)
			(type - &env_flags_vartype_rep[0]);

	printf("## Warning: Unknown environment variable type '%c'\n",
		flags[ENV_FLAGS_VARTYPE_LOC]);
	return env_flags_vartype_string;
}

/*
 * Parse the flags string from a .flags attribute list into the varaccess enum.
 */
enum env_flags_varaccess env_flags_parse_varaccess(const char *flags)
{
	char *access;

	if (strlen(flags) <= ENV_FLAGS_VARACCESS_LOC)
		return env_flags_varaccess_any;

	access = strchr(env_flags_varaccess_rep,
		flags[ENV_FLAGS_VARACCESS_LOC]);

	if (access != NULL)
		return (enum env_flags_varaccess)
			(access - &env_flags_varaccess_rep[0]);

	printf("## Warning: Unknown environment variable access method '%c'\n",
		flags[ENV_FLAGS_VARACCESS_LOC]);
	return env_flags_varaccess_any;
}

/*
 * Parse the binary flags from a hash table entry into the varaccess enum.
 */
enum env_flags_varaccess env_flags_parse_varaccess_from_binflags(int binflags)
{
	int i;

	for (i = 0; i < sizeof(env_flags_varaccess_mask); i++)
		if (env_flags_varaccess_mask[i] ==
		    (binflags & ENV_FLAGS_VARACCESS_BIN_MASK))
			return (enum env_flags_varaccess)i;

	printf("Warning: Non-standard access flags. (0x%x)\n",
		binflags & ENV_FLAGS_VARACCESS_BIN_MASK);

	return env_flags_varaccess_any;
}

static inline int is_hex_prefix(const char *value)
{
	return value[0] == '0' && (value[1] == 'x' || value[1] == 'X');
}

static void skip_num(int hex, const char *value, const char **end,
	int max_digits)
{
	int i;

	if (hex && is_hex_prefix(value))
		value += 2;

	for (i = max_digits; i != 0; i--) {
		if (hex && !isxdigit(*value))
			break;
		if (!hex && !isdigit(*value))
			break;
		value++;
	}
	if (end != NULL)
		*end = value;
}

/*
 * Based on the declared type enum, validate that the value string complies
 * with that format
 */
static int _env_flags_validate_type(const char *value,
	enum env_flags_vartype type)
{
	const char *end;
#ifdef CONFIG_CMD_NET
	const char *cur;
	int i;
#endif

	switch (type) {
	case env_flags_vartype_string:
		break;
	case env_flags_vartype_decimal:
		skip_num(0, value, &end, -1);
		if (*end != '\0')
			return -1;
		break;
	case env_flags_vartype_hex:
		skip_num(1, value, &end, -1);
		if (*end != '\0')
			return -1;
		if (value + 2 == end && is_hex_prefix(value))
			return -1;
		break;
	case env_flags_vartype_bool:
		if (value[0] != '1' && value[0] != 'y' && value[0] != 't' &&
		    value[0] != 'Y' && value[0] != 'T' &&
		    value[0] != '0' && value[0] != 'n' && value[0] != 'f' &&
		    value[0] != 'N' && value[0] != 'F')
			return -1;
		if (value[1] != '\0')
			return -1;
		break;
#ifdef CONFIG_CMD_NET
	case env_flags_vartype_ipaddr:
		cur = value;
		for (i = 0; i < 4; i++) {
			skip_num(0, cur, &end, 3);
			if (cur == end)
				return -1;
			if (i != 3 && *end != '.')
				return -1;
			if (i == 3 && *end != '\0')
				return -1;
			cur = end + 1;
		}
		break;
	case env_flags_vartype_macaddr:
		cur = value;
		for (i = 0; i < 6; i++) {
			skip_num(1, cur, &end, 2);
			if (cur == end)
				return -1;
			if (cur + 2 == end && is_hex_prefix(cur))
				return -1;
			if (i != 5 && *end != ':')
				return -1;
			if (i == 5 && *end != '\0')
				return -1;
			cur = end + 1;
		}
		break;
#endif
	case env_flags_vartype_end:
		return -1;
	}

	/* OK */
	return 0;
}

/*
 * Look for flags in a provided list and failing that the static list
 */
static inline int env_flags_lookup(const char *flags_list, const char *name,
	char *flags)
{
	int ret = 1;

	if (!flags)
		/* bad parameter */
		return -1;

	/* try the env first */
	if (flags_list)
		ret = env_attr_lookup(flags_list, name, flags);

	if (ret != 0)
		/* if not found in the env, look in the static list */
		ret = env_attr_lookup(ENV_FLAGS_LIST_STATIC, name, flags);

	return ret;
}

#ifdef USE_HOSTCC /* Functions only used from tools/env */
/*
 * Look up any flags directly from the .flags variable and the static list
 * and convert them to the vartype enum.
 */
enum env_flags_vartype env_flags_get_type(const char *name)
{
	const char *flags_list = getenv(ENV_FLAGS_VAR);
	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1];

	if (env_flags_lookup(flags_list, name, flags))
		return env_flags_vartype_string;

	if (strlen(flags) <= ENV_FLAGS_VARTYPE_LOC)
		return env_flags_vartype_string;

	return env_flags_parse_vartype(flags);
}

/*
 * Look up the access of a variable directly from the .flags var.
 */
enum env_flags_varaccess env_flags_get_varaccess(const char *name)
{
	const char *flags_list = getenv(ENV_FLAGS_VAR);
	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1];

	if (env_flags_lookup(flags_list, name, flags))
		return env_flags_varaccess_any;

	if (strlen(flags) <= ENV_FLAGS_VARACCESS_LOC)
		return env_flags_varaccess_any;

	return env_flags_parse_varaccess(flags);
}

/*
 * Validate that the proposed new value for "name" is valid according to the
 * defined flags for that variable, if any.
 */
int env_flags_validate_type(const char *name, const char *value)
{
	enum env_flags_vartype type;

	if (value == NULL)
		return 0;
	type = env_flags_get_type(name);
	if (_env_flags_validate_type(value, type) < 0) {
		printf("## Error: flags type check failure for "
			"\"%s\" <= \"%s\" (type: %c)\n",
			name, value, env_flags_vartype_rep[type]);
		return -1;
	}
	return 0;
}

/*
 * Validate that the proposed access to variable "name" is valid according to
 * the defined flags for that variable, if any.
 */
int env_flags_validate_varaccess(const char *name, int check_mask)
{
	enum env_flags_varaccess access;
	int access_mask;

	access = env_flags_get_varaccess(name);
	access_mask = env_flags_varaccess_mask[access];

	return (check_mask & access_mask) != 0;
}

/*
 * Validate the parameters to "env set" directly
 */
int env_flags_validate_env_set_params(int argc, char * const argv[])
{
	if ((argc >= 3) && argv[2] != NULL) {
		enum env_flags_vartype type = env_flags_get_type(argv[1]);

		/*
		 * we don't currently check types that need more than
		 * one argument
		 */
		if (type != env_flags_vartype_string && argc > 3) {
			printf("## Error: too many parameters for setting "
				"\"%s\"\n", argv[1]);
			return -1;
		}
		return env_flags_validate_type(argv[1], argv[2]);
	}
	/* ok */
	return 0;
}

#else /* !USE_HOSTCC - Functions only used from lib/hashtable.c */

/*
 * Parse the flag charachters from the .flags attribute list into the binary
 * form to be stored in the environment entry->flags field.
 */
static int env_parse_flags_to_bin(const char *flags)
{
	int binflags;

	binflags = env_flags_parse_vartype(flags) & ENV_FLAGS_VARTYPE_BIN_MASK;
	binflags |= env_flags_varaccess_mask[env_flags_parse_varaccess(flags)];

	return binflags;
}

static int first_call = 1;
static const char *flags_list;

/*
 * Look for possible flags for a newly added variable
 * This is called specifically when the variable did not exist in the hash
 * previously, so the blanket update did not find this variable.
 */
void env_flags_init(ENTRY *var_entry)
{
	const char *var_name = var_entry->key;
	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1] = "";
	int ret = 1;

	if (first_call) {
		flags_list = getenv(ENV_FLAGS_VAR);
		first_call = 0;
	}
	/* look in the ".flags" and static for a reference to this variable */
	ret = env_flags_lookup(flags_list, var_name, flags);

	/* if any flags were found, set the binary form to the entry */
	if (!ret && strlen(flags))
		var_entry->flags = env_parse_flags_to_bin(flags);
}

/*
 * Called on each existing env var prior to the blanket update since removing
 * a flag in the flag list should remove its flags.
 */
static int clear_flags(ENTRY *entry)
{
	entry->flags = 0;

	return 0;
}

/*
 * Call for each element in the list that defines flags for a variable
 */
static int set_flags(const char *name, const char *value)
{
	ENTRY e, *ep;

	e.key	= name;
	e.data	= NULL;
	hsearch_r(e, FIND, &ep, &env_htab, 0);

	/* does the env variable actually exist? */
	if (ep != NULL) {
		/* the flag list is empty, so clear the flags */
		if (value == NULL || strlen(value) == 0)
			ep->flags = 0;
		else
			/* assign the requested flags */
			ep->flags = env_parse_flags_to_bin(value);
	}

	return 0;
}

static int on_flags(const char *name, const char *value, enum env_op op,
	int flags)
{
	/* remove all flags */
	hwalk_r(&env_htab, clear_flags);

	/* configure any static flags */
	env_attr_walk(ENV_FLAGS_LIST_STATIC, set_flags);
	/* configure any dynamic flags */
	env_attr_walk(value, set_flags);

	return 0;
}
U_BOOT_ENV_CALLBACK(flags, on_flags);

/*
 * Perform consistency checking before creating, overwriting, or deleting an
 * environment variable. Called as a callback function by hsearch_r() and
 * hdelete_r(). Returns 0 in case of success, 1 in case of failure.
 * When (flag & H_FORCE) is set, do not print out any error message and force
 * overwriting of write-once variables.
 */

int env_flags_validate(const ENTRY *item, const char *newval, enum env_op op,
	int flag)
{
	const char *name;
	const char *oldval = NULL;

	if (op != env_op_create)
		oldval = item->data;

	name = item->key;

	/* Default value for NULL to protect string-manipulating functions */
	newval = newval ? : "";

	/* validate the value to match the variable type */
	if (op != env_op_delete) {
		enum env_flags_vartype type = (enum env_flags_vartype)
			(ENV_FLAGS_VARTYPE_BIN_MASK & item->flags);

		if (_env_flags_validate_type(newval, type) < 0) {
			printf("## Error: flags type check failure for "
				"\"%s\" <= \"%s\" (type: %c)\n",
				name, newval, env_flags_vartype_rep[type]);
			return -1;
		}
	}

	/* check for access permission */
#ifndef CONFIG_ENV_ACCESS_IGNORE_FORCE
	if (flag & H_FORCE)
		return 0;
#endif
	switch (op) {
	case env_op_delete:
		if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_DELETE) {
			printf("## Error: Can't delete \"%s\"\n", name);
			return 1;
		}
		break;
	case env_op_overwrite:
		if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_OVERWR) {
			printf("## Error: Can't overwrite \"%s\"\n", name);
			return 1;
		} else if (item->flags &
		    ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR) {
			const char *defval = getenv_default(name);

			if (defval == NULL)
				defval = "";
			printf("oldval: %s  defval: %s\n", oldval, defval);
			if (strcmp(oldval, defval) != 0) {
				printf("## Error: Can't overwrite \"%s\"\n",
					name);
				return 1;
			}
		}
		break;
	case env_op_create:
		if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_CREATE) {
			printf("## Error: Can't create \"%s\"\n", name);
			return 1;
		}
		break;
	}

	return 0;
}

#endif
Commit	Line	Data
2598090b JH	1	/*
	2	* (C) Copyright 2012
	3	* Joe Hershberger, National Instruments, joe.hershberger@ni.com
	4	*
1a459660	5	* SPDX-License-Identifier: GPL-2.0+
2598090b JH	6	*/
	7
	8	#include <linux/string.h>
	9	#include <linux/ctype.h>
	10
30fd4fad JH	11	#ifdef USE_HOSTCC /* Eliminate "ANSI does not permit..." warnings */
	12	#include <stdint.h>
	13	#include <stdio.h>
	14	#include "fw_env.h"
	15	#include <env_attr.h>
	16	#include <env_flags.h>
	17	#define getenv fw_getenv
	18	#else
2598090b JH	19	#include <common.h>
2598090b JH	20	#include <environment.h>
30fd4fad	21	#endif
2598090b JH	22
	23	#ifdef CONFIG_CMD_NET
	24	#define ENV_FLAGS_NET_VARTYPE_REPS "im"
	25	#else
	26	#define ENV_FLAGS_NET_VARTYPE_REPS ""
	27	#endif
	28
	29	static const char env_flags_vartype_rep[] = "sdxb" ENV_FLAGS_NET_VARTYPE_REPS;
267541f7 JH	30	static const char env_flags_varaccess_rep[] = "aroc";
	31	static const int env_flags_varaccess_mask[] = {
	32	0,
	33	ENV_FLAGS_VARACCESS_PREVENT_DELETE \|
	34	ENV_FLAGS_VARACCESS_PREVENT_CREATE \|
	35	ENV_FLAGS_VARACCESS_PREVENT_OVERWR,
	36	ENV_FLAGS_VARACCESS_PREVENT_DELETE \|
	37	ENV_FLAGS_VARACCESS_PREVENT_OVERWR,
	38	ENV_FLAGS_VARACCESS_PREVENT_DELETE \|
	39	ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR};
	40
fffad71b JH	41	#ifdef CONFIG_CMD_ENV_FLAGS
	42	static const char * const env_flags_vartype_names[] = {
	43	"string",
	44	"decimal",
	45	"hexadecimal",
	46	"boolean",
	47	#ifdef CONFIG_CMD_NET
	48	"IP address",
	49	"MAC address",
	50	#endif
	51	};
267541f7 JH	52	static const char * const env_flags_varaccess_names[] = {
	53	"any",
	54	"read-only",
	55	"write-once",
	56	"change-default",
	57	};
fffad71b JH	58
	59	/*
	60	* Print the whole list of available type flags.
	61	*/
	62	void env_flags_print_vartypes(void)
	63	{
	64	enum env_flags_vartype curtype = (enum env_flags_vartype)0;
	65
	66	while (curtype != env_flags_vartype_end) {
	67	printf("\t%c -\t%s\n", env_flags_vartype_rep[curtype],
	68	env_flags_vartype_names[curtype]);
	69	curtype++;
	70	}
	71	}
	72
267541f7 JH	73	/*
	74	* Print the whole list of available access flags.
	75	*/
	76	void env_flags_print_varaccess(void)
	77	{
	78	enum env_flags_varaccess curaccess = (enum env_flags_varaccess)0;
	79
	80	while (curaccess != env_flags_varaccess_end) {
	81	printf("\t%c -\t%s\n", env_flags_varaccess_rep[curaccess],
	82	env_flags_varaccess_names[curaccess]);
	83	curaccess++;
	84	}
	85	}
	86
fffad71b JH	87	/*
	88	* Return the name of the type.
	89	*/
	90	const char *env_flags_get_vartype_name(enum env_flags_vartype type)
	91	{
	92	return env_flags_vartype_names[type];
	93	}
267541f7 JH	94
	95	/*
	96	* Return the name of the access.
	97	*/
	98	const char *env_flags_get_varaccess_name(enum env_flags_varaccess access)
	99	{
	100	return env_flags_varaccess_names[access];
	101	}
fffad71b	102	#endif /* CONFIG_CMD_ENV_FLAGS */
2598090b JH	103
	104	/*
	105	* Parse the flags string from a .flags attribute list into the vartype enum.
	106	*/
	107	enum env_flags_vartype env_flags_parse_vartype(const char *flags)
	108	{
	109	char *type;
	110
	111	if (strlen(flags) <= ENV_FLAGS_VARTYPE_LOC)
	112	return env_flags_vartype_string;
	113
	114	type = strchr(env_flags_vartype_rep,
	115	flags[ENV_FLAGS_VARTYPE_LOC]);
	116
	117	if (type != NULL)
	118	return (enum env_flags_vartype)
	119	(type - &env_flags_vartype_rep[0]);
	120
	121	printf("## Warning: Unknown environment variable type '%c'\n",
	122	flags[ENV_FLAGS_VARTYPE_LOC]);
	123	return env_flags_vartype_string;
	124	}
	125
267541f7 JH	126	/*
	127	* Parse the flags string from a .flags attribute list into the varaccess enum.
	128	*/
	129	enum env_flags_varaccess env_flags_parse_varaccess(const char *flags)
	130	{
	131	char *access;
	132
	133	if (strlen(flags) <= ENV_FLAGS_VARACCESS_LOC)
	134	return env_flags_varaccess_any;
	135
	136	access = strchr(env_flags_varaccess_rep,
	137	flags[ENV_FLAGS_VARACCESS_LOC]);
	138
	139	if (access != NULL)
	140	return (enum env_flags_varaccess)
	141	(access - &env_flags_varaccess_rep[0]);
	142
	143	printf("## Warning: Unknown environment variable access method '%c'\n",
	144	flags[ENV_FLAGS_VARACCESS_LOC]);
	145	return env_flags_varaccess_any;
	146	}
	147
	148	/*
	149	* Parse the binary flags from a hash table entry into the varaccess enum.
	150	*/
	151	enum env_flags_varaccess env_flags_parse_varaccess_from_binflags(int binflags)
	152	{
	153	int i;
	154
	155	for (i = 0; i < sizeof(env_flags_varaccess_mask); i++)
	156	if (env_flags_varaccess_mask[i] ==
	157	(binflags & ENV_FLAGS_VARACCESS_BIN_MASK))
	158	return (enum env_flags_varaccess)i;
	159
	160	printf("Warning: Non-standard access flags. (0x%x)\n",
	161	binflags & ENV_FLAGS_VARACCESS_BIN_MASK);
	162
	163	return env_flags_varaccess_any;
	164	}
	165
2598090b JH	166	static inline int is_hex_prefix(const char *value)
	167	{
	168	return value[0] == '0' && (value[1] == 'x' \|\| value[1] == 'X');
	169	}
	170
	171	static void skip_num(int hex, const char value, const char *end,
	172	int max_digits)
	173	{
	174	int i;
	175
	176	if (hex && is_hex_prefix(value))
	177	value += 2;
	178
	179	for (i = max_digits; i != 0; i--) {
	180	if (hex && !isxdigit(*value))
	181	break;
	182	if (!hex && !isdigit(*value))
	183	break;
	184	value++;
	185	}
	186	if (end != NULL)
	187	*end = value;
	188	}
	189
	190	/*
	191	* Based on the declared type enum, validate that the value string complies
	192	* with that format
	193	*/
	194	static int _env_flags_validate_type(const char *value,
	195	enum env_flags_vartype type)
	196	{
	197	const char *end;
	198	#ifdef CONFIG_CMD_NET
	199	const char *cur;
	200	int i;
	201	#endif
	202
	203	switch (type) {
	204	case env_flags_vartype_string:
	205	break;
	206	case env_flags_vartype_decimal:
	207	skip_num(0, value, &end, -1);
	208	if (*end != '\0')
	209	return -1;
	210	break;
	211	case env_flags_vartype_hex:
	212	skip_num(1, value, &end, -1);
	213	if (*end != '\0')
	214	return -1;
	215	if (value + 2 == end && is_hex_prefix(value))
	216	return -1;
	217	break;
	218	case env_flags_vartype_bool:
	219	if (value[0] != '1' && value[0] != 'y' && value[0] != 't' &&
	220	value[0] != 'Y' && value[0] != 'T' &&
	221	value[0] != '0' && value[0] != 'n' && value[0] != 'f' &&
	222	value[0] != 'N' && value[0] != 'F')
	223	return -1;
	224	if (value[1] != '\0')
	225	return -1;
	226	break;
	227	#ifdef CONFIG_CMD_NET
	228	case env_flags_vartype_ipaddr:
	229	cur = value;
230	for (i = 0; i < 4; i++) {
231	skip_num(0, cur, &end, 3);
232	if (cur == end)
233	return -1;
234	if (i != 3 && *end != '.')
235	return -1;
236	if (i == 3 && *end != '\0')
237	return -1;
238	cur = end + 1;
239	}
240	break;
241	case env_flags_vartype_macaddr:
242	cur = value;
243	for (i = 0; i < 6; i++) {
244	skip_num(1, cur, &end, 2);
245	if (cur == end)
246	return -1;
247	if (cur + 2 == end && is_hex_prefix(cur))
248	return -1;
249	if (i != 5 && *end != ':')
250	return -1;
251	if (i == 5 && *end != '\0')
252	return -1;
253	cur = end + 1;
254	}
255	break;
256	#endif
257	case env_flags_vartype_end:
258	return -1;
259	}
260
261	/* OK */
262	return 0;
263	}
264
265	/*
266	* Look for flags in a provided list and failing that the static list
267	*/
268	static inline int env_flags_lookup(const char flags_list, const char name,
269	char *flags)
270	{
271	int ret = 1;
272
273	if (!flags)
274	/* bad parameter */
275	return -1;
276
277	/* try the env first */
278	if (flags_list)
279	ret = env_attr_lookup(flags_list, name, flags);
280
281	if (ret != 0)
282	/* if not found in the env, look in the static list */
283	ret = env_attr_lookup(ENV_FLAGS_LIST_STATIC, name, flags);
284
285	return ret;
286	}
287
30fd4fad JH	288	#ifdef USE_HOSTCC /* Functions only used from tools/env */
	289	/*
	290	* Look up any flags directly from the .flags variable and the static list
	291	* and convert them to the vartype enum.
	292	*/
	293	enum env_flags_vartype env_flags_get_type(const char *name)
	294	{
	295	const char *flags_list = getenv(ENV_FLAGS_VAR);
	296	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1];
	297
	298	if (env_flags_lookup(flags_list, name, flags))
	299	return env_flags_vartype_string;
	300
	301	if (strlen(flags) <= ENV_FLAGS_VARTYPE_LOC)
	302	return env_flags_vartype_string;
	303
	304	return env_flags_parse_vartype(flags);
	305	}
	306
267541f7 JH	307	/*
	308	* Look up the access of a variable directly from the .flags var.
	309	*/
	310	enum env_flags_varaccess env_flags_get_varaccess(const char *name)
	311	{
	312	const char *flags_list = getenv(ENV_FLAGS_VAR);
	313	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1];
	314
	315	if (env_flags_lookup(flags_list, name, flags))
	316	return env_flags_varaccess_any;
	317
	318	if (strlen(flags) <= ENV_FLAGS_VARACCESS_LOC)
	319	return env_flags_varaccess_any;
	320
	321	return env_flags_parse_varaccess(flags);
	322	}
	323
30fd4fad JH	324	/*
	325	* Validate that the proposed new value for "name" is valid according to the
	326	* defined flags for that variable, if any.
	327	*/
	328	int env_flags_validate_type(const char name, const char value)
	329	{
	330	enum env_flags_vartype type;
	331
	332	if (value == NULL)
	333	return 0;
	334	type = env_flags_get_type(name);
	335	if (_env_flags_validate_type(value, type) < 0) {
	336	printf("## Error: flags type check failure for "
	337	"\"%s\" <= \"%s\" (type: %c)\n",
	338	name, value, env_flags_vartype_rep[type]);
	339	return -1;
	340	}
	341	return 0;
	342	}
	343
267541f7 JH	344	/*
	345	* Validate that the proposed access to variable "name" is valid according to
	346	* the defined flags for that variable, if any.
	347	*/
	348	int env_flags_validate_varaccess(const char *name, int check_mask)
	349	{
	350	enum env_flags_varaccess access;
	351	int access_mask;
	352
	353	access = env_flags_get_varaccess(name);
	354	access_mask = env_flags_varaccess_mask[access];
	355
	356	return (check_mask & access_mask) != 0;
	357	}
	358
30fd4fad JH	359	/*
	360	* Validate the parameters to "env set" directly
	361	*/
	362	int env_flags_validate_env_set_params(int argc, char * const argv[])
	363	{
	364	if ((argc >= 3) && argv[2] != NULL) {
	365	enum env_flags_vartype type = env_flags_get_type(argv[1]);
	366
	367	/*
	368	* we don't currently check types that need more than
	369	* one argument
	370	*/
	371	if (type != env_flags_vartype_string && argc > 3) {
	372	printf("## Error: too many parameters for setting "
	373	"\"%s\"\n", argv[1]);
	374	return -1;
	375	}
	376	return env_flags_validate_type(argv[1], argv[2]);
	377	}
	378	/* ok */
	379	return 0;
	380	}
	381
	382	#else /* !USE_HOSTCC - Functions only used from lib/hashtable.c */
	383
2598090b JH	384	/*
	385	* Parse the flag charachters from the .flags attribute list into the binary
	386	* form to be stored in the environment entry->flags field.
	387	*/
	388	static int env_parse_flags_to_bin(const char *flags)
	389	{
267541f7 JH	390	int binflags;
	391
	392	binflags = env_flags_parse_vartype(flags) & ENV_FLAGS_VARTYPE_BIN_MASK;
	393	binflags \|= env_flags_varaccess_mask[env_flags_parse_varaccess(flags)];
	394
	395	return binflags;
2598090b JH	396	}
2598090b JH	397
1b610271 HS	398	static int first_call = 1;
	399	static const char *flags_list;
	400
2598090b JH	401	/*
	402	* Look for possible flags for a newly added variable
	403	* This is called specifically when the variable did not exist in the hash
	404	* previously, so the blanket update did not find this variable.
	405	*/
	406	void env_flags_init(ENTRY *var_entry)
	407	{
	408	const char *var_name = var_entry->key;
2598090b JH	409	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1] = "";
	410	int ret = 1;
	411
1b610271 HS	412	if (first_call) {
	413	flags_list = getenv(ENV_FLAGS_VAR);
	414	first_call = 0;
	415	}
2598090b JH	416	/* look in the ".flags" and static for a reference to this variable */
	417	ret = env_flags_lookup(flags_list, var_name, flags);
	418
	419	/* if any flags were found, set the binary form to the entry */
	420	if (!ret && strlen(flags))
	421	var_entry->flags = env_parse_flags_to_bin(flags);
	422	}
	423
	424	/*
	425	* Called on each existing env var prior to the blanket update since removing
	426	* a flag in the flag list should remove its flags.
	427	*/
	428	static int clear_flags(ENTRY *entry)
	429	{
	430	entry->flags = 0;
	431
	432	return 0;
	433	}
	434
	435	/*
	436	* Call for each element in the list that defines flags for a variable
	437	*/
	438	static int set_flags(const char name, const char value)
	439	{
	440	ENTRY e, *ep;
	441
	442	e.key = name;
	443	e.data = NULL;
	444	hsearch_r(e, FIND, &ep, &env_htab, 0);
	445
	446	/* does the env variable actually exist? */
	447	if (ep != NULL) {
	448	/* the flag list is empty, so clear the flags */
	449	if (value == NULL \|\| strlen(value) == 0)
	450	ep->flags = 0;
	451	else
	452	/* assign the requested flags */
	453	ep->flags = env_parse_flags_to_bin(value);
	454	}
	455
	456	return 0;
	457	}
	458
	459	static int on_flags(const char name, const char value, enum env_op op,
	460	int flags)
	461	{
	462	/* remove all flags */
	463	hwalk_r(&env_htab, clear_flags);
	464
	465	/* configure any static flags */
	466	env_attr_walk(ENV_FLAGS_LIST_STATIC, set_flags);
	467	/* configure any dynamic flags */
	468	env_attr_walk(value, set_flags);
	469
	470	return 0;
	471	}
	472	U_BOOT_ENV_CALLBACK(flags, on_flags);
	473
	474	/*
	475	* Perform consistency checking before creating, overwriting, or deleting an
	476	* environment variable. Called as a callback function by hsearch_r() and
	477	* hdelete_r(). Returns 0 in case of success, 1 in case of failure.
	478	* When (flag & H_FORCE) is set, do not print out any error message and force
	479	* overwriting of write-once variables.
480	*/
481
482	int env_flags_validate(const ENTRY item, const char newval, enum env_op op,
483	int flag)
484	{
485	const char *name;
2598090b JH	486	const char *oldval = NULL;
	487
	488	if (op != env_op_create)
	489	oldval = item->data;
2598090b JH	490
	491	name = item->key;
	492
	493	/* Default value for NULL to protect string-manipulating functions */
	494	newval = newval ? : "";
	495
2598090b JH	496	/* validate the value to match the variable type */
	497	if (op != env_op_delete) {
	498	enum env_flags_vartype type = (enum env_flags_vartype)
	499	(ENV_FLAGS_VARTYPE_BIN_MASK & item->flags);
	500
	501	if (_env_flags_validate_type(newval, type) < 0) {
	502	printf("## Error: flags type check failure for "
	503	"\"%s\" <= \"%s\" (type: %c)\n",
	504	name, newval, env_flags_vartype_rep[type]);
	505	return -1;
	506	}
	507	}
	508
267541f7 JH	509	/* check for access permission */
	510	#ifndef CONFIG_ENV_ACCESS_IGNORE_FORCE
	511	if (flag & H_FORCE)
	512	return 0;
	513	#endif
	514	switch (op) {
	515	case env_op_delete:
	516	if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_DELETE) {
	517	printf("## Error: Can't delete \"%s\"\n", name);
	518	return 1;
	519	}
	520	break;
	521	case env_op_overwrite:
	522	if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_OVERWR) {
	523	printf("## Error: Can't overwrite \"%s\"\n", name);
	524	return 1;
	525	} else if (item->flags &
	526	ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR) {
	527	const char *defval = getenv_default(name);
	528
	529	if (defval == NULL)
	530	defval = "";
	531	printf("oldval: %s defval: %s\n", oldval, defval);
	532	if (strcmp(oldval, defval) != 0) {
	533	printf("## Error: Can't overwrite \"%s\"\n",
	534	name);
	535	return 1;
	536	}
	537	}
	538	break;
	539	case env_op_create:
	540	if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_CREATE) {
	541	printf("## Error: Can't create \"%s\"\n", name);
	542	return 1;
	543	}
	544	break;
	545	}
	546
2598090b JH	547	return 0;
2598090b JH	548	}
30fd4fad JH	549
30fd4fad JH	550	#endif