[u-boot.git] / env / common.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2000-2010
 * Wolfgang Denk, DENX Software Engineering, [email protected].
 *
 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
 * Andreas Heppel <[email protected]>
 */

#include <common.h>
#include <bootstage.h>
#include <command.h>
#include <env.h>
#include <env_internal.h>
#include <log.h>
#include <sort.h>
#include <asm/global_data.h>
#include <linux/stddef.h>
#include <search.h>
#include <errno.h>
#include <malloc.h>
#include <u-boot/crc.h>

DECLARE_GLOBAL_DATA_PTR;

/************************************************************************
 * Default settings to be used when no valid environment is found
 */
#include <env_default.h>

struct hsearch_data env_htab = {
	.change_ok = env_flags_validate,
};

/*
 * Read an environment variable as a boolean
 * Return -1 if variable does not exist (default to true)
 */
int env_get_yesno(const char *var)
{
	char *s = env_get(var);

	if (s == NULL)
		return -1;
	return (*s == '1' || *s == 'y' || *s == 'Y' || *s == 't' || *s == 'T') ?
		1 : 0;
}

/*
 * Look up the variable from the default environment
 */
char *env_get_default(const char *name)
{
	char *ret_val;
	unsigned long really_valid = gd->env_valid;
	unsigned long real_gd_flags = gd->flags;

	/* Pretend that the image is bad. */
	gd->flags &= ~GD_FLG_ENV_READY;
	gd->env_valid = ENV_INVALID;
	ret_val = env_get(name);
	gd->env_valid = really_valid;
	gd->flags = real_gd_flags;
	return ret_val;
}

void env_set_default(const char *s, int flags)
{
	if (sizeof(default_environment) > ENV_SIZE) {
		puts("*** Error - default environment is too large\n\n");
		return;
	}

	if (s) {
		if ((flags & H_INTERACTIVE) == 0) {
			printf("*** Warning - %s, "
				"using default environment\n\n", s);
		} else {
			puts(s);
		}
	} else {
		debug("Using default environment\n");
	}

	flags |= H_DEFAULT;
	if (himport_r(&env_htab, (char *)default_environment,
			sizeof(default_environment), '\0', flags, 0,
			0, NULL) == 0)
		pr_err("## Error: Environment import failed: errno = %d\n",
		       errno);

	gd->flags |= GD_FLG_ENV_READY;
	gd->flags |= GD_FLG_ENV_DEFAULT;
}


/* [re]set individual variables to their value in the default environment */
int env_set_default_vars(int nvars, char * const vars[], int flags)
{
	/*
	 * Special use-case: import from default environment
	 * (and use \0 as a separator)
	 */
	flags |= H_NOCLEAR | H_DEFAULT;
	return himport_r(&env_htab, (const char *)default_environment,
				sizeof(default_environment), '\0',
				flags, 0, nvars, vars);
}

/*
 * Check if CRC is valid and (if yes) import the environment.
 * Note that "buf" may or may not be aligned.
 */
int env_import(const char *buf, int check, int flags)
{
	env_t *ep = (env_t *)buf;

	if (check) {
		uint32_t crc;

		memcpy(&crc, &ep->crc, sizeof(crc));

		if (crc32(0, ep->data, ENV_SIZE) != crc) {
			env_set_default("bad CRC", 0);
			return -ENOMSG; /* needed for env_load() */
		}
	}

	if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
			0, NULL)) {
		gd->flags |= GD_FLG_ENV_READY;
		return 0;
	}

	pr_err("Cannot import environment: errno = %d\n", errno);

	env_set_default("import failed", 0);

	return -EIO;
}

#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
static unsigned char env_flags;

