1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * (C) Copyright 2000-2010 4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 5 * 6 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com> 7 * Andreas Heppel <aheppel@sysgo.de> 8 */ 9 10#include <common.h> 11#include <bootstage.h> 12#include <command.h> 13#include <env.h> 14#include <env_internal.h> 15#include <log.h> 16#include <sort.h> 17#include <asm/global_data.h> 18#include <linux/printk.h> 19#include <linux/stddef.h> 20#include <search.h> 21#include <errno.h> 22#include <malloc.h> 23#include <u-boot/crc.h> 24#include <dm/ofnode.h> 25#include <net.h> 26#include <watchdog.h> 27 28DECLARE_GLOBAL_DATA_PTR; 29 30/************************************************************************ 31 * Default settings to be used when no valid environment is found 32 */ 33#include <env_default.h> 34 35struct hsearch_data env_htab = { 36 .change_ok = env_flags_validate, 37}; 38 39/* 40 * This variable is incremented each time we set an environment variable so we 41 * can be check via env_get_id() to see if the environment has changed or not. 42 * This makes it possible to reread an environment variable only if the 43 * environment was changed, typically used by networking code. 44 */ 45static int env_id = 1; 46 47int env_get_id(void) 48{ 49 return env_id; 50} 51 52void env_inc_id(void) 53{ 54 env_id++; 55} 56 57int env_do_env_set(int flag, int argc, char *const argv[], int env_flag) 58{ 59 int i, len; 60 char *name, *value, *s; 61 struct env_entry e, *ep; 62 63 debug("Initial value for argc=%d\n", argc); 64 65#if !IS_ENABLED(CONFIG_SPL_BUILD) && IS_ENABLED(CONFIG_CMD_NVEDIT_EFI) 66 if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e') 67 return do_env_set_efi(NULL, flag, --argc, ++argv); 68#endif 69 70 while (argc > 1 && **(argv + 1) == '-') { 71 char *arg = *++argv; 72 73 --argc; 74 while (*++arg) { 75 switch (*arg) { 76 case 'f': /* force */ 77 env_flag |= H_FORCE; 78 break; 79 default: 80 return CMD_RET_USAGE; 81 } 82 } 83 } 84 debug("Final value for argc=%d\n", argc); 85 name = argv[1]; 86 87 if (strchr(name, '=')) { 88 printf("## Error: illegal character '=' " 89 "in variable name \"%s\"\n", name); 90 return 1; 91 } 92 93 env_inc_id(); 94 95 /* Delete only ? */ 96 if (argc < 3 || argv[2] == NULL) { 97 int rc = hdelete_r(name, &env_htab, env_flag); 98 99 /* If the variable didn't exist, don't report an error */ 100 return rc && rc != -ENOENT ? 1 : 0; 101 } 102 103 /* 104 * Insert / replace new value 105 */ 106 for (i = 2, len = 0; i < argc; ++i) 107 len += strlen(argv[i]) + 1; 108 109 value = malloc(len); 110 if (value == NULL) { 111 printf("## Can't malloc %d bytes\n", len); 112 return 1; 113 } 114 for (i = 2, s = value; i < argc; ++i) { 115 char *v = argv[i]; 116 117 while ((*s++ = *v++) != '\0') 118 ; 119 *(s - 1) = ' '; 120 } 121 if (s != value) 122 *--s = '\0'; 123 124 e.key = name; 125 e.data = value; 126 hsearch_r(e, ENV_ENTER, &ep, &env_htab, env_flag); 127 free(value); 128 if (!ep) { 129 printf("## Error inserting \"%s\" variable, errno=%d\n", 130 name, errno); 131 return 1; 132 } 133 134 return 0; 135} 136 137int env_set(const char *varname, const char *varvalue) 138{ 139 const char * const argv[4] = { "setenv", varname, varvalue, NULL }; 140 141 /* before import into hashtable */ 142 if (!(gd->flags & GD_FLG_ENV_READY)) 143 return 1; 144 145 if (varvalue == NULL || varvalue[0] == '\0') 146 return env_do_env_set(0, 2, (char * const *)argv, H_PROGRAMMATIC); 147 else 148 return env_do_env_set(0, 3, (char * const *)argv, H_PROGRAMMATIC); 149} 150 151/** 152 * Set an environment variable to an integer value 153 * 154 * @param varname Environment variable to set 155 * @param value Value to set it to 156 * Return: 0 if ok, 1 on error 157 */ 158int env_set_ulong(const char *varname, ulong value) 159{ 160 /* TODO: this should be unsigned */ 161 char *str = simple_itoa(value); 162 163 return env_set(varname, str); 164} 165 166/** 167 * Set an environment variable to an value in hex 168 * 169 * @param varname Environment variable to set 170 * @param value Value to set it to 171 * Return: 0 if ok, 1 on error 172 */ 173int env_set_hex(const char *varname, ulong value) 174{ 175 char str[17]; 176 177 sprintf(str, "%lx", value); 178 return env_set(varname, str); 179} 180 181ulong env_get_hex(const char *varname, ulong default_val) 182{ 183 const char *s; 184 ulong value; 185 char *endp; 186 187 s = env_get(varname); 188 if (s) 189 value = hextoul(s, &endp); 190 if (!s || endp == s) 191 return default_val; 192 193 return value; 194} 195 196int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr) 197{ 198 string_to_enetaddr(env_get(name), enetaddr); 199 return is_valid_ethaddr(enetaddr); 200} 201 202int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr) 203{ 204 char buf[ARP_HLEN_ASCII + 1]; 205 206 if (eth_env_get_enetaddr(name, (uint8_t *)buf)) 207 return -EEXIST; 208 209 sprintf(buf, "%pM", enetaddr); 210 211 return env_set(name, buf); 212} 213 214/* 215 * Look up variable from environment, 216 * return address of storage for that variable, 217 * or NULL if not found 218 */ 219char *env_get(const char *name) 220{ 221 if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */ 222 struct env_entry e, *ep; 223 224 schedule(); 225 226 e.key = name; 227 e.data = NULL; 228 hsearch_r(e, ENV_FIND, &ep, &env_htab, 0); 229 230 return ep ? ep->data : NULL; 231 } 232 233 /* restricted capabilities before import */ 234 if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) >= 0) 235 return (char *)(gd->env_buf); 236 237 return NULL; 238} 239 240/* 241 * Like env_get, but prints an error if envvar isn't defined in the 242 * environment. It always returns what env_get does, so it can be used in 243 * place of env_get without changing error handling otherwise. 244 */ 245char *from_env(const char *envvar) 246{ 247 char *ret; 248 249 ret = env_get(envvar); 250 251 if (!ret) 252 printf("missing environment variable: %s\n", envvar); 253 254 return ret; 255} 256 257static int env_get_from_linear(const char *env, const char *name, char *buf, 258 unsigned len) 259{ 260 const char *p, *end; 261 size_t name_len; 262 263 if (name == NULL || *name == '\0') 264 return -1; 265 266 name_len = strlen(name); 267 268 for (p = env; *p != '\0'; p = end + 1) { 269 const char *value; 270 unsigned res; 271 272 for (end = p; *end != '\0'; ++end) 273 if (end - env >= CONFIG_ENV_SIZE) 274 return -1; 275 276 if (strncmp(name, p, name_len) || p[name_len] != '=') 277 continue; 278 value = &p[name_len + 1]; 279 280 res = end - value; 281 memcpy(buf, value, min(len, res + 1)); 282 283 if (len <= res) { 284 buf[len - 1] = '\0'; 285 printf("env_buf [%u bytes] too small for value of \"%s\"\n", 286 len, name); 287 } 288 289 return res; 290 } 291 292 return -1; 293} 294 295/* 296 * Look up variable from environment for restricted C runtime env. 297 */ 298int env_get_f(const char *name, char *buf, unsigned len) 299{ 300 const char *env; 301 302 if (gd->env_valid == ENV_INVALID) 303 env = default_environment; 304 else 305 env = (const char *)gd->env_addr; 306 307 return env_get_from_linear(env, name, buf, len); 308} 309 310/** 311 * Decode the integer value of an environment variable and return it. 312 * 313 * @param name Name of environment variable 314 * @param base Number base to use (normally 10, or 16 for hex) 315 * @param default_val Default value to return if the variable is not 316 * found 317 * Return: the decoded value, or default_val if not found 318 */ 319ulong env_get_ulong(const char *name, int base, ulong default_val) 320{ 321 /* 322 * We can use env_get() here, even before relocation, since the 323 * environment variable value is an integer and thus short. 324 */ 325 const char *str = env_get(name); 326 327 return str ? simple_strtoul(str, NULL, base) : default_val; 328} 329 330/* 331 * Read an environment variable as a boolean 332 * Return -1 if variable does not exist (default to true) 333 */ 334int env_get_yesno(const char *var) 335{ 336 char *s = env_get(var); 337 338 if (s == NULL) 339 return -1; 340 return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ? 341 1 : 0; 342} 343 344bool env_get_autostart(void) 345{ 346 return env_get_yesno("autostart") == 1; 347} 348 349/* 350 * Look up the variable from the default environment 351 */ 352char *env_get_default(const char *name) 353{ 354 int ret; 355 356 ret = env_get_default_into(name, (char *)(gd->env_buf), 357 sizeof(gd->env_buf)); 358 if (ret >= 0) 359 return (char *)(gd->env_buf); 360 361 return NULL; 362} 363 364/* 365 * Look up the variable from the default environment and store its value in buf 366 */ 367int env_get_default_into(const char *name, char *buf, unsigned int len) 368{ 369 return env_get_from_linear(default_environment, name, buf, len); 370} 371 372void env_set_default(const char *s, int flags) 373{ 374 if (s) { 375 if ((flags & H_INTERACTIVE) == 0) { 376 printf("*** Warning - %s, " 377 "using default environment\n\n", s); 378 } else { 379 puts(s); 380 } 381 } else { 382 debug("Using default environment\n"); 383 } 384 385 flags |= H_DEFAULT; 386 if (himport_r(&env_htab, default_environment, 387 sizeof(default_environment), '\0', flags, 0, 388 0, NULL) == 0) { 389 pr_err("## Error: Environment import failed: errno = %d\n", 390 errno); 391 return; 392 } 393 394 gd->flags |= GD_FLG_ENV_READY; 395 gd->flags |= GD_FLG_ENV_DEFAULT; 396} 397 398 399/* [re]set individual variables to their value in the default environment */ 400int env_set_default_vars(int nvars, char * const vars[], int flags) 401{ 402 /* 403 * Special use-case: import from default environment 404 * (and use \0 as a separator) 405 */ 406 flags |= H_NOCLEAR | H_DEFAULT; 407 return himport_r(&env_htab, default_environment, 408 sizeof(default_environment), '\0', 409 flags, 0, nvars, vars); 410} 411 412/* 413 * Check if CRC is valid and (if yes) import the environment. 414 * Note that "buf" may or may not be aligned. 415 */ 416int env_import(const char *buf, int check, int flags) 417{ 418 env_t *ep = (env_t *)buf; 419 420 if (check) { 421 uint32_t crc; 422 423 memcpy(&crc, &ep->crc, sizeof(crc)); 424 425 if (crc32(0, ep->data, ENV_SIZE) != crc) { 426 env_set_default("bad CRC", 0); 427 return -ENOMSG; /* needed for env_load() */ 428 } 429 } 430 431 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0, 432 0, NULL)) { 433 gd->flags |= GD_FLG_ENV_READY; 434 return 0; 435 } 436 437 pr_err("Cannot import environment: errno = %d\n", errno); 438 439 env_set_default("import failed", 0); 440 441 return -EIO; 442} 443 444#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT 445static unsigned char env_flags; 446 447int env_check_redund(const char *buf1, int buf1_read_fail, 448 const char *buf2, int buf2_read_fail) 449{ 450 int crc1_ok = 0, crc2_ok = 0; 451 env_t *tmp_env1, *tmp_env2; 452 453 tmp_env1 = (env_t *)buf1; 454 tmp_env2 = (env_t *)buf2; 455 456 if (buf1_read_fail && buf2_read_fail) { 457 puts("*** Error - No Valid Environment Area found\n"); 458 return -EIO; 459 } else if (buf1_read_fail || buf2_read_fail) { 460 puts("*** Warning - some problems detected "); 461 puts("reading environment; recovered successfully\n"); 462 } 463 464 if (!buf1_read_fail) 465 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == 466 tmp_env1->crc; 467 if (!buf2_read_fail) 468 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == 469 tmp_env2->crc; 470 471 if (!crc1_ok && !crc2_ok) { 472 gd->env_valid = ENV_INVALID; 473 return -ENOMSG; /* needed for env_load() */ 474 } else if (crc1_ok && !crc2_ok) { 475 gd->env_valid = ENV_VALID; 476 } else if (!crc1_ok && crc2_ok) { 477 gd->env_valid = ENV_REDUND; 478 } else { 479 /* both ok - check serial */ 480 if (tmp_env1->flags == 255 && tmp_env2->flags == 0) 481 gd->env_valid = ENV_REDUND; 482 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) 483 gd->env_valid = ENV_VALID; 484 else if (tmp_env1->flags > tmp_env2->flags) 485 gd->env_valid = ENV_VALID; 486 else if (tmp_env2->flags > tmp_env1->flags) 487 gd->env_valid = ENV_REDUND; 488 else /* flags are equal - almost impossible */ 489 gd->env_valid = ENV_VALID; 490 } 491 492 return 0; 493} 494 495int env_import_redund(const char *buf1, int buf1_read_fail, 496 const char *buf2, int buf2_read_fail, 497 int flags) 498{ 499 env_t *ep; 500 int ret; 501 502 ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail); 503 504 if (ret == -EIO) { 505 env_set_default("bad env area", 0); 506 return -EIO; 507 } else if (ret == -ENOMSG) { 508 env_set_default("bad CRC", 0); 509 return -ENOMSG; 510 } 511 512 if (gd->env_valid == ENV_VALID) 513 ep = (env_t *)buf1; 514 else 515 ep = (env_t *)buf2; 516 517 env_flags = ep->flags; 518 519 return env_import((char *)ep, 0, flags); 520} 521#endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */ 522 523/* Export the environment and generate CRC for it. */ 524int env_export(env_t *env_out) 525{ 526 char *res; 527 ssize_t len; 528 529 res = (char *)env_out->data; 530 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL); 531 if (len < 0) { 532 pr_err("Cannot export environment: errno = %d\n", errno); 533 return 1; 534 } 535 536 env_out->crc = crc32(0, env_out->data, ENV_SIZE); 537 538#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT 539 env_out->flags = ++env_flags; /* increase the serial */ 540#endif 541 542 return 0; 543} 544 545void env_relocate(void) 546{ 547 if (gd->env_valid == ENV_INVALID) { 548#if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD) 549 /* Environment not changable */ 550 env_set_default(NULL, 0); 551#else 552 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); 553 env_set_default("bad CRC", 0); 554#endif 555 } else { 556 env_load(); 557 } 558} 559 560#ifdef CONFIG_AUTO_COMPLETE 561int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf, 562 bool dollar_comp) 563{ 564 struct env_entry *match; 565 int found, idx; 566 567 if (dollar_comp) { 568 /* 569 * When doing $ completion, the first character should 570 * obviously be a '$'. 571 */ 572 if (var[0] != '$') 573 return 0; 574 575 var++; 576 577 /* 578 * The second one, if present, should be a '{', as some 579 * configuration of the u-boot shell expand ${var} but not 580 * $var. 581 */ 582 if (var[0] == '{') 583 var++; 584 else if (var[0] != '\0') 585 return 0; 586 } 587 588 idx = 0; 589 found = 0; 590 cmdv[0] = NULL; 591 592 593 while ((idx = hmatch_r(var, idx, &match, &env_htab))) { 594 int vallen = strlen(match->key) + 1; 595 596 if (found >= maxv - 2 || 597 bufsz < vallen + (dollar_comp ? 3 : 0)) 598 break; 599 600 cmdv[found++] = buf; 601 602 /* Add the '${' prefix to each var when doing $ completion. */ 603 if (dollar_comp) { 604 strcpy(buf, "${"); 605 buf += 2; 606 bufsz -= 3; 607 } 608 609 memcpy(buf, match->key, vallen); 610 buf += vallen; 611 bufsz -= vallen; 612 613 if (dollar_comp) { 614 /* 615 * This one is a bit odd: vallen already contains the 616 * '\0' character but we need to add the '}' suffix, 617 * hence the buf - 1 here. strcpy() will add the '\0' 618 * character just after '}'. buf is then incremented 619 * to account for the extra '}' we just added. 620 */ 621 strcpy(buf - 1, "}"); 622 buf++; 623 } 624 } 625 626 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar); 627 628 if (idx) 629 cmdv[found++] = dollar_comp ? "${...}" : "..."; 630 631 cmdv[found] = NULL; 632 return found; 633} 634#endif 635 636#ifdef CONFIG_ENV_IMPORT_FDT 637void env_import_fdt(void) 638{ 639 const char *path; 640 struct ofprop prop; 641 ofnode node; 642 int res; 643 644 path = env_get("env_fdt_path"); 645 if (!path || !path[0]) 646 return; 647 648 node = ofnode_path(path); 649 if (!ofnode_valid(node)) { 650 printf("Warning: device tree node '%s' not found\n", path); 651 return; 652 } 653 654 for (res = ofnode_first_property(node, &prop); 655 !res; 656 res = ofnode_next_property(&prop)) { 657 const char *name, *val; 658 659 val = ofprop_get_property(&prop, &name, NULL); 660 env_set(name, val); 661 } 662} 663#endif 664