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