int env_check_redund(const char *buf1, int buf1_read_fail,
		     const char *buf2, int buf2_read_fail)
{
	int crc1_ok, crc2_ok;
	env_t *tmp_env1, *tmp_env2;

	tmp_env1 = (env_t *)buf1;
	tmp_env2 = (env_t *)buf2;

	if (buf1_read_fail && buf2_read_fail) {
		puts("*** Error - No Valid Environment Area found\n");
	} else if (buf1_read_fail || buf2_read_fail) {
		puts("*** Warning - some problems detected ");
		puts("reading environment; recovered successfully\n");
	}

	if (buf1_read_fail && buf2_read_fail) {
		return -EIO;
	} else if (!buf1_read_fail && buf2_read_fail) {
		gd->env_valid = ENV_VALID;
		return -EINVAL;
	} else if (buf1_read_fail && !buf2_read_fail) {
		gd->env_valid = ENV_REDUND;
		return -ENOENT;
	}

	crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
			tmp_env1->crc;
	crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
			tmp_env2->crc;

	if (!crc1_ok && !crc2_ok) {
		return -ENOMSG; /* needed for env_load() */
	} else if (crc1_ok && !crc2_ok) {
		gd->env_valid = ENV_VALID;
	} else if (!crc1_ok && crc2_ok) {
		gd->env_valid = ENV_REDUND;
	} else {
		/* both ok - check serial */
		if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
			gd->env_valid = ENV_REDUND;
		else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
			gd->env_valid = ENV_VALID;
		else if (tmp_env1->flags > tmp_env2->flags)
			gd->env_valid = ENV_VALID;
		else if (tmp_env2->flags > tmp_env1->flags)
			gd->env_valid = ENV_REDUND;
		else /* flags are equal - almost impossible */
			gd->env_valid = ENV_VALID;
	}

	return 0;
}

int env_import_redund(const char *buf1, int buf1_read_fail,
		      const char *buf2, int buf2_read_fail,
		      int flags)
{
	env_t *ep;
	int ret;

	ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);

	if (ret == -EIO) {
		env_set_default("bad env area", 0);
		return -EIO;
	} else if (ret == -EINVAL) {
		return env_import((char *)buf1, 1, flags);
	} else if (ret == -ENOENT) {
		return env_import((char *)buf2, 1, flags);
	} else if (ret == -ENOMSG) {
		env_set_default("bad CRC", 0);
		return -ENOMSG;
	}

	if (gd->env_valid == ENV_VALID)
		ep = (env_t *)buf1;
	else
		ep = (env_t *)buf2;

	env_flags = ep->flags;

	return env_import((char *)ep, 0, flags);
}
#endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */

/* Export the environment and generate CRC for it. */
int env_export(env_t *env_out)
{
	char *res;
	ssize_t	len;

	res = (char *)env_out->data;
	len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
	if (len < 0) {
		pr_err("Cannot export environment: errno = %d\n", errno);
		return 1;
	}

	env_out->crc = crc32(0, env_out->data, ENV_SIZE);

#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
	env_out->flags = ++env_flags; /* increase the serial */
#endif

	return 0;
}

void env_relocate(void)
{
#if defined(CONFIG_NEEDS_MANUAL_RELOC)
	env_reloc();
	env_fix_drivers();
	env_htab.change_ok += gd->reloc_off;
#endif
	if (gd->env_valid == ENV_INVALID) {
#if defined(CONFIG_ENV_IS_NOWHERE) || defined(CONFIG_SPL_BUILD)
		/* Environment not changable */
		env_set_default(NULL, 0);
#else
		bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
		env_set_default("bad CRC", 0);
#endif
	} else {
		env_load();
	}
}

