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