]>
Commit | Line | Data |
---|---|---|
05706fdd | 1 | /* |
ea882baf | 2 | * (C) Copyright 2000-2010 |
05706fdd WD |
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> | |
ea882baf | 7 | * |
3765b3e7 | 8 | * SPDX-License-Identifier: GPL-2.0+ |
05706fdd WD |
9 | */ |
10 | ||
11 | #include <common.h> | |
12 | #include <command.h> | |
13 | #include <environment.h> | |
05706fdd | 14 | #include <linux/stddef.h> |
ea882baf WD |
15 | #include <search.h> |
16 | #include <errno.h> | |
05706fdd WD |
17 | #include <malloc.h> |
18 | ||
d87080b7 WD |
19 | DECLARE_GLOBAL_DATA_PTR; |
20 | ||
05706fdd WD |
21 | /************************************************************************ |
22 | * Default settings to be used when no valid environment is found | |
23 | */ | |
ddd8418f | 24 | #include <env_default.h> |
05706fdd | 25 | |
c5983592 | 26 | struct hsearch_data env_htab = { |
2598090b | 27 | .change_ok = env_flags_validate, |
c5983592 | 28 | }; |
2eb1573f | 29 | |
ec8a252c JH |
30 | /* |
31 | * Read an environment variable as a boolean | |
32 | * Return -1 if variable does not exist (default to true) | |
33 | */ | |
bfebc8c9 | 34 | int env_get_yesno(const char *var) |
ec8a252c | 35 | { |
00caae6d | 36 | char *s = env_get(var); |
ec8a252c JH |
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 | ||
267541f7 JH |
44 | /* |
45 | * Look up the variable from the default environment | |
46 | */ | |
723806cc | 47 | char *env_get_default(const char *name) |
267541f7 JH |
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; | |
2d7cb5b4 | 55 | gd->env_valid = ENV_INVALID; |
00caae6d | 56 | ret_val = env_get(name); |
267541f7 JH |
57 | gd->env_valid = really_valid; |
58 | gd->flags = real_gd_flags; | |
59 | return ret_val; | |
60 | } | |
61 | ||
ea882baf | 62 | void set_default_env(const char *s) |
5bb12dbd | 63 | { |
c4e0057f JH |
64 | int flags = 0; |
65 | ||
5bb12dbd | 66 | if (sizeof(default_environment) > ENV_SIZE) { |
ea882baf | 67 | puts("*** Error - default environment is too large\n\n"); |
5bb12dbd HW |
68 | return; |
69 | } | |
70 | ||
ea882baf WD |
71 | if (s) { |
72 | if (*s == '!') { | |
73 | printf("*** Warning - %s, " | |
74 | "using default environment\n\n", | |
27aafe98 | 75 | s + 1); |
ea882baf | 76 | } else { |
c4e0057f | 77 | flags = H_INTERACTIVE; |
ea882baf WD |
78 | puts(s); |
79 | } | |
80 | } else { | |
81 | puts("Using default environment\n\n"); | |
82 | } | |
83 | ||
2eb1573f | 84 | if (himport_r(&env_htab, (char *)default_environment, |
ecd1446f | 85 | sizeof(default_environment), '\0', flags, 0, |
c4e0057f | 86 | 0, NULL) == 0) |
9b643e31 | 87 | pr_err("Environment import failed: errno = %d\n", errno); |
27aafe98 | 88 | |
ea882baf | 89 | gd->flags |= GD_FLG_ENV_READY; |
340b0e3b | 90 | gd->flags |= GD_FLG_ENV_DEFAULT; |
5bb12dbd HW |
91 | } |
92 | ||
b64b7c3d GF |
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, | |
c4e0057f | 102 | sizeof(default_environment), '\0', |
ecd1446f | 103 | H_NOCLEAR | H_INTERACTIVE, 0, nvars, vars); |
b64b7c3d GF |
104 | } |
105 | ||
a4223b74 | 106 | #ifdef CONFIG_ENV_AES |
b80c0b99 | 107 | #include <uboot_aes.h> |
a4223b74 MV |
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 | |
62a3b7dd | 112 | * to encrypt and decrypt the environment. This function must be overridden |
a4223b74 MV |
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 | ||
ea882baf WD |
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) | |
05706fdd | 157 | { |
ea882baf | 158 | env_t *ep = (env_t *)buf; |
a4223b74 | 159 | int ret; |
05706fdd | 160 | |
ea882baf WD |
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 | ||
a4223b74 MV |
172 | /* Decrypt the env if desired. */ |
173 | ret = env_aes_cbc_crypt(ep, 0); | |
174 | if (ret) { | |
9b643e31 | 175 | pr_err("Failed to decrypt env!\n"); |
a4223b74 MV |
176 | set_default_env("!import failed"); |
177 | return ret; | |
178 | } | |
179 | ||
ecd1446f | 180 | if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, |
c4e0057f | 181 | 0, NULL)) { |
ea882baf WD |
182 | gd->flags |= GD_FLG_ENV_READY; |
183 | return 1; | |
184 | } | |
05706fdd | 185 | |
9b643e31 | 186 | pr_err("Cannot import environment: errno = %d\n", errno); |
ea882baf WD |
187 | |
188 | set_default_env("!import failed"); | |
189 | ||
190 | return 0; | |
191 | } | |
192 | ||
76768f5f FA |
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) { | |
2d7cb5b4 | 213 | gd->env_valid = ENV_VALID; |
76768f5f | 214 | } else if (!crc1_ok && crc2_ok) { |
2d7cb5b4 | 215 | gd->env_valid = ENV_REDUND; |
76768f5f FA |
216 | } else { |
217 | /* both ok - check serial */ | |
218 | if (tmp_env1->flags == 255 && tmp_env2->flags == 0) | |
2d7cb5b4 | 219 | gd->env_valid = ENV_REDUND; |
76768f5f | 220 | else if (tmp_env2->flags == 255 && tmp_env1->flags == 0) |
2d7cb5b4 | 221 | gd->env_valid = ENV_VALID; |
76768f5f | 222 | else if (tmp_env1->flags > tmp_env2->flags) |
2d7cb5b4 | 223 | gd->env_valid = ENV_VALID; |
76768f5f | 224 | else if (tmp_env2->flags > tmp_env1->flags) |
2d7cb5b4 | 225 | gd->env_valid = ENV_REDUND; |
76768f5f | 226 | else /* flags are equal - almost impossible */ |
2d7cb5b4 | 227 | gd->env_valid = ENV_VALID; |
76768f5f FA |
228 | } |
229 | ||
2d7cb5b4 | 230 | if (gd->env_valid == ENV_VALID) |
76768f5f FA |
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 | ||
fc0b5948 | 240 | /* Export the environment and generate CRC for it. */ |
7ce1526e MV |
241 | int env_export(env_t *env_out) |
242 | { | |
243 | char *res; | |
244 | ssize_t len; | |
a4223b74 | 245 | int ret; |
7ce1526e MV |
246 | |
247 | res = (char *)env_out->data; | |
248 | len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL); | |
249 | if (len < 0) { | |
9b643e31 | 250 | pr_err("Cannot export environment: errno = %d\n", errno); |
7ce1526e MV |
251 | return 1; |
252 | } | |
a4223b74 MV |
253 | |
254 | /* Encrypt the env if desired. */ | |
255 | ret = env_aes_cbc_crypt(env_out, 1); | |
256 | if (ret) | |
257 | return ret; | |
258 | ||
7ce1526e MV |
259 | env_out->crc = crc32(0, env_out->data, ENV_SIZE); |
260 | ||
76768f5f FA |
261 | #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT |
262 | env_out->flags = ++env_flags; /* increase the serial */ | |
263 | #endif | |
264 | ||
7ce1526e MV |
265 | return 0; |
266 | } | |
267 | ||
27aafe98 | 268 | void env_relocate(void) |
ea882baf | 269 | { |
2e5167cc | 270 | #if defined(CONFIG_NEEDS_MANUAL_RELOC) |
60f7da1f | 271 | env_reloc(); |
7afcf3a5 | 272 | env_htab.change_ok += gd->reloc_off; |
60f7da1f | 273 | #endif |
2d7cb5b4 | 274 | if (gd->env_valid == ENV_INVALID) { |
7ac2fe2d IY |
275 | #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD) |
276 | /* Environment not changable */ | |
ea882baf | 277 | set_default_env(NULL); |
05706fdd | 278 | #else |
770605e4 | 279 | bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM); |
ea882baf | 280 | set_default_env("!bad CRC"); |
d259079d | 281 | #endif |
ea882baf | 282 | } else { |
310fb14b | 283 | env_load(); |
05706fdd | 284 | } |
05706fdd | 285 | } |
04a85b3b | 286 | |
7ac2fe2d | 287 | #if defined(CONFIG_AUTO_COMPLETE) && !defined(CONFIG_SPL_BUILD) |
04a85b3b WD |
288 | int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf) |
289 | { | |
560d424b MF |
290 | ENTRY *match; |
291 | int found, idx; | |
04a85b3b | 292 | |
560d424b | 293 | idx = 0; |
04a85b3b WD |
294 | found = 0; |
295 | cmdv[0] = NULL; | |
296 | ||
560d424b MF |
297 | while ((idx = hmatch_r(var, idx, &match, &env_htab))) { |
298 | int vallen = strlen(match->key) + 1; | |
04a85b3b | 299 | |
560d424b | 300 | if (found >= maxv - 2 || bufsz < vallen) |
04a85b3b | 301 | break; |
560d424b | 302 | |
04a85b3b | 303 | cmdv[found++] = buf; |
560d424b MF |
304 | memcpy(buf, match->key, vallen); |
305 | buf += vallen; | |
306 | bufsz -= vallen; | |
04a85b3b WD |
307 | } |
308 | ||
560d424b MF |
309 | qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar); |
310 | ||
311 | if (idx) | |
312 | cmdv[found++] = "..."; | |
27aafe98 | 313 | |
04a85b3b WD |
314 | cmdv[found] = NULL; |
315 | return found; | |
316 | } | |
317 | #endif |