#ifdef CONFIG_AUTO_COMPLETE
int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf,
		 bool dollar_comp)
{
	struct env_entry *match;
	int found, idx;

	if (dollar_comp) {
		/*
		 * When doing $ completion, the first character should
		 * obviously be a '$'.
		 */
		if (var[0] != '$')
			return 0;

		var++;

		/*
		 * The second one, if present, should be a '{', as some
		 * configuration of the u-boot shell expand ${var} but not
		 * $var.
		 */
		if (var[0] == '{')
			var++;
		else if (var[0] != '\0')
			return 0;
	}

	idx = 0;
	found = 0;
	cmdv[0] = NULL;


	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
		int vallen = strlen(match->key) + 1;

		if (found >= maxv - 2 ||
		    bufsz < vallen + (dollar_comp ? 3 : 0))
			break;

		cmdv[found++] = buf;

		/* Add the '${' prefix to each var when doing $ completion. */
		if (dollar_comp) {
			strcpy(buf, "${");
			buf += 2;
			bufsz -= 3;
		}

		memcpy(buf, match->key, vallen);
		buf += vallen;
		bufsz -= vallen;

		if (dollar_comp) {
			/*
			 * This one is a bit odd: vallen already contains the
			 * '\0' character but we need to add the '}' suffix,
			 * hence the buf - 1 here. strcpy() will add the '\0'
			 * character just after '}'. buf is then incremented
			 * to account for the extra '}' we just added.
			 */
			strcpy(buf - 1, "}");
			buf++;
		}
	}

	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);

	if (idx)
		cmdv[found++] = dollar_comp ? "${...}" : "...";

	cmdv[found] = NULL;
	return found;
}
#endif
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
05706fdd	2	/*
ea882baf	3	* (C) Copyright 2000-2010
05706fdd WD	4	* Wolfgang Denk, DENX Software Engineering, [email protected].
	5	*
	6	* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
	7	* Andreas Heppel <[email protected]>
05706fdd WD	8	*/
	9
	10	#include <common.h>
52f24238	11	#include <bootstage.h>
05706fdd	12	#include <command.h>
3f989e7b	13	#include <env.h>
f3998fdc	14	#include <env_internal.h>
f7ae49fc	15	#include <log.h>
8bef79bf	16	#include <sort.h>
401d1c4f	17	#include <asm/global_data.h>
05706fdd	18	#include <linux/stddef.h>
ea882baf WD	19	#include <search.h>
ea882baf WD	20	#include <errno.h>
05706fdd	21	#include <malloc.h>
3db71108	22	#include <u-boot/crc.h>
05706fdd	23
d87080b7 WD	24	DECLARE_GLOBAL_DATA_PTR;
d87080b7 WD	25
05706fdd WD	26	/************************************************************************
	27	* Default settings to be used when no valid environment is found
	28	*/
ddd8418f	29	#include <env_default.h>
05706fdd	30
c5983592	31	struct hsearch_data env_htab = {
2598090b	32	.change_ok = env_flags_validate,
c5983592	33	};
2eb1573f	34
ec8a252c JH	35	/*
	36	* Read an environment variable as a boolean
	37	* Return -1 if variable does not exist (default to true)
	38	*/
bfebc8c9	39	int env_get_yesno(const char *var)
ec8a252c	40	{
00caae6d	41	char *s = env_get(var);
ec8a252c JH	42
	43	if (s == NULL)
	44	return -1;
	45	return (s == '1' \|\| s == 'y' \|\| s == 'Y' \|\| s == 't' \|\| *s == 'T') ?
	46	1 : 0;
	47	}
	48
267541f7 JH	49	/*
	50	* Look up the variable from the default environment
	51	*/
723806cc	52	char env_get_default(const char name)
267541f7 JH	53	{
	54	char *ret_val;
	55	unsigned long really_valid = gd->env_valid;
	56	unsigned long real_gd_flags = gd->flags;
	57
	58	/* Pretend that the image is bad. */
	59	gd->flags &= ~GD_FLG_ENV_READY;
2d7cb5b4	60	gd->env_valid = ENV_INVALID;
00caae6d	61	ret_val = env_get(name);
267541f7 JH	62	gd->env_valid = really_valid;
	63	gd->flags = real_gd_flags;
	64	return ret_val;
	65	}
	66
