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