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/printk.h>
19#include <linux/stddef.h>
20#include <search.h>
21#include <errno.h>
22#include <malloc.h>
23#include <u-boot/crc.h>
24#include <dm/ofnode.h>
25#include <net.h>
26#include <watchdog.h>
27
28DECLARE_GLOBAL_DATA_PTR;
29
30/************************************************************************
31 * Default settings to be used when no valid environment is found
32 */
33#include <env_default.h>
34
35struct hsearch_data env_htab = {
36	.change_ok = env_flags_validate,
37};
38
39/*
40 * This variable is incremented each time we set an environment variable so we
41 * can be check via env_get_id() to see if the environment has changed or not.
42 * This makes it possible to reread an environment variable only if the
43 * environment was changed, typically used by networking code.
44 */
45static int env_id = 1;
46
47int env_get_id(void)
48{
49	return env_id;
50}
51
52void env_inc_id(void)
53{
54	env_id++;
55}
56
57int env_do_env_set(int flag, int argc, char *const argv[], int env_flag)
58{
59	int   i, len;
60	char  *name, *value, *s;
61	struct env_entry e, *ep;
62
63	debug("Initial value for argc=%d\n", argc);
64
65#if !IS_ENABLED(CONFIG_SPL_BUILD) && IS_ENABLED(CONFIG_CMD_NVEDIT_EFI)
66	if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e')
67		return do_env_set_efi(NULL, flag, --argc, ++argv);
68#endif
69
70	while (argc > 1 && **(argv + 1) == '-') {
71		char *arg = *++argv;
72
73		--argc;
74		while (*++arg) {
75			switch (*arg) {
76			case 'f':		/* force */
77				env_flag |= H_FORCE;
78				break;
79			default:
80				return CMD_RET_USAGE;
81			}
82		}
83	}
84	debug("Final value for argc=%d\n", argc);
85	name = argv[1];
86
87	if (strchr(name, '=')) {
88		printf("## Error: illegal character '=' "
89		       "in variable name \"%s\"\n", name);
90		return 1;
91	}
92
93	env_inc_id();
94
95	/* Delete only ? */
96	if (argc < 3 || argv[2] == NULL) {
97		int rc = hdelete_r(name, &env_htab, env_flag);
98
99		/* If the variable didn't exist, don't report an error */
100		return rc && rc != -ENOENT ? 1 : 0;
101	}
102
103	/*
104	 * Insert / replace new value
105	 */
106	for (i = 2, len = 0; i < argc; ++i)
107		len += strlen(argv[i]) + 1;
108
109	value = malloc(len);
110	if (value == NULL) {
111		printf("## Can't malloc %d bytes\n", len);
112		return 1;
113	}
114	for (i = 2, s = value; i < argc; ++i) {
115		char *v = argv[i];
116
117		while ((*s++ = *v++) != '\0')
118			;
119		*(s - 1) = ' ';
120	}
121	if (s != value)
122		*--s = '\0';
123
124	e.key	= name;
125	e.data	= value;
126	hsearch_r(e, ENV_ENTER, &ep, &env_htab, env_flag);
127	free(value);
128	if (!ep) {
129		printf("## Error inserting \"%s\" variable, errno=%d\n",
130			name, errno);
131		return 1;
132	}
133
134	return 0;
135}
136
137int env_set(const char *varname, const char *varvalue)
138{
139	const char * const argv[4] = { "setenv", varname, varvalue, NULL };
140
141	/* before import into hashtable */
142	if (!(gd->flags & GD_FLG_ENV_READY))
143		return 1;
144
145	if (varvalue == NULL || varvalue[0] == '\0')
146		return env_do_env_set(0, 2, (char * const *)argv, H_PROGRAMMATIC);
147	else
148		return env_do_env_set(0, 3, (char * const *)argv, H_PROGRAMMATIC);
149}
150
151/**
152 * Set an environment variable to an integer value
153 *
154 * @param varname	Environment variable to set
155 * @param value		Value to set it to
156 * Return: 0 if ok, 1 on error
157 */
158int env_set_ulong(const char *varname, ulong value)
159{
160	/* TODO: this should be unsigned */
161	char *str = simple_itoa(value);
162
163	return env_set(varname, str);
164}
165
166/**
167 * Set an environment variable to an value in hex
168 *
169 * @param varname	Environment variable to set
170 * @param value		Value to set it to
171 * Return: 0 if ok, 1 on error
172 */
173int env_set_hex(const char *varname, ulong value)
174{
175	char str[17];
176
177	sprintf(str, "%lx", value);
178	return env_set(varname, str);
179}
180
181ulong env_get_hex(const char *varname, ulong default_val)
182{
183	const char *s;
184	ulong value;
185	char *endp;
186
187	s = env_get(varname);
188	if (s)
189		value = hextoul(s, &endp);
190	if (!s || endp == s)
191		return default_val;
192
193	return value;
194}
195
196int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr)
197{
198	string_to_enetaddr(env_get(name), enetaddr);
199	return is_valid_ethaddr(enetaddr);
200}
201
202int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr)
203{
204	char buf[ARP_HLEN_ASCII + 1];
205
206	if (eth_env_get_enetaddr(name, (uint8_t *)buf))
207		return -EEXIST;
208
209	sprintf(buf, "%pM", enetaddr);
210
211	return env_set(name, buf);
212}
213
214/*
215 * Look up variable from environment,
216 * return address of storage for that variable,
217 * or NULL if not found
218 */
219char *env_get(const char *name)
220{
221	if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
222		struct env_entry e, *ep;
223
224		schedule();
225
226		e.key	= name;
227		e.data	= NULL;
228		hsearch_r(e, ENV_FIND, &ep, &env_htab, 0);
229
230		return ep ? ep->data : NULL;
231	}
232
233	/* restricted capabilities before import */
234	if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) >= 0)
235		return (char *)(gd->env_buf);
236
237	return NULL;
238}
239
240/*
241 * Like env_get, but prints an error if envvar isn't defined in the
242 * environment.  It always returns what env_get does, so it can be used in
243 * place of env_get without changing error handling otherwise.
244 */
245char *from_env(const char *envvar)
246{
247	char *ret;
248
249	ret = env_get(envvar);
250
251	if (!ret)
252		printf("missing environment variable: %s\n", envvar);
253
254	return ret;
255}
256
257static int env_get_from_linear(const char *env, const char *name, char *buf,
258			       unsigned len)
259{
260	const char *p, *end;
261	size_t name_len;
262
263	if (name == NULL || *name == '\0')
264		return -1;
265
266	name_len = strlen(name);
267
268	for (p = env; *p != '\0'; p = end + 1) {
269		const char *value;
270		unsigned res;
271
272		for (end = p; *end != '\0'; ++end)
273			if (end - env >= CONFIG_ENV_SIZE)
274				return -1;
275
276		if (strncmp(name, p, name_len) || p[name_len] != '=')
277			continue;
278		value = &p[name_len + 1];
279
280		res = end - value;
281		memcpy(buf, value, min(len, res + 1));
282
283		if (len <= res) {
284			buf[len - 1] = '\0';
285			printf("env_buf [%u bytes] too small for value of \"%s\"\n",
286			       len, name);
287		}
288
289		return res;
290	}
291
292	return -1;
293}
294
295/*
296 * Look up variable from environment for restricted C runtime env.
297 */
298int env_get_f(const char *name, char *buf, unsigned len)
299{
300	const char *env;
301
302	if (gd->env_valid == ENV_INVALID)
303		env = default_environment;
304	else
305		env = (const char *)gd->env_addr;
306
307	return env_get_from_linear(env, name, buf, len);
308}
309
310/**
311 * Decode the integer value of an environment variable and return it.
312 *
313 * @param name		Name of environment variable
314 * @param base		Number base to use (normally 10, or 16 for hex)
315 * @param default_val	Default value to return if the variable is not
316 *			found
317 * Return: the decoded value, or default_val if not found
318 */
319ulong env_get_ulong(const char *name, int base, ulong default_val)
320{
321	/*
322	 * We can use env_get() here, even before relocation, since the
323	 * environment variable value is an integer and thus short.
324	 */
325	const char *str = env_get(name);
326
327	return str ? simple_strtoul(str, NULL, base) : default_val;
328}
329
330/*
331 * Read an environment variable as a boolean
332 * Return -1 if variable does not exist (default to true)
333 */
334int env_get_yesno(const char *var)
335{
336	char *s = env_get(var);
337
338	if (s == NULL)
339		return -1;
340	return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
341		1 : 0;
342}
343
344bool env_get_autostart(void)
345{
346	return env_get_yesno("autostart") == 1;
347}
348
349/*
350 * Look up the variable from the default environment
351 */
352char *env_get_default(const char *name)
353{
354	int ret;
355
356	ret = env_get_default_into(name, (char *)(gd->env_buf),
357				   sizeof(gd->env_buf));
358	if (ret >= 0)
359		return (char *)(gd->env_buf);
360
361	return NULL;
362}
363
364/*
365 * Look up the variable from the default environment and store its value in buf
366 */
367int env_get_default_into(const char *name, char *buf, unsigned int len)
368{
369	return env_get_from_linear(default_environment, name, buf, len);
370}
371
372void env_set_default(const char *s, int flags)
373{
374	if (s) {
375		if ((flags & H_INTERACTIVE) == 0) {
376			printf("*** Warning - %s, "
377				"using default environment\n\n", s);
378		} else {
379			puts(s);
380		}
381	} else {
382		debug("Using default environment\n");
383	}
384
385	flags |= H_DEFAULT;
386	if (himport_r(&env_htab, default_environment,
387			sizeof(default_environment), '\0', flags, 0,
388			0, NULL) == 0) {
389		pr_err("## Error: Environment import failed: errno = %d\n",
390		       errno);
391		return;
392	}
393
394	gd->flags |= GD_FLG_ENV_READY;
395	gd->flags |= GD_FLG_ENV_DEFAULT;
396}
397
398
399/* [re]set individual variables to their value in the default environment */
400int env_set_default_vars(int nvars, char * const vars[], int flags)
401{
402	/*
403	 * Special use-case: import from default environment
404	 * (and use \0 as a separator)
405	 */
406	flags |= H_NOCLEAR | H_DEFAULT;
407	return himport_r(&env_htab, default_environment,
408				sizeof(default_environment), '\0',
409				flags, 0, nvars, vars);
410}
411
412/*
413 * Check if CRC is valid and (if yes) import the environment.
414 * Note that "buf" may or may not be aligned.
415 */
416int env_import(const char *buf, int check, int flags)
417{
418	env_t *ep = (env_t *)buf;
419
420	if (check) {
421		uint32_t crc;
422
423		memcpy(&crc, &ep->crc, sizeof(crc));
424
425		if (crc32(0, ep->data, ENV_SIZE) != crc) {
426			env_set_default("bad CRC", 0);
427			return -ENOMSG; /* needed for env_load() */
428		}
429	}
430
431	if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
432			0, NULL)) {
433		gd->flags |= GD_FLG_ENV_READY;
434		return 0;
435	}
436
437	pr_err("Cannot import environment: errno = %d\n", errno);
438
439	env_set_default("import failed", 0);
440
441	return -EIO;
442}
443
444#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
445static unsigned char env_flags;
446
447int env_check_redund(const char *buf1, int buf1_read_fail,
448		     const char *buf2, int buf2_read_fail)
449{
450	int crc1_ok = 0, crc2_ok = 0;
451	env_t *tmp_env1, *tmp_env2;
452
453	tmp_env1 = (env_t *)buf1;
454	tmp_env2 = (env_t *)buf2;
455
456	if (buf1_read_fail && buf2_read_fail) {
457		puts("*** Error - No Valid Environment Area found\n");
458		return -EIO;
459	} else if (buf1_read_fail || buf2_read_fail) {
460		puts("*** Warning - some problems detected ");
461		puts("reading environment; recovered successfully\n");
462	}
463
464	if (!buf1_read_fail)
465		crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
466				tmp_env1->crc;
467	if (!buf2_read_fail)
468		crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
469				tmp_env2->crc;
470
471	if (!crc1_ok && !crc2_ok) {
472		gd->env_valid = ENV_INVALID;
473		return -ENOMSG; /* needed for env_load() */
474	} else if (crc1_ok && !crc2_ok) {
475		gd->env_valid = ENV_VALID;
476	} else if (!crc1_ok && crc2_ok) {
477		gd->env_valid = ENV_REDUND;
478	} else {
479		/* both ok - check serial */
480		if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
481			gd->env_valid = ENV_REDUND;
482		else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
483			gd->env_valid = ENV_VALID;
484		else if (tmp_env1->flags > tmp_env2->flags)
485			gd->env_valid = ENV_VALID;
486		else if (tmp_env2->flags > tmp_env1->flags)
487			gd->env_valid = ENV_REDUND;
488		else /* flags are equal - almost impossible */
489			gd->env_valid = ENV_VALID;
490	}
491
492	return 0;
493}
494
495int env_import_redund(const char *buf1, int buf1_read_fail,
496		      const char *buf2, int buf2_read_fail,
497		      int flags)
498{
499	env_t *ep;
500	int ret;
501
502	ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
503
504	if (ret == -EIO) {
505		env_set_default("bad env area", 0);
506		return -EIO;
507	} else if (ret == -ENOMSG) {
508		env_set_default("bad CRC", 0);
509		return -ENOMSG;
510	}
511
512	if (gd->env_valid == ENV_VALID)
513		ep = (env_t *)buf1;
514	else
515		ep = (env_t *)buf2;
516
517	env_flags = ep->flags;
518
519	return env_import((char *)ep, 0, flags);
520}
521#endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
522
523/* Export the environment and generate CRC for it. */
524int env_export(env_t *env_out)
525{
526	char *res;
527	ssize_t	len;
528
529	res = (char *)env_out->data;
530	len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
531	if (len < 0) {
532		pr_err("Cannot export environment: errno = %d\n", errno);
533		return 1;
534	}
535
536	env_out->crc = crc32(0, env_out->data, ENV_SIZE);
537
538#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
539	env_out->flags = ++env_flags; /* increase the serial */
540#endif
541
542	return 0;
543}
544
545void env_relocate(void)
546{
547	if (gd->env_valid == ENV_INVALID) {
548#if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
549		/* Environment not changable */
550		env_set_default(NULL, 0);
551#else
552		bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
553		env_set_default("bad CRC", 0);
554#endif
555	} else {
556		env_load();
557	}
558}
559
560#ifdef CONFIG_AUTO_COMPLETE
561int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
562		 bool dollar_comp)
563{
564	struct env_entry *match;
565	int found, idx;
566
567	if (dollar_comp) {
568		/*
569		 * When doing $ completion, the first character should
570		 * obviously be a '$'.
571		 */
572		if (var[0] != '$')
573			return 0;
574
575		var++;
576
577		/*
578		 * The second one, if present, should be a '{', as some
579		 * configuration of the u-boot shell expand ${var} but not
580		 * $var.
581		 */
582		if (var[0] == '{')
583			var++;
584		else if (var[0] != '\0')
585			return 0;
586	}
587
588	idx = 0;
589	found = 0;
590	cmdv[0] = NULL;
591
592
593	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
594		int vallen = strlen(match->key) + 1;
595
596		if (found >= maxv - 2 ||
597		    bufsz < vallen + (dollar_comp ? 3 : 0))
598			break;
599
600		cmdv[found++] = buf;
601
602		/* Add the '${' prefix to each var when doing $ completion. */
603		if (dollar_comp) {
604			strcpy(buf, "${");
605			buf += 2;
606			bufsz -= 3;
607		}
608
609		memcpy(buf, match->key, vallen);
610		buf += vallen;
611		bufsz -= vallen;
612
613		if (dollar_comp) {
614			/*
615			 * This one is a bit odd: vallen already contains the
616			 * '\0' character but we need to add the '}' suffix,
617			 * hence the buf - 1 here. strcpy() will add the '\0'
618			 * character just after '}'. buf is then incremented
619			 * to account for the extra '}' we just added.
620			 */
621			strcpy(buf - 1, "}");
622			buf++;
623		}
624	}
625
626	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
627
628	if (idx)
629		cmdv[found++] = dollar_comp ? "${...}" : "...";
630
631	cmdv[found] = NULL;
632	return found;
633}
634#endif
635
636#ifdef CONFIG_ENV_IMPORT_FDT
637void env_import_fdt(void)
638{
639	const char *path;
640	struct ofprop prop;
641	ofnode node;
642	int res;
643
644	path = env_get("env_fdt_path");
645	if (!path || !path[0])
646		return;
647
648	node = ofnode_path(path);
649	if (!ofnode_valid(node)) {
650		printf("Warning: device tree node '%s' not found\n", path);
651		return;
652	}
653
654	for (res = ofnode_first_property(node, &prop);
655	     !res;
656	     res = ofnode_next_property(&prop)) {
657		const char *name, *val;
658
659		val = ofprop_get_property(&prop, &name, NULL);
660		env_set(name, val);
661	}
662}
663#endif
664