0ac7d722	67	void env_set_default(const char *s, int flags)
5bb12dbd HW	68	{
5bb12dbd HW	69	if (sizeof(default_environment) > ENV_SIZE) {
ea882baf	70	puts("*** Error - default environment is too large\n\n");
5bb12dbd HW	71	return;
	72	}
	73
ea882baf	74	if (s) {
c5d548a9	75	if ((flags & H_INTERACTIVE) == 0) {
ea882baf	76	printf("*** Warning - %s, "
c5d548a9	77	"using default environment\n\n", s);
ea882baf WD	78	} else {
	79	puts(s);
	80	}
	81	} else {
58ae9990	82	debug("Using default environment\n");
ea882baf WD	83	}
ea882baf WD	84
ef9bef2b	85	flags \|= H_DEFAULT;
2eb1573f	86	if (himport_r(&env_htab, (char *)default_environment,
ecd1446f	87	sizeof(default_environment), '\0', flags, 0,
c4e0057f	88	0, NULL) == 0)
6c90f623 QS	89	pr_err("## Error: Environment import failed: errno = %d\n",
6c90f623 QS	90	errno);
27aafe98	91
ea882baf	92	gd->flags \|= GD_FLG_ENV_READY;
340b0e3b	93	gd->flags \|= GD_FLG_ENV_DEFAULT;
5bb12dbd HW	94	}
5bb12dbd HW	95
b64b7c3d GF	96
b64b7c3d GF	97	/* [re]set individual variables to their value in the default environment */
0b9d8a05	98	int env_set_default_vars(int nvars, char * const vars[], int flags)
b64b7c3d GF	99	{
	100	/*
	101	* Special use-case: import from default environment
	102	* (and use \0 as a separator)
	103	*/
ef9bef2b	104	flags \|= H_NOCLEAR \| H_DEFAULT;
b64b7c3d	105	return himport_r(&env_htab, (const char *)default_environment,
c4e0057f	106	sizeof(default_environment), '\0',
477f8116	107	flags, 0, nvars, vars);
b64b7c3d GF	108	}
b64b7c3d GF	109
ea882baf WD	110	/*
	111	* Check if CRC is valid and (if yes) import the environment.
	112	* Note that "buf" may or may not be aligned.
	113	*/
890feeca	114	int env_import(const char *buf, int check, int flags)
05706fdd	115	{
ea882baf	116	env_t ep = (env_t )buf;
05706fdd	117
ea882baf WD	118	if (check) {
	119	uint32_t crc;
	120
	121	memcpy(&crc, &ep->crc, sizeof(crc));
	122
	123	if (crc32(0, ep->data, ENV_SIZE) != crc) {
0ac7d722	124	env_set_default("bad CRC", 0);
49d04c58	125	return -ENOMSG; /* needed for env_load() */
ea882baf WD	126	}
	127	}
	128
890feeca	129	if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', flags, 0,
c4e0057f	130	0, NULL)) {
ea882baf	131	gd->flags \|= GD_FLG_ENV_READY;
42a1820b	132	return 0;
ea882baf	133	}
05706fdd	134
9b643e31	135	pr_err("Cannot import environment: errno = %d\n", errno);
ea882baf	136
0ac7d722	137	env_set_default("import failed", 0);
ea882baf	138
42a1820b	139	return -EIO;
ea882baf WD	140	}
ea882baf WD	141
76768f5f FA	142	#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
	143	static unsigned char env_flags;
	144
