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("## Error: Environment import failed: errno = %d\n", 83 errno); 84 85 gd->flags |= GD_FLG_ENV_READY; 86 gd->flags |= GD_FLG_ENV_DEFAULT; 87 } 88 89 90 /* [re]set individual variables to their value in the default environment */ 91 int set_default_vars(int nvars, char * const vars[], int flags) 92 { 93 /* 94 * Special use-case: import from default environment 95 * (and use \0 as a separator) 96 */ 97 flags |= H_NOCLEAR; 98 return himport_r(&env_htab, (const char *)default_environment, 99 sizeof(default_environment), '\0', 100 flags, 0, nvars, vars); 101 } 102 103 /* 104 * Check if CRC is valid and (if yes) import the environment. 105 * Note that "buf" may or may not be aligned. 106 */ 107 int env_import(const char *buf, int check) 108 { 109 env_t *ep = (env_t *)buf; 110 111 if (check) { 112 uint32_t crc; 113 114 memcpy(&crc, &ep->crc, sizeof(crc)); 115 116 if (crc32(0, ep->data, ENV_SIZE) != crc) { 117 set_default_env("bad CRC", 0); 118 return -EIO; 119 } 120 } 121 122 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, 123 0, NULL)) { 124 gd->flags |= GD_FLG_ENV_READY; 125 return 0; 126 } 127 128 pr_err("Cannot import environment: errno = %d\n", errno); 129 130 set_default_env("import failed", 0); 131 132 return -EIO; 133 } 134 135 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT 136 static unsigned char env_flags; 137 138 int env_import_redund(const char *buf1, int buf1_read_fail, 139 const char *buf2, int buf2_read_fail) 140 { 141 int crc1_ok, crc2_ok; 142 env_t *ep, *tmp_env1, *tmp_env2; 143 144 tmp_env1 = (env_t *)buf1; 145 tmp_env2 = (env_t *)buf2; 146 147 if (buf1_read_fail && buf2_read_fail) { 148 puts("*** Error - No Valid Environment Area found\n"); 149 } else if (buf1_read_fail || buf2_read_fail) { 150 puts("*** Warning - some problems detected "); 151 puts("reading environment; recovered successfully\n"); 152 } 153 154 if (buf1_read_fail && buf2_read_fail) { 155 set_default_env("bad env area", 0); 156 return -EIO; 157 } else if (!buf1_read_fail && buf2_read_fail) { 158 gd->env_valid = ENV_VALID; 159 return env_import((char *)tmp_env1, 1); 160 } else if (buf1_read_fail && !buf2_read_fail) { 161 gd->env_valid = ENV_REDUND; 162 return env_import((char *)tmp_env2, 1); 163 } 164 165 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) == 166 tmp_env1->crc; 167 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) == 168 tmp_env2->crc; 169 170 if (!crc1_ok && !crc2_ok) { 171 set_default_env("bad CRC", 0); 172 return -EIO; 173 } else if (crc1_ok && !crc2_ok) { 174 gd->env_valid = ENV_VALID; 175 } else if (!crc1_ok && crc2_ok) { 176 gd->env_valid = ENV_REDUND; 177 } else { 178 /* both ok - check serial */ 179 if (tmp_env1->flags == 255 && tmp_env2->flags == 0) 180 gd->env_valid = ENV_REDUND; 181 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) 182 gd->env_valid = ENV_VALID; 183 else if (tmp_env1->flags > tmp_env2->flags) 184 gd->env_valid = ENV_VALID; 185 else if (tmp_env2->flags > tmp_env1->flags) 186 gd->env_valid = ENV_REDUND; 187 else /* flags are equal - almost impossible */ 188 gd->env_valid = ENV_VALID; 189 } 190 191 if (gd->env_valid == ENV_VALID) 192 ep = tmp_env1; 193 else 194 ep = tmp_env2; 195 196 env_flags = ep->flags; 197 return env_import((char *)ep, 0); 198 } 199 #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */ 200 201 /* Export the environment and generate CRC for it. */ 202 int env_export(env_t *env_out) 203 { 204 char *res; 205 ssize_t len; 206 207 res = (char *)env_out->data; 208 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL); 209 if (len < 0) { 210 pr_err("Cannot export environment: errno = %d\n", errno); 211 return 1; 212 } 213 214 env_out->crc = crc32(0, env_out->data, ENV_SIZE); 215 216 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT 217 env_out->flags = ++env_flags; /* increase the serial */ 218 #endif 219 220 return 0; 221 } 222 223 void env_relocate(void) 224 { 225 #if defined(CONFIG_NEEDS_MANUAL_RELOC) 226 env_reloc(); 227 env_fix_drivers(); 228 env_htab.change_ok += gd->reloc_off; 229 #endif 230 if (gd->env_valid == ENV_INVALID) { 231 #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD) 232 /* Environment not changable */ 233 set_default_env(NULL, 0); 234 #else 235 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); 236 set_default_env("bad CRC", 0); 237 #endif 238 } else { 239 env_load(); 240 } 241 } 242 243 #if defined(CONFIG_AUTO_COMPLETE) && !defined(CONFIG_SPL_BUILD) 244 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf) 245 { 246 ENTRY *match; 247 int found, idx; 248 249 idx = 0; 250 found = 0; 251 cmdv[0] = NULL; 252 253 while ((idx = hmatch_r(var, idx, &match, &env_htab))) { 254 int vallen = strlen(match->key) + 1; 255 256 if (found >= maxv - 2 || bufsz < vallen) 257 break; 258 259 cmdv[found++] = buf; 260 memcpy(buf, match->key, vallen); 261 buf += vallen; 262 bufsz -= vallen; 263 } 264 265 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar); 266 267 if (idx) 268 cmdv[found++] = "..."; 269 270 cmdv[found] = NULL; 271 return found; 272 } 273 #endif 274