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