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