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 <bootstage.h>
12 #include <command.h>
13 #include <env.h>
14 #include <env_internal.h>
15 #include <log.h>
16 #include <sort.h>
17 #include <asm/global_data.h>
18 #include <linux/stddef.h>
19 #include <search.h>
20 #include <errno.h>
21 #include <malloc.h>
22 #include <u-boot/crc.h>
23 #include <dm/ofnode.h>
24
25 DECLARE_GLOBAL_DATA_PTR;
26
27 /************************************************************************
28 * Default settings to be used when no valid environment is found
29 */
30 #include <env_default.h>
31
32 struct hsearch_data env_htab = {
33 .change_ok = env_flags_validate,
34 };
35
36 /*
37 * Read an environment variable as a boolean
38 * Return -1 if variable does not exist (default to true)
39 */
env_get_yesno(const char * var)40 int env_get_yesno(const char *var)
41 {
42 char *s = env_get(var);
43
44 if (s == NULL)
45 return -1;
46 return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
47 1 : 0;
48 }
49
50 /*
51 * Look up the variable from the default environment
52 */
env_get_default(const char * name)53 char *env_get_default(const char *name)
54 {
55 char *ret_val;
56 unsigned long really_valid = gd->env_valid;
57 unsigned long real_gd_flags = gd->flags;
58
59 /* Pretend that the image is bad. */
60 gd->flags &= ~GD_FLG_ENV_READY;
61 gd->env_valid = ENV_INVALID;
62 ret_val = env_get(name);
63 gd->env_valid = really_valid;
64 gd->flags = real_gd_flags;
65 return ret_val;
66 }
67
env_set_default(const char * s,int flags)68 void env_set_default(const char *s, int flags)
69 {
70 if (sizeof(default_environment) > ENV_SIZE) {
71 puts("*** Error - default environment is too large\n\n");
72 return;
73 }
74
75 if (s) {
76 if ((flags & H_INTERACTIVE) == 0) {
77 printf("*** Warning - %s, "
78 "using default environment\n\n", s);
79 } else {
80 puts(s);
81 }
82 } else {
83 debug("Using default environment\n");
84 }
85
86 flags |= H_DEFAULT;
87 if (himport_r(&env_htab, (char *)default_environment,
88 sizeof(default_environment), '\0', flags, 0,
89 0, NULL) == 0)
90 pr_err("## Error: Environment import failed: errno = %d\n",
91 errno);
92
93 gd->flags |= GD_FLG_ENV_READY;
94 gd->flags |= GD_FLG_ENV_DEFAULT;
95 }
96
97
98 /* [re]set individual variables to their value in the default environment */
env_set_default_vars(int nvars,char * const vars[],int flags)99 int env_set_default_vars(int nvars, char * const vars[], int flags)
100 {
101 /*
102 * Special use-case: import from default environment
103 * (and use \0 as a separator)
104 */
105 flags |= H_NOCLEAR | H_DEFAULT;
106 return himport_r(&env_htab, (const char *)default_environment,
107 sizeof(default_environment), '\0',
108 flags, 0, nvars, vars);
109 }
110
111 /*
112 * Check if CRC is valid and (if yes) import the environment.
113 * Note that "buf" may or may not be aligned.
114 */
env_import(const char * buf,int check,int flags)115 int env_import(const char *buf, int check, int flags)
116 {
117 env_t *ep = (env_t *)buf;
118
119 if (check) {
120 uint32_t crc;
121
122 memcpy(&crc, &ep->crc, sizeof(crc));
123
124 if (crc32(0, ep->data, ENV_SIZE) != crc) {
125 env_set_default("bad CRC", 0);
126 return -ENOMSG; /* needed for env_load() */
127 }
128 }
129
130 if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
131 0, NULL)) {
132 gd->flags |= GD_FLG_ENV_READY;
133 return 0;
134 }
135
136 pr_err("Cannot import environment: errno = %d\n", errno);
137
138 env_set_default("import failed", 0);
139
140 return -EIO;
141 }
142
143 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
144 static unsigned char env_flags;
145
env_check_redund(const char * buf1,int buf1_read_fail,const char * buf2,int buf2_read_fail)146 int env_check_redund(const char *buf1, int buf1_read_fail,
147 const char *buf2, int buf2_read_fail)
148 {
149 int crc1_ok = 0, crc2_ok = 0;
150 env_t *tmp_env1, *tmp_env2;
151
152 tmp_env1 = (env_t *)buf1;
153 tmp_env2 = (env_t *)buf2;
154
155 if (buf1_read_fail && buf2_read_fail) {
156 puts("*** Error - No Valid Environment Area found\n");
157 return -EIO;
158 } else if (buf1_read_fail || buf2_read_fail) {
159 puts("*** Warning - some problems detected ");
160 puts("reading environment; recovered successfully\n");
161 }
162
163 if (!buf1_read_fail)
164 crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
165 tmp_env1->crc;
166 if (!buf2_read_fail)
167 crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
168 tmp_env2->crc;
169
170 if (!crc1_ok && !crc2_ok) {
171 return -ENOMSG; /* needed for env_load() */
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 return 0;
191 }
192
env_import_redund(const char * buf1,int buf1_read_fail,const char * buf2,int buf2_read_fail,int flags)193 int env_import_redund(const char *buf1, int buf1_read_fail,
194 const char *buf2, int buf2_read_fail,
195 int flags)
196 {
197 env_t *ep;
198 int ret;
199
200 ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
201
202 if (ret == -EIO) {
203 env_set_default("bad env area", 0);
204 return -EIO;
205 } else if (ret == -ENOMSG) {
206 env_set_default("bad CRC", 0);
207 return -ENOMSG;
208 }
209
210 if (gd->env_valid == ENV_VALID)
211 ep = (env_t *)buf1;
212 else
213 ep = (env_t *)buf2;
214
215 env_flags = ep->flags;
216
217 return env_import((char *)ep, 0, flags);
218 }
219 #endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
220
221 /* Export the environment and generate CRC for it. */
env_export(env_t * env_out)222 int env_export(env_t *env_out)
223 {
224 char *res;
225 ssize_t len;
226
227 res = (char *)env_out->data;
228 len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
229 if (len < 0) {
230 pr_err("Cannot export environment: errno = %d\n", errno);
231 return 1;
232 }
233
234 env_out->crc = crc32(0, env_out->data, ENV_SIZE);
235
236 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
237 env_out->flags = ++env_flags; /* increase the serial */
238 #endif
239
240 return 0;
241 }
242
env_relocate(void)243 void env_relocate(void)
244 {
245 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
246 env_reloc();
247 env_fix_drivers();
248 env_htab.change_ok += gd->reloc_off;
249 #endif
250 if (gd->env_valid == ENV_INVALID) {
251 #if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
252 /* Environment not changable */
253 env_set_default(NULL, 0);
254 #else
255 bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
256 env_set_default("bad CRC", 0);
257 #endif
258 } else {
259 env_load();
260 }
261 }
262
263 #ifdef CONFIG_AUTO_COMPLETE
env_complete(char * var,int maxv,char * cmdv[],int bufsz,char * buf,bool dollar_comp)264 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
265 bool dollar_comp)
266 {
267 struct env_entry *match;
268 int found, idx;
269
270 if (dollar_comp) {
271 /*
272 * When doing $ completion, the first character should
273 * obviously be a '$'.
274 */
275 if (var[0] != '$')
276 return 0;
277
278 var++;
279
280 /*
281 * The second one, if present, should be a '{', as some
282 * configuration of the u-boot shell expand ${var} but not
283 * $var.
284 */
285 if (var[0] == '{')
286 var++;
287 else if (var[0] != '\0')
288 return 0;
289 }
290
291 idx = 0;
292 found = 0;
293 cmdv[0] = NULL;
294
295
296 while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
297 int vallen = strlen(match->key) + 1;
298
299 if (found >= maxv - 2 ||
300 bufsz < vallen + (dollar_comp ? 3 : 0))
301 break;
302
303 cmdv[found++] = buf;
304
305 /* Add the '${' prefix to each var when doing $ completion. */
306 if (dollar_comp) {
307 strcpy(buf, "${");
308 buf += 2;
309 bufsz -= 3;
310 }
311
312 memcpy(buf, match->key, vallen);
313 buf += vallen;
314 bufsz -= vallen;
315
316 if (dollar_comp) {
317 /*
318 * This one is a bit odd: vallen already contains the
319 * '\0' character but we need to add the '}' suffix,
320 * hence the buf - 1 here. strcpy() will add the '\0'
321 * character just after '}'. buf is then incremented
322 * to account for the extra '}' we just added.
323 */
324 strcpy(buf - 1, "}");
325 buf++;
326 }
327 }
328
329 qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
330
331 if (idx)
332 cmdv[found++] = dollar_comp ? "${...}" : "...";
333
334 cmdv[found] = NULL;
335 return found;
336 }
337 #endif
338
339 #ifdef CONFIG_ENV_IMPORT_FDT
env_import_fdt(void)340 void env_import_fdt(void)
341 {
342 const char *path;
343 struct ofprop prop;
344 ofnode node;
345 int res;
346
347 path = env_get("env_fdt_path");
348 if (!path || !path[0])
349 return;
350
351 node = ofnode_path(path);
352 if (!ofnode_valid(node)) {
353 printf("Warning: device tree node '%s' not found\n", path);
354 return;
355 }
356
357 for (res = ofnode_get_first_property(node, &prop);
358 !res;
359 res = ofnode_get_next_property(&prop)) {
360 const char *name, *val;
361
362 val = ofnode_get_property_by_prop(&prop, &name, NULL);
363 env_set(name, val);
364 }
365 }
366 #endif
367