[J-u-boot.git] / env / flags.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2012
 * Joe Hershberger, National Instruments, [email protected]
 */

#include <env.h>
#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_private.h"
#include "fw_env.h"
#include <env_attr.h>
#include <env_flags.h>
#define env_get fw_getenv
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#else
#include <common.h>
#include <env_internal.h>
#endif

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

#ifdef CONFIG_ENV_WRITEABLE_LIST
#define ENV_FLAGS_WRITEABLE_VARACCESS_REPS "w"
#else
#define ENV_FLAGS_WRITEABLE_VARACCESS_REPS ""
#endif

static const char env_flags_vartype_rep[] = "sdxb" ENV_FLAGS_NET_VARTYPE_REPS;
static const char env_flags_varaccess_rep[] =
	"aroc" ENV_FLAGS_WRITEABLE_VARACCESS_REPS;
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_ENV_WRITEABLE_LIST
	ENV_FLAGS_VARACCESS_WRITEABLE,
#endif
	};

#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",
#ifdef CONFIG_ENV_WRITEABLE_LIST
	"writeable",
#endif
};

/*
 * 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)
{
	enum env_flags_varaccess va_default = env_flags_varaccess_any;
	enum env_flags_varaccess va;
	char *access;

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

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

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

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

/*
 * 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)
{
	enum env_flags_varaccess va_default = env_flags_varaccess_any;
	enum env_flags_varaccess va;
	int i;

	for (i = 0; i < ARRAY_SIZE(env_flags_varaccess_mask); i++)
		if (env_flags_varaccess_mask[i] ==
		    (binflags & ENV_FLAGS_VARACCESS_BIN_MASK)) {
			va = (enum env_flags_varaccess)i;
			return va;
	}

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

	return va_default;
}

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;
}

#ifdef CONFIG_CMD_NET
int eth_validate_ethaddr_str(const char *addr)
{
	const char *end;
	const char *cur;
	int i;

	cur = addr;
	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;
	}

	return 0;
}
#endif

/*
 * 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:
		if (eth_validate_ethaddr_str(value))
			return -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 = env_get(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 = env_get(ENV_FLAGS_VAR);
	enum env_flags_varaccess va_default = env_flags_varaccess_any;
	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1];

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

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

	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(char *name, char * const val[], int count)
{
	if ((count >= 1) && val[0] != NULL) {
		enum env_flags_vartype type = env_flags_get_type(name);

		/*
		 * we don't currently check types that need more than
		 * one argument
		 */
		if (type != env_flags_vartype_string && count > 1) {
			printf("## Error: too many parameters for setting \"%s\"\n",
			       name);
			return -1;
		}
		return env_flags_validate_type(name, val[0]);
	}
	/* 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(struct env_entry *var_entry)
{
	const char *var_name = var_entry->key;
	char flags[ENV_FLAGS_ATTR_MAX_LEN + 1] = "";
	int ret = 1;

	if (first_call) {
#ifdef CONFIG_ENV_WRITEABLE_LIST
		flags_list = ENV_FLAGS_LIST_STATIC;
#else
		flags_list = env_get(ENV_FLAGS_VAR);
#endif
		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(struct env_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, void *priv)
{
	struct env_entry e, *ep;

	e.key	= name;
	e.data	= NULL;
	hsearch_r(e, ENV_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, NULL);
	/* configure any dynamic flags */
	env_attr_walk(value, set_flags, NULL);

	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 struct env_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 */
#ifdef CONFIG_ENV_WRITEABLE_LIST
	if (flag & H_DEFAULT)
		return 0;	/* Default env is always OK */

	/*
	 * External writeable variables can be overwritten by external env,
	 * anything else can not be overwritten by external env.
	 */
	if ((flag & H_EXTERNAL) &&
	    !(item->flags & ENV_FLAGS_VARACCESS_WRITEABLE))
		return 1;
#endif

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