env/common.c

   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
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 /************************************************************************
  31  * Default settings to be used when no valid environment is found
  32  */
  33 #include <env_default.h>
  34
  35 struct 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  */
  45 static int env_id = 1;
  46
  47 int env_get_id(void)
  48 {
  49         return env_id;
  50 }
  51
  52 void env_inc_id(void)
  53 {
  54         env_id++;
  55 }
  56
  57 int 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
 137 int 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  */
 158 int 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  */
 173 int 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
 181 ulong 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
 196 int 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
 202 int 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  */
 219 char *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  */
 245 char *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
 257 static 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  */
 298 int 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  */
 319 ulong 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  */
 334 int 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
 344 bool 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  */
 352 char *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  */
 367 int 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
 372 void 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 */
 400 int 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  */
 416 int 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
 445 static unsigned char env_flags;
 446
 447 int 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
 495 int 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. */
 524 int 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
 545 void 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
 561 int 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
 637 void 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