Merge branch 'master' of git://git.denx.de/u-boot-arm
[platform/kernel/u-boot.git] / common / env_flags.c
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.h"
15 #include <env_attr.h>
16 #include <env_flags.h>
17 #define getenv fw_getenv
18 #else
19 #include <common.h>
20 #include <environment.h>
21 #endif
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;
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
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 };
52 static const char * const env_flags_varaccess_names[] = {
53         "any",
54         "read-only",
55         "write-once",
56         "change-default",
57 };
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
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
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 }
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 }
102 #endif /* CONFIG_CMD_ENV_FLAGS */
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
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
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
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
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
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
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
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
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 {
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;
396 }
397
398 static int first_call = 1;
399 static const char *flags_list;
400
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;
409         char flags[ENV_FLAGS_ATTR_MAX_LEN + 1] = "";
410         int ret = 1;
411
412         if (first_call) {
413                 flags_list = getenv(ENV_FLAGS_VAR);
414                 first_call = 0;
415         }
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;
486         const char *oldval = NULL;
487
488         if (op != env_op_create)
489                 oldval = item->data;
490
491         name = item->key;
492
493         /* Default value for NULL to protect string-manipulating functions */
494         newval = newval ? : "";
495
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
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
547         return 0;
548 }
549
550 #endif