1229533a HS	145	int env_check_redund(const char *buf1, int buf1_read_fail,
1229533a HS	146	const char *buf2, int buf2_read_fail)
76768f5f FA	147	{
76768f5f FA	148	int crc1_ok, crc2_ok;
1229533a	149	env_t tmp_env1, tmp_env2;
76768f5f FA	150
	151	tmp_env1 = (env_t *)buf1;
	152	tmp_env2 = (env_t *)buf2;
	153
31f044bd SG	154	if (buf1_read_fail && buf2_read_fail) {
	155	puts("*** Error - No Valid Environment Area found\n");
	156	} else if (buf1_read_fail \|\| buf2_read_fail) {
	157	puts("*** Warning - some problems detected ");
	158	puts("reading environment; recovered successfully\n");
	159	}
	160
	161	if (buf1_read_fail && buf2_read_fail) {
31f044bd SG	162	return -EIO;
	163	} else if (!buf1_read_fail && buf2_read_fail) {
	164	gd->env_valid = ENV_VALID;
1229533a	165	return -EINVAL;
31f044bd SG	166	} else if (buf1_read_fail && !buf2_read_fail) {
31f044bd SG	167	gd->env_valid = ENV_REDUND;
1229533a	168	return -ENOENT;
31f044bd SG	169	}
31f044bd SG	170
76768f5f FA	171	crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
	172	tmp_env1->crc;
	173	crc2_ok = crc32(0, tmp_env2->data, ENV_SIZE) ==
	174	tmp_env2->crc;
	175
	176	if (!crc1_ok && !crc2_ok) {
49d04c58	177	return -ENOMSG; /* needed for env_load() */
76768f5f	178	} else if (crc1_ok && !crc2_ok) {
2d7cb5b4	179	gd->env_valid = ENV_VALID;
76768f5f	180	} else if (!crc1_ok && crc2_ok) {
2d7cb5b4	181	gd->env_valid = ENV_REDUND;
76768f5f FA	182	} else {
	183	/* both ok - check serial */
	184	if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
2d7cb5b4	185	gd->env_valid = ENV_REDUND;
76768f5f	186	else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
2d7cb5b4	187	gd->env_valid = ENV_VALID;
76768f5f	188	else if (tmp_env1->flags > tmp_env2->flags)
2d7cb5b4	189	gd->env_valid = ENV_VALID;
76768f5f	190	else if (tmp_env2->flags > tmp_env1->flags)
2d7cb5b4	191	gd->env_valid = ENV_REDUND;
76768f5f	192	else /* flags are equal - almost impossible */
2d7cb5b4	193	gd->env_valid = ENV_VALID;
76768f5f FA	194	}
76768f5f FA	195
1229533a HS	196	return 0;
	197	}
	198
	199	int env_import_redund(const char *buf1, int buf1_read_fail,
	200	const char *buf2, int buf2_read_fail,
	201	int flags)
	202	{
	203	env_t *ep;
	204	int ret;
	205
	206	ret = env_check_redund(buf1, buf1_read_fail, buf2, buf2_read_fail);
	207
	208	if (ret == -EIO) {
	209	env_set_default("bad env area", 0);
	210	return -EIO;
	211	} else if (ret == -EINVAL) {
	212	return env_import((char *)buf1, 1, flags);
	213	} else if (ret == -ENOENT) {
	214	return env_import((char *)buf2, 1, flags);
	215	} else if (ret == -ENOMSG) {
	216	env_set_default("bad CRC", 0);
	217	return -ENOMSG;
	218	}
	219
2d7cb5b4	220	if (gd->env_valid == ENV_VALID)
1229533a	221	ep = (env_t *)buf1;
76768f5f	222	else
1229533a	223	ep = (env_t *)buf2;
76768f5f FA	224
76768f5f FA	225	env_flags = ep->flags;
1229533a	226
890feeca	227	return env_import((char *)ep, 0, flags);
76768f5f FA	228	}
	229	#endif /* CONFIG_SYS_REDUNDAND_ENVIRONMENT */
	230
fc0b5948	231	/* Export the environment and generate CRC for it. */
7ce1526e MV	232	int env_export(env_t *env_out)
	233	{
	234	char *res;
	235	ssize_t len;
	236
	237	res = (char *)env_out->data;
	238	len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
	239	if (len < 0) {
9b643e31	240	pr_err("Cannot export environment: errno = %d\n", errno);
7ce1526e MV	241	return 1;
7ce1526e MV	242	}
a4223b74	243
7ce1526e MV	244	env_out->crc = crc32(0, env_out->data, ENV_SIZE);
7ce1526e MV	245
76768f5f FA	246	#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
	247	env_out->flags = ++env_flags; /* increase the serial */
	248	#endif
	249
7ce1526e MV	250	return 0;
	251	}
	252
