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 <command.h> 12 #include <environment.h> 13 #include <linux/stddef.h> 14 #include <search.h> 15 #include <errno.h> 16 #include <malloc.h> 17 18 DECLARE_GLOBAL_DATA_PTR; 19 20 /************************************************************************ 21 * Default settings to be used when no valid environment is found 22 */ 23 #include <env_default.h> 24 25 struct hsearch_data env_htab = { 26 .change_ok = env_flags_validate, 27 }; 28 29 /* 30 * Read an environment variable as a boolean 31 * Return -1 if variable does not exist (default to true) 32 */ 33 int env_get_yesno(const char *var) 34 { 35 char *s = env_get(var); 36 37 if (s == NULL) 38 return -1; 39 return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ? 40 1 : 0; 41 } 42 43 /* 44 * Look up the variable from the default environment 45 */ 46 char *env_get_default(const char *name) 47 { 48 char *ret_val; 49 unsigned long really_valid = gd->env_valid; 50 unsigned long real_gd_flags = gd->flags; 51 52 /* Pretend that the image is bad. */ 53 gd->flags &= ~GD_FLG_ENV_READY; 54 gd->env_valid = ENV_INVALID; 55 ret_val = env_get(name); 56 gd->env_valid = really_valid; 57 gd->flags = real_gd_flags; 58 return ret_val; 59 } 60 61 void set_default_env(const char *s, int flags) 62 { 63 if (sizeof(default_environment) > ENV_SIZE) { 64 puts("*** Error - default environment is too large\n\n"); 65 return; 66 } 67 68 if (s) { 69 if ((flags & H_INTERACTIVE) == 0) { 70 printf("*** Warning - %s, " 71 "using default environment\n\n", s); 72 } else { 73 puts(s); 74 } 75 } else { 76 debug("Using default environment\n"); 77 } 78 79 if (himport_r(&env_htab, (char *)default_environment, 80 sizeof(default_environment), '\0', flags, 0, 81 0, NULL) == 0) 82 pr_err("Environment import failed: errno = %d\n", errno); 83 84 gd->flags |= GD_FLG_ENV_READY; 85 gd->flags |= GD_FLG_ENV_DEFAULT; 86 } 87 88 89 /* [re]set individual variables to their value in the default environment */ 90 int set_default_vars(int nvars, char * const vars[], int flags) 91 { 92 /* 93 * Special use-case: import from default environment 94 * (and use \0 as a separator) 95 */ 96 flags |= H_NOCLEAR; 97 return himport_r(&env_htab, (const char *)default_environment, 98 sizeof(default_environment), '\0', 99 flags, 0, nvars, vars); 100 } 101 102 /* 103 * Check if CRC is valid and (if yes) import the environment. 104 * Note that "buf" may or may not be aligned. 105 */ 106 int env_import(const char *buf, int check) 107 { 108 env_t *ep = (env_t *)buf; 109 110 if (check) { 111 uint32_t crc; 112 113 memcpy(&crc, &ep->crc, sizeof(crc)); 114 115 if (crc32(0, ep->data, ENV_SIZE) != crc) { 116 set_default_env("bad CRC", 0); 117 return -EIO; 118 } 119 } 120 121 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, 122 0, NULL)) { 123 gd->flags |= GD_FLG_ENV_READY; 124 return 0; 125 } 126 127 pr_err("Cannot import environment: errno = %d\n", errno); 128 129 set_default_env("import failed", 0); 130 131 return -EIO; 132 } 133 134 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT 135 static unsigned char env_flags; 136 137 int env_import_redund(const char *buf1, int buf1_read_fail, 138 const char *buf2, int buf2_read_fail) 139 { 140 int crc1_ok, crc2_ok; 141 env_t *ep, *tmp_env1, *tmp_env2; 142 143 tmp_env1 = (env_t *)buf1; 144 tmp_env2 = (env_t *)buf2; 145 146 if (buf1_read_fail && buf2_read_fail) { 147 puts("*** Error - No Valid Environment Area found\n"); 148 } else if (buf1_read_fail || buf2_read_fail) { 149 puts("*** Warning - some problems detected "); 150 puts("reading environment; recovered successfully\n"); 151 } 152 153 if (buf1_read_fail && buf2_read_fail) { 154 set_default_env("bad env area", 0); 155 return -EIO; 156 } else if (!buf1_read_fail && buf2_read_fail) { 157 gd->env_valid = ENV_VALID; 158 return env_import((char *)tmp_env1, 1); 159 } else if (buf1_read_fail && !buf2_read_fail) { 160 gd->env_valid = ENV_REDUND; 161 return env_import((char *)tmp_env2, 1); 162 } 163 164 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == 165 tmp_env1->crc; 166 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == 167 tmp_env2->crc; 168 169 if (!crc1_ok && !crc2_ok) { 170 set_default_env("bad CRC", 0); 171 return -EIO; 172 } else if (crc1_ok && !crc2_ok) { 173 gd->env_valid = ENV_VALID; 174 } else if (!crc1_ok && crc2_ok) { 175 gd->env_valid = ENV_REDUND; 176 } else { 177 /* both ok - check serial */ 178 if (tmp_env1->flags == 255 && tmp_env2->flags == 0) 179 gd->env_valid = ENV_REDUND; 180 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) 181 gd->env_valid = ENV_VALID; 182 else if (tmp_env1->flags > tmp_env2->flags) 183 gd->env_valid = ENV_VALID; 184 else if (tmp_env2->flags > tmp_env1->flags) 185 gd->env_valid = ENV_REDUND; 186 else /* flags are equal - almost impossible */ 187 gd->env_valid = ENV_VALID; 188 } 189 190 if (gd->env_valid == ENV_VALID) 191 ep = tmp_env1; 192 else 193 ep = tmp_env2; 194 195 env_flags = ep->flags; 196 return env_import((char *)ep, 0); 197 } 198 #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */ 199 200 /* Export the environment and generate CRC for it. */ 201 int env_export(env_t *env_out) 202 { 203 char *res; 204 ssize_t len; 205 206 res = (char *)env_out->data; 207 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL); 208 if (len < 0) { 209 pr_err("Cannot export environment: errno = %d\n", errno); 210 return 1; 211 } 212 213 env_out->crc = crc32(0, env_out->data, ENV_SIZE); 214 215 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT 216 env_out->flags = ++env_flags; /* increase the serial */ 217 #endif 218 219 return 0; 220 } 221 222 void env_relocate(void) 223 { 224 #if defined(CONFIG_NEEDS_MANUAL_RELOC) 225 env_reloc(); 226 env_fix_drivers(); 227 env_htab.change_ok += gd->reloc_off; 228 #endif 229 if (gd->env_valid == ENV_INVALID) { 230 #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD) 231 /* Environment not changable */ 232 set_default_env(NULL, 0); 233 #else 234 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); 235 set_default_env("bad CRC", 0); 236 #endif 237 } else { 238 env_load(); 239 } 240 } 241 242 #if defined(CONFIG_AUTO_COMPLETE) && !defined(CONFIG_SPL_BUILD) 243 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf) 244 { 245 ENTRY *match; 246 int found, idx; 247 248 idx = 0; 249 found = 0; 250 cmdv[0] = NULL; 251 252 while ((idx = hmatch_r(var, idx, &match, &env_htab))) { 253 int vallen = strlen(match->key) + 1; 254 255 if (found >= maxv - 2 || bufsz < vallen) 256 break; 257 258 cmdv[found++] = buf; 259 memcpy(buf, match->key, vallen); 260 buf += vallen; 261 bufsz -= vallen; 262 } 263 264 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar); 265 266 if (idx) 267 cmdv[found++] = "..."; 268 269 cmdv[found] = NULL; 270 return found; 271 } 272 #endif 273