Merge branch 'u-boot-imx/master' into 'u-boot-arm/master'
[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  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <linux/string.h>
25 #include <linux/ctype.h>
26
27 #ifdef USE_HOSTCC /* Eliminate "ANSI does not permit..." warnings */
28 #include <stdint.h>
29 #include <stdio.h>
30 #include "fw_env.h"
31 #include <env_attr.h>
32 #include <env_flags.h>
33 #define getenv fw_getenv
34 #else
35 #include <common.h>
36 #include <environment.h>
37 #endif
38
39 #ifdef CONFIG_CMD_NET
40 #define ENV_FLAGS_NET_VARTYPE_REPS "im"
41 #else
42 #define ENV_FLAGS_NET_VARTYPE_REPS ""
43 #endif
44
45 static const char env_flags_vartype_rep[] = "sdxb" ENV_FLAGS_NET_VARTYPE_REPS;
46 static const char env_flags_varaccess_rep[] = "aroc";
47 static const int env_flags_varaccess_mask[] = {
48         0,
49         ENV_FLAGS_VARACCESS_PREVENT_DELETE |
50                 ENV_FLAGS_VARACCESS_PREVENT_CREATE |
51                 ENV_FLAGS_VARACCESS_PREVENT_OVERWR,
52         ENV_FLAGS_VARACCESS_PREVENT_DELETE |
53                 ENV_FLAGS_VARACCESS_PREVENT_OVERWR,
54         ENV_FLAGS_VARACCESS_PREVENT_DELETE |
55                 ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR};
56
57 #ifdef CONFIG_CMD_ENV_FLAGS
58 static const char * const env_flags_vartype_names[] = {
59         "string",
60         "decimal",
61         "hexadecimal",
62         "boolean",
63 #ifdef CONFIG_CMD_NET
64         "IP address",
65         "MAC address",
66 #endif
67 };
68 static const char * const env_flags_varaccess_names[] = {
69         "any",
70         "read-only",
71         "write-once",
72         "change-default",
73 };
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
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
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 }
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 }
118 #endif /* CONFIG_CMD_ENV_FLAGS */
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
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 {
147         char *access;
148
149         if (strlen(flags) <= ENV_FLAGS_VARACCESS_LOC)
150                 return env_flags_varaccess_any;
151
152         access = strchr(env_flags_varaccess_rep,
153                 flags[ENV_FLAGS_VARACCESS_LOC]);
154
155         if (access != NULL)
156                 return (enum env_flags_varaccess)
157                         (access - &env_flags_varaccess_rep[0]);
158
159         printf("## Warning: Unknown environment variable access method '%c'\n",
160                 flags[ENV_FLAGS_VARACCESS_LOC]);
161         return env_flags_varaccess_any;
162 }
163
164 /*
165  * Parse the binary flags from a hash table entry into the varaccess enum.
166  */
167 enum env_flags_varaccess env_flags_parse_varaccess_from_binflags(int binflags)
168 {
169         int i;
170
171         for (i = 0; i < sizeof(env_flags_varaccess_mask); i++)
172                 if (env_flags_varaccess_mask[i] ==
173                     (binflags & ENV_FLAGS_VARACCESS_BIN_MASK))
174                         return (enum env_flags_varaccess)i;
175
176         printf("Warning: Non-standard access flags. (0x%x)\n",
177                 binflags & ENV_FLAGS_VARACCESS_BIN_MASK);
178
179         return env_flags_varaccess_any;
180 }
181
182 static inline int is_hex_prefix(const char *value)
183 {
184         return value[0] == '0' && (value[1] == 'x' || value[1] == 'X');
185 }
186
187 static void skip_num(int hex, const char *value, const char **end,
188         int max_digits)
189 {
190         int i;
191
192         if (hex && is_hex_prefix(value))
193                 value += 2;
194
195         for (i = max_digits; i != 0; i--) {
196                 if (hex && !isxdigit(*value))
197                         break;
198                 if (!hex && !isdigit(*value))
199                         break;
200                 value++;
201         }
202         if (end != NULL)
203                 *end = value;
204 }
205
206 /*
207  * Based on the declared type enum, validate that the value string complies
208  * with that format
209  */
210 static int _env_flags_validate_type(const char *value,
211         enum env_flags_vartype type)
212 {
213         const char *end;
214 #ifdef CONFIG_CMD_NET
215         const char *cur;
216         int i;
217 #endif
218
219         switch (type) {
220         case env_flags_vartype_string:
221                 break;
222         case env_flags_vartype_decimal:
223                 skip_num(0, value, &end, -1);
224                 if (*end != '\0')
225                         return -1;
226                 break;
227         case env_flags_vartype_hex:
228                 skip_num(1, value, &end, -1);
229                 if (*end != '\0')
230                         return -1;
231                 if (value + 2 == end && is_hex_prefix(value))
232                         return -1;
233                 break;
234         case env_flags_vartype_bool:
235                 if (value[0] != '1' && value[0] != 'y' && value[0] != 't' &&
236                     value[0] != 'Y' && value[0] != 'T' &&
237                     value[0] != '0' && value[0] != 'n' && value[0] != 'f' &&
238                     value[0] != 'N' && value[0] != 'F')
239                         return -1;
240                 if (value[1] != '\0')
241                         return -1;
242                 break;
243 #ifdef CONFIG_CMD_NET
244         case env_flags_vartype_ipaddr:
245                 cur = value;
246                 for (i = 0; i < 4; i++) {
247                         skip_num(0, cur, &end, 3);
248                         if (cur == end)
249                                 return -1;
250                         if (i != 3 && *end != '.')
251                                 return -1;
252                         if (i == 3 && *end != '\0')
253                                 return -1;
254                         cur = end + 1;
255                 }
256                 break;
257         case env_flags_vartype_macaddr:
258                 cur = value;
259                 for (i = 0; i < 6; i++) {
260                         skip_num(1, cur, &end, 2);
261                         if (cur == end)
262                                 return -1;
263                         if (cur + 2 == end && is_hex_prefix(cur))
264                                 return -1;
265                         if (i != 5 && *end != ':')
266                                 return -1;
267                         if (i == 5 && *end != '\0')
268                                 return -1;
269                         cur = end + 1;
270                 }
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 = getenv(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 = getenv(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(int argc, char * const argv[])
379 {
380         if ((argc >= 3) && argv[2] != NULL) {
381                 enum env_flags_vartype type = env_flags_get_type(argv[1]);
382
383                 /*
384                  * we don't currently check types that need more than
385                  * one argument
386                  */
387                 if (type != env_flags_vartype_string && argc > 3) {
388                         printf("## Error: too many parameters for setting "
389                                 "\"%s\"\n", argv[1]);
390                         return -1;
391                 }
392                 return env_flags_validate_type(argv[1], argv[2]);
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 /*
415  * Look for possible flags for a newly added variable
416  * This is called specifically when the variable did not exist in the hash
417  * previously, so the blanket update did not find this variable.
418  */
419 void env_flags_init(ENTRY *var_entry)
420 {
421         const char *var_name = var_entry->key;
422         const char *flags_list = getenv(ENV_FLAGS_VAR);
423         char flags[ENV_FLAGS_ATTR_MAX_LEN + 1] = "";
424         int ret = 1;
425
426         /* look in the ".flags" and static for a reference to this variable */
427         ret = env_flags_lookup(flags_list, var_name, flags);
428
429         /* if any flags were found, set the binary form to the entry */
430         if (!ret && strlen(flags))
431                 var_entry->flags = env_parse_flags_to_bin(flags);
432 }
433
434 /*
435  * Called on each existing env var prior to the blanket update since removing
436  * a flag in the flag list should remove its flags.
437  */
438 static int clear_flags(ENTRY *entry)
439 {
440         entry->flags = 0;
441
442         return 0;
443 }
444
445 /*
446  * Call for each element in the list that defines flags for a variable
447  */
448 static int set_flags(const char *name, const char *value)
449 {
450         ENTRY e, *ep;
451
452         e.key   = name;
453         e.data  = NULL;
454         hsearch_r(e, FIND, &ep, &env_htab, 0);
455
456         /* does the env variable actually exist? */
457         if (ep != NULL) {
458                 /* the flag list is empty, so clear the flags */
459                 if (value == NULL || strlen(value) == 0)
460                         ep->flags = 0;
461                 else
462                         /* assign the requested flags */
463                         ep->flags = env_parse_flags_to_bin(value);
464         }
465
466         return 0;
467 }
468
469 static int on_flags(const char *name, const char *value, enum env_op op,
470         int flags)
471 {
472         /* remove all flags */
473         hwalk_r(&env_htab, clear_flags);
474
475         /* configure any static flags */
476         env_attr_walk(ENV_FLAGS_LIST_STATIC, set_flags);
477         /* configure any dynamic flags */
478         env_attr_walk(value, set_flags);
479
480         return 0;
481 }
482 U_BOOT_ENV_CALLBACK(flags, on_flags);
483
484 /*
485  * Perform consistency checking before creating, overwriting, or deleting an
486  * environment variable. Called as a callback function by hsearch_r() and
487  * hdelete_r(). Returns 0 in case of success, 1 in case of failure.
488  * When (flag & H_FORCE) is set, do not print out any error message and force
489  * overwriting of write-once variables.
490  */
491
492 int env_flags_validate(const ENTRY *item, const char *newval, enum env_op op,
493         int flag)
494 {
495         const char *name;
496         const char *oldval = NULL;
497
498         if (op != env_op_create)
499                 oldval = item->data;
500
501         name = item->key;
502
503         /* Default value for NULL to protect string-manipulating functions */
504         newval = newval ? : "";
505
506         /* validate the value to match the variable type */
507         if (op != env_op_delete) {
508                 enum env_flags_vartype type = (enum env_flags_vartype)
509                         (ENV_FLAGS_VARTYPE_BIN_MASK & item->flags);
510
511                 if (_env_flags_validate_type(newval, type) < 0) {
512                         printf("## Error: flags type check failure for "
513                                 "\"%s\" <= \"%s\" (type: %c)\n",
514                                 name, newval, env_flags_vartype_rep[type]);
515                         return -1;
516                 }
517         }
518
519         /* check for access permission */
520 #ifndef CONFIG_ENV_ACCESS_IGNORE_FORCE
521         if (flag & H_FORCE)
522                 return 0;
523 #endif
524         switch (op) {
525         case env_op_delete:
526                 if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_DELETE) {
527                         printf("## Error: Can't delete \"%s\"\n", name);
528                         return 1;
529                 }
530                 break;
531         case env_op_overwrite:
532                 if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_OVERWR) {
533                         printf("## Error: Can't overwrite \"%s\"\n", name);
534                         return 1;
535                 } else if (item->flags &
536                     ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR) {
537                         const char *defval = getenv_default(name);
538
539                         if (defval == NULL)
540                                 defval = "";
541                         printf("oldval: %s  defval: %s\n", oldval, defval);
542                         if (strcmp(oldval, defval) != 0) {
543                                 printf("## Error: Can't overwrite \"%s\"\n",
544                                         name);
545                                 return 1;
546                         }
547                 }
548                 break;
549         case env_op_create:
550                 if (item->flags & ENV_FLAGS_VARACCESS_PREVENT_CREATE) {
551                         printf("## Error: Can't create \"%s\"\n", name);
552                         return 1;
553                 }
554                 break;
555         }
556
557         return 0;
558 }
559
560 #endif