27aafe98	253	void env_relocate(void)
ea882baf	254	{
2e5167cc	255	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
60f7da1f	256	env_reloc();
7bcdf195	257	env_fix_drivers();
d90fc9c3	258	env_htab.change_ok += gd->reloc_off;
60f7da1f	259	#endif
2d7cb5b4	260	if (gd->env_valid == ENV_INVALID) {
7ac2fe2d IY	261	#if defined(CONFIG_ENV_IS_NOWHERE) \|\| defined(CONFIG_SPL_BUILD)
7ac2fe2d IY	262	/* Environment not changable */
0ac7d722	263	env_set_default(NULL, 0);
05706fdd	264	#else
770605e4	265	bootstage_error(BOOTSTAGE_ID_NET_CHECKSUM);
0ac7d722	266	env_set_default("bad CRC", 0);
d259079d	267	#endif
ea882baf	268	} else {
310fb14b	269	env_load();
05706fdd	270	}
05706fdd	271	}
04a85b3b	272
03dcf17d BB	273	#ifdef CONFIG_AUTO_COMPLETE
	274	int env_complete(char var, int maxv, char cmdv[], int bufsz, char *buf,
	275	bool dollar_comp)
04a85b3b	276	{
dd2408ca	277	struct env_entry *match;
560d424b	278	int found, idx;
04a85b3b	279
03dcf17d BB	280	if (dollar_comp) {
	281	/*
	282	* When doing $ completion, the first character should
	283	* obviously be a '$'.
	284	*/
	285	if (var[0] != '$')
	286	return 0;
	287
	288	var++;
	289
	290	/*
	291	* The second one, if present, should be a '{', as some
	292	* configuration of the u-boot shell expand ${var} but not
	293	* $var.
	294	*/
	295	if (var[0] == '{')
	296	var++;
	297	else if (var[0] != '\0')
	298	return 0;
	299	}
	300
560d424b	301	idx = 0;
04a85b3b WD	302	found = 0;
	303	cmdv[0] = NULL;
	304
03dcf17d	305
560d424b MF	306	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
560d424b MF	307	int vallen = strlen(match->key) + 1;
04a85b3b	308
03dcf17d BB	309	if (found >= maxv - 2 \|\|
03dcf17d BB	310	bufsz < vallen + (dollar_comp ? 3 : 0))
04a85b3b	311	break;
560d424b	312
04a85b3b	313	cmdv[found++] = buf;
03dcf17d BB	314
	315	/* Add the '${' prefix to each var when doing $ completion. */
	316	if (dollar_comp) {
	317	strcpy(buf, "${");
	318	buf += 2;
	319	bufsz -= 3;
	320	}
	321
560d424b MF	322	memcpy(buf, match->key, vallen);
	323	buf += vallen;
	324	bufsz -= vallen;
03dcf17d BB	325
	326	if (dollar_comp) {
	327	/*
	328	* This one is a bit odd: vallen already contains the
	329	* '\0' character but we need to add the '}' suffix,
	330	* hence the buf - 1 here. strcpy() will add the '\0'
	331	* character just after '}'. buf is then incremented
	332	* to account for the extra '}' we just added.
	333	*/
	334	strcpy(buf - 1, "}");
	335	buf++;
	336	}
04a85b3b WD	337	}
04a85b3b WD	338
560d424b MF	339	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);
	340
	341	if (idx)
03dcf17d	342	cmdv[found++] = dollar_comp ? "${...}" : "...";
27aafe98	343
04a85b3b WD	344	cmdv[found] = NULL;
	345	return found;
	346	}
	347	#endif