git.sur5r.net Git - u-boot/blob - 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