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