env/common.c

   1 /*
   2  * (C) Copyright 2000-2010
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   6  * Andreas Heppel <aheppel@sysgo.de>
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <command.h>
  13 #include <environment.h>
  14 #include <linux/stddef.h>
  15 #include <search.h>
  16 #include <errno.h>
  17 #include <malloc.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 /************************************************************************
  22  * Default settings to be used when no valid environment is found
  23  */
  24 #include <env_default.h>
  25
  26 struct hsearch_data env_htab = {
  27         .change_ok = env_flags_validate,
  28 };
  29
  30 __weak uchar env_get_char_spec(int index)
  31 {
  32         return *((uchar *)(gd->env_addr + index));
  33 }
  34
  35 static uchar env_get_char_init(int index)
  36 {
  37         /* if crc was bad, use the default environment */
  38         if (gd->env_valid)
  39                 return env_get_char_spec(index);
  40         else
  41                 return default_environment[index];
  42 }
  43
  44 static uchar env_get_char_memory(int index)
  45 {
  46         if (gd->env_valid)
  47                 return *(uchar *)(gd->env_addr + index);
  48         else
  49                 return default_environment[index];
  50 }
  51
  52 uchar env_get_char(int index)
  53 {
  54         /* if relocated to RAM */
  55         if (gd->flags & GD_FLG_RELOC)
  56                 return env_get_char_memory(index);
  57         else
  58                 return env_get_char_init(index);
  59 }
  60
  61 /*
  62  * Read an environment variable as a boolean
  63  * Return -1 if variable does not exist (default to true)
  64  */
  65 int getenv_yesno(const char *var)
  66 {
  67         char *s = getenv(var);
  68
  69         if (s == NULL)
  70                 return -1;
  71         return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
  72                 1 : 0;
  73 }
  74
  75 /*
  76  * Look up the variable from the default environment
  77  */
  78 char *getenv_default(const char *name)
  79 {
  80         char *ret_val;
  81         unsigned long really_valid = gd->env_valid;
  82         unsigned long real_gd_flags = gd->flags;
  83
  84         /* Pretend that the image is bad. */
  85         gd->flags &= ~GD_FLG_ENV_READY;
  86         gd->env_valid = 0;
  87         ret_val = getenv(name);
  88         gd->env_valid = really_valid;
  89         gd->flags = real_gd_flags;
  90         return ret_val;
  91 }
  92
  93 void set_default_env(const char *s)
  94 {
  95         int flags = 0;
  96
  97         if (sizeof(default_environment) > ENV_SIZE) {
  98                 puts("*** Error - default environment is too large\n\n");
  99                 return;
 100         }
 101
 102         if (s) {
 103                 if (*s == '!') {
 104                         printf("*** Warning - %s, "
 105                                 "using default environment\n\n",
 106                                 s + 1);
 107                 } else {
 108                         flags = H_INTERACTIVE;
 109                         puts(s);
 110                 }
 111         } else {
 112                 puts("Using default environment\n\n");
 113         }
 114
 115         if (himport_r(&env_htab, (char *)default_environment,
 116                         sizeof(default_environment), '\0', flags, 0,
 117                         0, NULL) == 0)
 118                 error("Environment import failed: errno = %d\n", errno);
 119
 120         gd->flags |= GD_FLG_ENV_READY;
 121         gd->flags |= GD_FLG_ENV_DEFAULT;
 122 }
 123
 124
 125 /* [re]set individual variables to their value in the default environment */
 126 int set_default_vars(int nvars, char * const vars[])
 127 {
 128         /*
 129          * Special use-case: import from default environment
 130          * (and use \0 as a separator)
 131          */
 132         return himport_r(&env_htab, (const char *)default_environment,
 133                                 sizeof(default_environment), '\0',
 134                                 H_NOCLEAR | H_INTERACTIVE, 0, nvars, vars);
 135 }
 136
 137 #ifdef CONFIG_ENV_AES
 138 #include <uboot_aes.h>
 139 /**
 140  * env_aes_cbc_get_key() - Get AES-128-CBC key for the environment
 141  *
 142  * This function shall return 16-byte array containing AES-128 key used
 143  * to encrypt and decrypt the environment. This function must be overridden
 144  * by the implementer as otherwise the environment encryption will not
 145  * work.
 146  */
 147 __weak uint8_t *env_aes_cbc_get_key(void)
 148 {
 149         return NULL;
 150 }
 151
 152 static int env_aes_cbc_crypt(env_t *env, const int enc)
 153 {
 154         unsigned char *data = env->data;
 155         uint8_t *key;
 156         uint8_t key_exp[AES_EXPAND_KEY_LENGTH];
 157         uint32_t aes_blocks;
 158
 159         key = env_aes_cbc_get_key();
 160         if (!key)
 161                 return -EINVAL;
 162
 163         /* First we expand the key. */
 164         aes_expand_key(key, key_exp);
 165
 166         /* Calculate the number of AES blocks to encrypt. */
 167         aes_blocks = ENV_SIZE / AES_KEY_LENGTH;
 168
 169         if (enc)
 170                 aes_cbc_encrypt_blocks(key_exp, data, data, aes_blocks);
 171         else
 172                 aes_cbc_decrypt_blocks(key_exp, data, data, aes_blocks);
 173
 174         return 0;
 175 }
 176 #else
 177 static inline int env_aes_cbc_crypt(env_t *env, const int enc)
 178 {
 179         return 0;
 180 }
 181 #endif
 182
 183 /*
 184  * Check if CRC is valid and (if yes) import the environment.
 185  * Note that "buf" may or may not be aligned.
 186  */
 187 int env_import(const char *buf, int check)
 188 {
 189         env_t *ep = (env_t *)buf;
 190         int ret;
 191
 192         if (check) {
 193                 uint32_t crc;
 194
 195                 memcpy(&crc, &ep->crc, sizeof(crc));
 196
 197                 if (crc32(0, ep->data, ENV_SIZE) != crc) {
 198                         set_default_env("!bad CRC");
 199                         return 0;
 200                 }
 201         }
 202
 203         /* Decrypt the env if desired. */
 204         ret = env_aes_cbc_crypt(ep, 0);
 205         if (ret) {
 206                 error("Failed to decrypt env!\n");
 207                 set_default_env("!import failed");
 208                 return ret;
 209         }
 210
 211         if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0,
 212                         0, NULL)) {
 213                 gd->flags |= GD_FLG_ENV_READY;
 214                 return 1;
 215         }
 216
 217         error("Cannot import environment: errno = %d\n", errno);
 218
 219         set_default_env("!import failed");
 220
 221         return 0;
 222 }
 223
 224 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
 225 static unsigned char env_flags;
 226
 227 int env_import_redund(const char *buf1, const char *buf2)
 228 {
 229         int crc1_ok, crc2_ok;
 230         env_t *ep, *tmp_env1, *tmp_env2;
 231
 232         tmp_env1 = (env_t *)buf1;
 233         tmp_env2 = (env_t *)buf2;
 234
 235         crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
 236                         tmp_env1->crc;
 237         crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
 238                         tmp_env2->crc;
 239
 240         if (!crc1_ok && !crc2_ok) {
 241                 set_default_env("!bad CRC");
 242                 return 0;
 243         } else if (crc1_ok && !crc2_ok) {
 244                 gd->env_valid = 1;
 245         } else if (!crc1_ok && crc2_ok) {
 246                 gd->env_valid = 2;
 247         } else {
 248                 /* both ok - check serial */
 249                 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
 250                         gd->env_valid = 2;
 251                 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
 252                         gd->env_valid = 1;
 253                 else if (tmp_env1->flags > tmp_env2->flags)
 254                         gd->env_valid = 1;
 255                 else if (tmp_env2->flags > tmp_env1->flags)
 256                         gd->env_valid = 2;
 257                 else /* flags are equal - almost impossible */
 258                         gd->env_valid = 1;
 259         }
 260
 261         if (gd->env_valid == 1)
 262                 ep = tmp_env1;
 263         else
 264                 ep = tmp_env2;
 265
 266         env_flags = ep->flags;
 267         return env_import((char *)ep, 0);
 268 }
 269 #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
 270
 271 /* Export the environment and generate CRC for it. */
 272 int env_export(env_t *env_out)
 273 {
 274         char *res;
 275         ssize_t len;
 276         int ret;
 277
 278         res = (char *)env_out->data;
 279         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
 280         if (len < 0) {
 281                 error("Cannot export environment: errno = %d\n", errno);
 282                 return 1;
 283         }
 284
 285         /* Encrypt the env if desired. */
 286         ret = env_aes_cbc_crypt(env_out, 1);
 287         if (ret)
 288                 return ret;
 289
 290         env_out->crc = crc32(0, env_out->data, ENV_SIZE);
 291
 292 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
 293         env_out->flags = ++env_flags; /* increase the serial */
 294 #endif
 295
 296         return 0;
 297 }
 298
 299 void env_relocate(void)
 300 {
 301 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 302         env_reloc();
 303         env_htab.change_ok += gd->reloc_off;
 304 #endif
 305         if (gd->env_valid == 0) {
 306 #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
 307                 /* Environment not changable */
 308                 set_default_env(NULL);
 309 #else
 310                 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
 311                 set_default_env("!bad CRC");
 312 #endif
 313         } else {
 314                 env_relocate_spec();
 315         }
 316 }
 317
 318 #if defined(CONFIG_AUTO_COMPLETE) && !defined(CONFIG_SPL_BUILD)
 319 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
 320 {
 321         ENTRY *match;
 322         int found, idx;
 323
 324         idx = 0;
 325         found = 0;
 326         cmdv[0] = NULL;
 327
 328         while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
 329                 int vallen = strlen(match->key) + 1;
 330
 331                 if (found >= maxv - 2 || bufsz < vallen)
 332                         break;
 333
 334                 cmdv[found++] = buf;
 335                 memcpy(buf, match->key, vallen);
 336                 buf += vallen;
 337                 bufsz -= vallen;
 338         }
 339
 340         qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
 341
 342         if (idx)
 343                 cmdv[found++] = "...";
 344
 345         cmdv[found] = NULL;
 346         return found;
 347 }
 348 #endif