[J-u-boot.git] / cmd / setexpr.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2008 Freescale Semiconductor, Inc.
 * Copyright 2013 Wolfgang Denk <[email protected]>
 */

/*
 * This file provides a shell like 'expr' function to return.
 */

#include <config.h>
#include <command.h>
#include <ctype.h>
#include <env.h>
#include <log.h>
#include <malloc.h>
#include <mapmem.h>
#include <vsprintf.h>
#include <linux/errno.h>
#include <linux/sizes.h>
#include "printf.h"

#define MAX_STR_LEN 128

/**
 * struct expr_arg: Holds an argument to an expression
 *
 * @ival: Integer value (if width is not CMD_DATA_SIZE_STR)
 * @sval: String value (if width is CMD_DATA_SIZE_STR)
 */
struct expr_arg {
	union {
		ulong ival;
		char *sval;
	};
};

static int get_arg(char *s, int w, struct expr_arg *argp)
{
	struct expr_arg arg;

	/*
	 * If the parameter starts with a '*' then assume it is a pointer to
	 * the value we want.
	 */
	if (s[0] == '*') {
		ulong *p;
		ulong addr;
		ulong val;
		int len;
		char *str;

		addr = hextoul(&s[1], NULL);
		switch (w) {
		case 1:
			p = map_sysmem(addr, sizeof(uchar));
			val = (ulong)*(uchar *)p;
			unmap_sysmem(p);
			arg.ival = val;
			break;
		case 2:
			p = map_sysmem(addr, sizeof(ushort));
			val = (ulong)*(ushort *)p;
			unmap_sysmem(p);
			arg.ival = val;
			break;
		case CMD_DATA_SIZE_STR:
			p = map_sysmem(addr, SZ_64K);

			/* Maximum string length of 64KB plus terminator */
			len = strnlen((char *)p, SZ_64K) + 1;
			str = malloc(len);
			if (!str) {
				printf("Out of memory\n");
				return -ENOMEM;
			}
			memcpy(str, p, len);
			str[len - 1] = '\0';
			unmap_sysmem(p);
			arg.sval = str;
			break;
		case 4:
			p = map_sysmem(addr, sizeof(u32));
			val = *(u32 *)p;
			unmap_sysmem(p);
			arg.ival = val;
			break;
		default:
			p = map_sysmem(addr, sizeof(ulong));
			val = *p;
			unmap_sysmem(p);
			arg.ival = val;
			break;
		}
	} else {
		if (w == CMD_DATA_SIZE_STR)
			return -EINVAL;
		arg.ival = hextoul(s, NULL);
	}
	*argp = arg;

	return 0;
}

#ifdef CONFIG_REGEX

#include <slre.h>

/*
 * memstr - Find the first substring in memory
 * @s1: The string to be searched
 * @s2: The string to search for
 *
 * Similar to and based on strstr(),
 * but strings do not need to be NUL terminated.
 */
static char *memstr(const char *s1, int l1, const char *s2, int l2)
{
	if (!l2)
		return (char *)s1;

	while (l1 >= l2) {
		l1--;
		if (!memcmp(s1, s2, l2))
			return (char *)s1;
		s1++;
	}
	return NULL;
}

/**
 * substitute() - Substitute part of one string with another
 *
 * This updates @string so that the first occurrence of @old is replaced with
 * @new
 *
 * @string: String buffer containing string to update at the start
 * @slen: Pointer to current string length, updated on success
 * @ssize: Size of string buffer
 * @old: Old string to find in the buffer (no terminator needed)
 * @olen: Length of @old excluding terminator
 * @new: New string to replace @old with
 * @nlen: Length of @new excluding terminator
 * Return: pointer to immediately after the copied @new in @string, or NULL if
 *	no replacement took place
 */
static char *substitute(char *string, int *slen, int ssize,
			const char *old, int olen, const char *new, int nlen)
{
	char *p = memstr(string, *slen, old, olen);

	if (p == NULL)
		return NULL;

	debug("## Match at pos %ld: match len %d, subst len %d\n",
		(long)(p - string), olen, nlen);

	/* make sure replacement matches */
	if (*slen + nlen - olen > ssize) {
		printf("## error: substitution buffer overflow\n");
		return NULL;
	}

	/* move tail if needed */
	if (olen != nlen) {
		int tail, len;

		len = (olen > nlen) ? olen : nlen;

		tail = ssize - (p + len - string);

		debug("## tail len %d\n", tail);

		memmove(p + nlen, p + olen, tail);
	}

	/* insert substitute */
	memcpy(p, new, nlen);

	*slen += nlen - olen;

	return p + nlen;
}

int setexpr_regex_sub(char *data, uint data_size, char *nbuf, uint nbuf_size,
		      const char *r, const char *s, bool global)
{
	struct slre slre;
	char *datap = data;
	int res, len, nlen, loop;

	if (slre_compile(&slre, r) == 0) {
		printf("Error compiling regex: %s\n", slre.err_str);
		return 1;
	}

	len = strlen(data);
	for (loop = 0;; loop++) {
		struct cap caps[slre.num_caps + 2];
		const char *old;
		char *np;
		int i, olen;

		(void) memset(caps, 0, sizeof(caps));

		res = slre_match(&slre, datap, len - (datap - data), caps);

		debug("Result: %d\n", res);

		for (i = 0; i <= slre.num_caps; i++) {
			if (caps[i].len > 0) {
				debug("Substring %d: [%.*s]\n", i,
					caps[i].len, caps[i].ptr);
			}
		}

		if (res == 0) {
			if (loop == 0) {
				debug("%s: No match\n", data);
			} else {
				debug("## MATCH ## %s\n", data);
			}
			break;
		}

		if (!s)
			return 1;

		old = caps[0].ptr;
		olen = caps[0].len;
		nlen = strlen(s);

		if (nlen + 1 >= nbuf_size) {
			printf("## error: pattern buffer overflow: have %d, need %d\n",
			       nbuf_size, nlen + 1);
			return 1;
		}
		strcpy(nbuf, s);

		debug("## SUBST(1) ## %s\n", nbuf);

		/*
		 * Handle back references
		 *
		 * Support for \0 ... \9, where \0 is the
		 * whole matched pattern (similar to &).
		 *
		 * Implementation is a bit simpleminded as
		 * backrefs are substituted sequentially, one
		 * by one.  This will lead to somewhat
		 * unexpected results if the replacement
		 * strings contain any \N strings then then
		 * may get substitued, too.  We accept this
		 * restriction for the sake of simplicity.
		 */
		for (i = 0; i < 10; ++i) {
			char backref[2] = {
				'\\',
				'0',
			};

			if (caps[i].len == 0)
				break;

			backref[1] += i;

			debug("## BACKREF %d: replace \"%.*s\" by \"%.*s\" in \"%s\"\n",
				i,
				2, backref,
				caps[i].len, caps[i].ptr,
				nbuf);

			for (np = nbuf;;) {
				char *p = memstr(np, nlen, backref, 2);

				if (p == NULL)
					break;

				np = substitute(np, &nlen,
					nbuf_size - (np - nbuf),
					backref, 2,
					caps[i].ptr, caps[i].len);

				if (np == NULL)
					return 1;
			}
		}
		debug("## SUBST(2) ## %s\n", nbuf);

		datap = substitute(datap, &len, data_size - (datap - data),
				   old, olen, nbuf, nlen);

		if (datap == NULL)
			return 1;

		debug("## REMAINDER: %s\n", datap);

		debug("## RESULT: %s\n", data);

		if (!global)
			break;
	}
	debug("## FINAL (now env_set()) :  %s\n", data);

	return 0;
}

#define SLRE_BUFSZ	16384
#define SLRE_PATSZ	4096

/*
 * Perform regex operations on a environment variable
 *
 * Returns 0 if OK, 1 in case of errors.
 */
static int regex_sub_var(const char *name, const char *r, const char *s,
			 const char *t, int global)
{
	struct slre slre;
	char data[SLRE_BUFSZ];
	char nbuf[SLRE_PATSZ];
	const char *value;
	int len;
	int ret;

	if (!name)
		return 1;

	if (slre_compile(&slre, r) == 0) {
		printf("Error compiling regex: %s\n", slre.err_str);
		return 1;
	}

	if (!t) {
		value = env_get(name);
		if (!value) {
			printf("## Error: variable \"%s\" not defined\n", name);
			return 1;
		}
		t = value;
	}

	debug("REGEX on %s=%s\n", name, t);
	debug("REGEX=\"%s\", SUBST=\"%s\", GLOBAL=%d\n", r, s ? s : "<NULL>",
	      global);

	len = strlen(t);
	if (len + 1 > SLRE_BUFSZ) {
		printf("## error: subst buffer overflow: have %d, need %d\n",
		       SLRE_BUFSZ, len + 1);
		return 1;
	}

	strcpy(data, t);

	ret = setexpr_regex_sub(data, SLRE_BUFSZ, nbuf, SLRE_PATSZ, r, s,
				global);
	if (ret)
		return 1;

	debug("%s=%s\n", name, data);

	return env_set(name, data);
}
#endif

static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc,
		      char *const argv[])
{
	struct expr_arg aval, bval;
	ulong value;
	int ret = 0;
	int w;

	/*
	 * We take 3, 5, or 6 arguments, except fmt operation, which
	 * takes 4 to 8 arguments (limited by _maxargs):
	 * 3 : setexpr name value
	 * 5 : setexpr name val1 op val2
	 *     setexpr name [g]sub r s
	 * 6 : setexpr name [g]sub r s t
	 *     setexpr name fmt format [val1] [val2] [val3] [val4]
	 */

	if (argc < 3)
		return CMD_RET_USAGE;

	w = cmd_get_data_size(argv[0], 4);

	if (get_arg(argv[2], w, &aval))
		return CMD_RET_FAILURE;

	/* format string assignment: "setexpr name fmt %d value" */
	if (strcmp(argv[2], "fmt") == 0 && IS_ENABLED(CONFIG_CMD_SETEXPR_FMT)) {
		char str[MAX_STR_LEN];
		int result;

		if (argc == 3)
			return CMD_RET_USAGE;

		result = printf_setexpr(str, sizeof(str), argc - 3, &argv[3]);
		if (result)
			return result;

		return env_set(argv[1], str);
	}

	if (argc == 4 || argc > 6)
		return CMD_RET_USAGE;

	/* plain assignment: "setexpr name value" */
	if (argc == 3) {
		if (w == CMD_DATA_SIZE_STR) {
			ret = env_set(argv[1], aval.sval);
			free(aval.sval);
		} else {
			ret = env_set_hex(argv[1], aval.ival);
		}

		return ret;
	}

	/* 5 or 6 args (6 args only with [g]sub) */
#ifdef CONFIG_REGEX
	/*
	 * rexep handling: "setexpr name [g]sub r s [t]"
	 * with 5 args, "t" will be NULL
	 */
	if (strcmp(argv[2], "gsub") == 0)
		return regex_sub_var(argv[1], argv[3], argv[4], argv[5], 1);

	if (strcmp(argv[2], "sub") == 0)
		return regex_sub_var(argv[1], argv[3], argv[4], argv[5], 0);
#endif

	/* standard operators: "setexpr name val1 op val2" */
	if (argc != 5)
		return CMD_RET_USAGE;

	if (strlen(argv[3]) != 1)
		return CMD_RET_USAGE;

	if (get_arg(argv[4], w, &bval)) {
		if (w == CMD_DATA_SIZE_STR)
			free(aval.sval);
		return CMD_RET_FAILURE;
	}

	if (w == CMD_DATA_SIZE_STR) {
		int len;
		char *str;

		switch (argv[3][0]) {
		case '+':
			len = strlen(aval.sval) + strlen(bval.sval) + 1;
			str = malloc(len);
			if (!str) {
				printf("Out of memory\n");
				ret = CMD_RET_FAILURE;
			} else {
				/* These were copied out and checked earlier */
				strcpy(str, aval.sval);
				strcat(str, bval.sval);
				ret = env_set(argv[1], str);
				if (ret)
					printf("Could not set var\n");
				free(str);
			}
			break;
		default:
			printf("invalid op\n");
			ret = 1;
		}
	} else {
		ulong a = aval.ival;
		ulong b = bval.ival;

		switch (argv[3][0]) {
		case '|':
			value = a | b;
			break;
		case '&':
			value = a & b;
			break;
		case '+':
			value = a + b;
			break;
		case '^':
			value = a ^ b;
			break;
		case '-':
			value = a - b;
			break;
		case '*':
			value = a * b;
			break;
		case '/':
			value = a / b;
			break;
		case '%':
			value = a % b;
			break;
		default:
			printf("invalid op\n");
			return 1;
		}

		env_set_hex(argv[1], value);
	}

	if (w == CMD_DATA_SIZE_STR) {
		free(aval.sval);
		free(bval.sval);
	}

	return ret;
}

U_BOOT_CMD(
	setexpr, 8, 0, do_setexpr,
	"set environment variable as the result of eval expression",
	"[.b, .w, .l, .s] name [*]value1 <op> [*]value2\n"
	"    - set environment variable 'name' to the result of the evaluated\n"
	"      expression specified by <op>.  <op> can be &, |, ^, +, -, *, /, %\n"
	"      (for strings only + is supported)\n"
	"      size argument is only meaningful if value1 and/or value2 are\n"
	"      memory addresses (*)\n"
	"setexpr[.b, .w, .l] name [*]value\n"
	"    - load a value into a variable"
#ifdef CONFIG_CMD_SETEXPR_FMT
	"\n"
	"setexpr name fmt <format> [value1] [value2] [value3] [value4]\n"
	"    - set environment variable 'name' to the result of the bash like\n"
	"      format string evaluation of value."
#endif
#ifdef CONFIG_REGEX
	"\n"
	"setexpr name gsub r s [t]\n"
	"    - For each substring matching the regular expression <r> in the\n"
	"      string <t>, substitute the string <s>.  The result is\n"
	"      assigned to <name>.  If <t> is not supplied, use the old\n"
	"      value of <name>. If no substring matching <r> is found in <t>,\n"
	"      assign <t> to <name>.\n"
	"setexpr name sub r s [t]\n"
	"    - Just like gsub(), but replace only the first matching substring"
#endif
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
d058698f KG	2	/*
d058698f KG	3	* Copyright 2008 Freescale Semiconductor, Inc.
855f18ea	4	* Copyright 2013 Wolfgang Denk <[email protected]>
d058698f KG	5	*/
	6
	7	/*
	8	* This file provides a shell like 'expr' function to return.
	9	*/
	10
d058698f KG	11	#include <config.h>
d058698f KG	12	#include <command.h>
f4f8d8bb	13	#include <ctype.h>
c7694dd4	14	#include <env.h>
f7ae49fc	15	#include <log.h>
2c02152a	16	#include <malloc.h>
2068cea1	17	#include <mapmem.h>
03de305e TR	18	#include <vsprintf.h>
03de305e TR	19	#include <linux/errno.h>
2c02152a	20	#include <linux/sizes.h>
f4f8d8bb RG	21	#include "printf.h"
	22
	23	#define MAX_STR_LEN 128
d058698f	24
f66bee41 SG	25	/**
	26	* struct expr_arg: Holds an argument to an expression
	27	*
	28	* @ival: Integer value (if width is not CMD_DATA_SIZE_STR)
2c02152a	29	* @sval: String value (if width is CMD_DATA_SIZE_STR)
f66bee41 SG	30	*/
f66bee41 SG	31	struct expr_arg {
2c02152a SG	32	union {
	33	ulong ival;
	34	char *sval;
	35	};
f66bee41 SG	36	};
	37
	38	static int get_arg(char s, int w, struct expr_arg argp)
47ab5ad1	39	{
f66bee41 SG	40	struct expr_arg arg;
f66bee41 SG	41
482126e2	42	/*
2068cea1 JH	43	* If the parameter starts with a '*' then assume it is a pointer to
2068cea1 JH	44	* the value we want.
47ab5ad1	45	*/
47ab5ad1	46	if (s[0] == '*') {
2068cea1 JH	47	ulong *p;
	48	ulong addr;
	49	ulong val;
2c02152a SG	50	int len;
2c02152a SG	51	char *str;
2068cea1	52
7e5f460e	53	addr = hextoul(&s[1], NULL);
47ab5ad1	54	switch (w) {
2068cea1 JH	55	case 1:
	56	p = map_sysmem(addr, sizeof(uchar));
	57	val = (ulong)(uchar )p;
	58	unmap_sysmem(p);
f66bee41 SG	59	arg.ival = val;
f66bee41 SG	60	break;
2068cea1 JH	61	case 2:
	62	p = map_sysmem(addr, sizeof(ushort));
	63	val = (ulong)(ushort )p;
	64	unmap_sysmem(p);
f66bee41 SG	65	arg.ival = val;
f66bee41 SG	66	break;
2c02152a SG	67	case CMD_DATA_SIZE_STR:
	68	p = map_sysmem(addr, SZ_64K);
	69
	70	/* Maximum string length of 64KB plus terminator */
	71	len = strnlen((char *)p, SZ_64K) + 1;
	72	str = malloc(len);
	73	if (!str) {
	74	printf("Out of memory\n");
	75	return -ENOMEM;
	76	}
	77	memcpy(str, p, len);
	78	str[len - 1] = '\0';
	79	unmap_sysmem(p);
	80	arg.sval = str;
	81	break;
47ab5ad1	82	case 4:
25a43ac8 SG	83	p = map_sysmem(addr, sizeof(u32));
	84	val = (u32 )p;
	85	unmap_sysmem(p);
f66bee41 SG	86	arg.ival = val;
f66bee41 SG	87	break;
2068cea1 JH	88	default:
	89	p = map_sysmem(addr, sizeof(ulong));
	90	val = *p;
	91	unmap_sysmem(p);
f66bee41 SG	92	arg.ival = val;
f66bee41 SG	93	break;
47ab5ad1 FM	94	}
47ab5ad1 FM	95	} else {
2c02152a SG	96	if (w == CMD_DATA_SIZE_STR)
2c02152a SG	97	return -EINVAL;
7e5f460e	98	arg.ival = hextoul(s, NULL);
47ab5ad1	99	}
f66bee41 SG	100	*argp = arg;
	101
	102	return 0;
47ab5ad1 FM	103	}
47ab5ad1 FM	104
855f18ea WD	105	#ifdef CONFIG_REGEX
	106
	107	#include <slre.h>
	108
855f18ea WD	109	/*
	110	* memstr - Find the first substring in memory
	111	* @s1: The string to be searched
	112	* @s2: The string to search for
	113	*
	114	* Similar to and based on strstr(),
	115	* but strings do not need to be NUL terminated.
	116	*/
	117	static char memstr(const char s1, int l1, const char *s2, int l2)
	118	{
	119	if (!l2)
	120	return (char *)s1;
	121
	122	while (l1 >= l2) {
	123	l1--;
	124	if (!memcmp(s1, s2, l2))
	125	return (char *)s1;
	126	s1++;
	127	}
	128	return NULL;
	129	}
	130
56331b26 SG	131	/**
	132	* substitute() - Substitute part of one string with another
	133	*
	134	* This updates @string so that the first occurrence of @old is replaced with
	135	* @new
	136	*
	137	* @string: String buffer containing string to update at the start
	138	* @slen: Pointer to current string length, updated on success
	139	* @ssize: Size of string buffer
	140	* @old: Old string to find in the buffer (no terminator needed)
	141	* @olen: Length of @old excluding terminator
	142	* @new: New string to replace @old with
	143	* @nlen: Length of @new excluding terminator
185f812c	144	* Return: pointer to immediately after the copied @new in @string, or NULL if
56331b26 SG	145	* no replacement took place
	146	*/
	147	static char substitute(char string, int *slen, int ssize,
	148	const char old, int olen, const char new, int nlen)
855f18ea WD	149	{
	150	char p = memstr(string, slen, old, olen);
	151
	152	if (p == NULL)
	153	return NULL;
	154
	155	debug("## Match at pos %ld: match len %d, subst len %d\n",
	156	(long)(p - string), olen, nlen);
	157
	158	/* make sure replacement matches */
	159	if (*slen + nlen - olen > ssize) {
	160	printf("## error: substitution buffer overflow\n");
	161	return NULL;
	162	}
	163
	164	/* move tail if needed */
	165	if (olen != nlen) {
	166	int tail, len;
	167
	168	len = (olen > nlen) ? olen : nlen;
	169
	170	tail = ssize - (p + len - string);
	171
	172	debug("## tail len %d\n", tail);
	173
	174	memmove(p + nlen, p + olen, tail);
	175	}
	176
56331b26	177	/* insert substitute */
855f18ea WD	178	memcpy(p, new, nlen);
	179
	180	*slen += nlen - olen;
	181
	182	return p + nlen;
	183	}
	184
d422c77a SG	185	int setexpr_regex_sub(char data, uint data_size, char nbuf, uint nbuf_size,
d422c77a SG	186	const char r, const char s, bool global)
855f18ea WD	187	{
855f18ea WD	188	struct slre slre;
855f18ea	189	char *datap = data;
855f18ea WD	190	int res, len, nlen, loop;
855f18ea WD	191
855f18ea WD	192	if (slre_compile(&slre, r) == 0) {
	193	printf("Error compiling regex: %s\n", slre.err_str);
	194	return 1;
	195	}
	196
56331b26	197	len = strlen(data);
855f18ea WD	198	for (loop = 0;; loop++) {
855f18ea WD	199	struct cap caps[slre.num_caps + 2];
855f18ea WD	200	const char *old;
	201	char *np;
	202	int i, olen;
	203
	204	(void) memset(caps, 0, sizeof(caps));
	205
8f4aa7dd	206	res = slre_match(&slre, datap, len - (datap - data), caps);
855f18ea WD	207
	208	debug("Result: %d\n", res);
	209
8f4aa7dd	210	for (i = 0; i <= slre.num_caps; i++) {
855f18ea WD	211	if (caps[i].len > 0) {
	212	debug("Substring %d: [%.*s]\n", i,
	213	caps[i].len, caps[i].ptr);
	214	}
	215	}
	216
	217	if (res == 0) {
	218	if (loop == 0) {
36b900e8	219	debug("%s: No match\n", data);
855f18ea	220	} else {
4c736306	221	debug("## MATCH ## %s\n", data);
855f18ea	222	}
4c736306	223	break;
855f18ea WD	224	}
855f18ea WD	225
56331b26	226	if (!s)
855f18ea	227	return 1;
855f18ea WD	228
	229	old = caps[0].ptr;
	230	olen = caps[0].len;
9528229f	231	nlen = strlen(s);
855f18ea	232
56331b26	233	if (nlen + 1 >= nbuf_size) {
855f18ea	234	printf("## error: pattern buffer overflow: have %d, need %d\n",
56331b26	235	nbuf_size, nlen + 1);
855f18ea WD	236	return 1;
	237	}
	238	strcpy(nbuf, s);
	239
	240	debug("## SUBST(1) ## %s\n", nbuf);
	241
	242	/*
	243	* Handle back references
	244	*
	245	* Support for \0 ... \9, where \0 is the
	246	* whole matched pattern (similar to &).
	247	*
	248	* Implementation is a bit simpleminded as
	249	* backrefs are substituted sequentially, one
	250	* by one. This will lead to somewhat
	251	* unexpected results if the replacement
	252	* strings contain any \N strings then then
	253	* may get substitued, too. We accept this
	254	* restriction for the sake of simplicity.
	255	*/
	256	for (i = 0; i < 10; ++i) {
	257	char backref[2] = {
	258	'\\',
	259	'0',
	260	};
	261
	262	if (caps[i].len == 0)
	263	break;
	264
	265	backref[1] += i;
	266
	267	debug("## BACKREF %d: replace \"%.s\" by \"%.s\" in \"%s\"\n",
	268	i,
	269	2, backref,
	270	caps[i].len, caps[i].ptr,
	271	nbuf);
	272
	273	for (np = nbuf;;) {
	274	char *p = memstr(np, nlen, backref, 2);
	275
	276	if (p == NULL)
	277	break;
	278
	279	np = substitute(np, &nlen,
8f4aa7dd	280	nbuf_size - (np - nbuf),
855f18ea WD	281	backref, 2,
	282	caps[i].ptr, caps[i].len);
	283
	284	if (np == NULL)
	285	return 1;
	286	}
	287	}
	288	debug("## SUBST(2) ## %s\n", nbuf);
	289
8f4aa7dd SG	290	datap = substitute(datap, &len, data_size - (datap - data),
8f4aa7dd SG	291	old, olen, nbuf, nlen);
855f18ea WD	292
	293	if (datap == NULL)
	294	return 1;
	295
	296	debug("## REMAINDER: %s\n", datap);
	297
	298	debug("## RESULT: %s\n", data);
	299
	300	if (!global)
	301	break;
	302	}
382bee57	303	debug("## FINAL (now env_set()) : %s\n", data);
855f18ea	304
56331b26 SG	305	return 0;
	306	}
	307
	308	#define SLRE_BUFSZ 16384
	309	#define SLRE_PATSZ 4096
	310
	311	/*
	312	* Perform regex operations on a environment variable
	313	*
	314	* Returns 0 if OK, 1 in case of errors.
	315	*/
	316	static int regex_sub_var(const char name, const char r, const char *s,
	317	const char *t, int global)
	318	{
	319	struct slre slre;
	320	char data[SLRE_BUFSZ];
	321	char nbuf[SLRE_PATSZ];
	322	const char *value;
	323	int len;
	324	int ret;
	325
	326	if (!name)
	327	return 1;
	328
	329	if (slre_compile(&slre, r) == 0) {
	330	printf("Error compiling regex: %s\n", slre.err_str);
	331	return 1;
	332	}
	333
	334	if (!t) {
	335	value = env_get(name);
	336	if (!value) {
	337	printf("## Error: variable \"%s\" not defined\n", name);
	338	return 1;
	339	}
	340	t = value;
	341	}
	342
	343	debug("REGEX on %s=%s\n", name, t);
	344	debug("REGEX=\"%s\", SUBST=\"%s\", GLOBAL=%d\n", r, s ? s : "<NULL>",
	345	global);
	346
	347	len = strlen(t);
	348	if (len + 1 > SLRE_BUFSZ) {
	349	printf("## error: subst buffer overflow: have %d, need %d\n",
	350	SLRE_BUFSZ, len + 1);
	351	return 1;
	352	}
	353
	354	strcpy(data, t);
	355
d422c77a SG	356	ret = setexpr_regex_sub(data, SLRE_BUFSZ, nbuf, SLRE_PATSZ, r, s,
d422c77a SG	357	global);
56331b26 SG	358	if (ret)
	359	return 1;
	360
36b900e8	361	debug("%s=%s\n", name, data);
855f18ea	362
382bee57	363	return env_set(name, data);
855f18ea WD	364	}
	365	#endif
	366
09140113 SG	367	static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	368	char *const argv[])
d058698f	369	{
f66bee41	370	struct expr_arg aval, bval;
41ef372c	371	ulong value;
2c02152a	372	int ret = 0;
47ab5ad1	373	int w;
d058698f	374
855f18ea	375	/*
f4f8d8bb RG	376	* We take 3, 5, or 6 arguments, except fmt operation, which
f4f8d8bb RG	377	* takes 4 to 8 arguments (limited by _maxargs):
855f18ea WD	378	* 3 : setexpr name value
	379	* 5 : setexpr name val1 op val2
	380	* setexpr name [g]sub r s
	381	* 6 : setexpr name [g]sub r s t
f4f8d8bb	382	* setexpr name fmt format [val1] [val2] [val3] [val4]
855f18ea WD	383	*/
855f18ea WD	384
f4f8d8bb	385	if (argc < 3)
4c12eeb8	386	return CMD_RET_USAGE;
d058698f	387
47ab5ad1 FM	388	w = cmd_get_data_size(argv[0], 4);
47ab5ad1 FM	389
f66bee41 SG	390	if (get_arg(argv[2], w, &aval))
f66bee41 SG	391	return CMD_RET_FAILURE;
4823b45d	392
f4f8d8bb RG	393	/* format string assignment: "setexpr name fmt %d value" */
	394	if (strcmp(argv[2], "fmt") == 0 && IS_ENABLED(CONFIG_CMD_SETEXPR_FMT)) {
	395	char str[MAX_STR_LEN];
	396	int result;
	397
	398	if (argc == 3)
	399	return CMD_RET_USAGE;
	400
	401	result = printf_setexpr(str, sizeof(str), argc - 3, &argv[3]);
	402	if (result)
	403	return result;
	404
	405	return env_set(argv[1], str);
	406	}
	407
	408	if (argc == 4 \|\| argc > 6)
	409	return CMD_RET_USAGE;
	410
103c94b1	411	/* plain assignment: "setexpr name value" */
2c02152a SG	412	if (argc == 3) {
	413	if (w == CMD_DATA_SIZE_STR) {
	414	ret = env_set(argv[1], aval.sval);
	415	free(aval.sval);
	416	} else {
	417	ret = env_set_hex(argv[1], aval.ival);
	418	}
	419
	420	return ret;
	421	}
4823b45d	422
855f18ea WD	423	/* 5 or 6 args (6 args only with [g]sub) */
	424	#ifdef CONFIG_REGEX
	425	/*
	426	* rexep handling: "setexpr name [g]sub r s [t]"
	427	* with 5 args, "t" will be NULL
	428	*/
	429	if (strcmp(argv[2], "gsub") == 0)
56331b26	430	return regex_sub_var(argv[1], argv[3], argv[4], argv[5], 1);
855f18ea WD	431
855f18ea WD	432	if (strcmp(argv[2], "sub") == 0)
56331b26	433	return regex_sub_var(argv[1], argv[3], argv[4], argv[5], 0);
855f18ea WD	434	#endif
855f18ea WD	435
103c94b1 WD	436	/* standard operators: "setexpr name val1 op val2" */
	437	if (argc != 5)
	438	return CMD_RET_USAGE;
	439
	440	if (strlen(argv[3]) != 1)
	441	return CMD_RET_USAGE;
	442
2c02152a SG	443	if (get_arg(argv[4], w, &bval)) {
	444	if (w == CMD_DATA_SIZE_STR)
	445	free(aval.sval);
f66bee41	446	return CMD_RET_FAILURE;
2c02152a SG	447	}
	448
	449	if (w == CMD_DATA_SIZE_STR) {
	450	int len;
	451	char *str;
d058698f	452
2c02152a SG	453	switch (argv[3][0]) {
	454	case '+':
	455	len = strlen(aval.sval) + strlen(bval.sval) + 1;
	456	str = malloc(len);
	457	if (!str) {
	458	printf("Out of memory\n");
	459	ret = CMD_RET_FAILURE;
	460	} else {
	461	/* These were copied out and checked earlier */
	462	strcpy(str, aval.sval);
	463	strcat(str, bval.sval);
	464	ret = env_set(argv[1], str);
	465	if (ret)
	466	printf("Could not set var\n");
	467	free(str);
	468	}
	469	break;
	470	default:
	471	printf("invalid op\n");
	472	ret = 1;
	473	}
	474	} else {
f66bee41 SG	475	ulong a = aval.ival;
	476	ulong b = bval.ival;
	477
	478	switch (argv[3][0]) {
	479	case '\|':
	480	value = a \| b;
	481	break;
	482	case '&':
	483	value = a & b;
	484	break;
	485	case '+':
	486	value = a + b;
	487	break;
	488	case '^':
	489	value = a ^ b;
	490	break;
	491	case '-':
	492	value = a - b;
	493	break;
	494	case '*':
	495	value = a * b;
	496	break;
	497	case '/':
	498	value = a / b;
	499	break;
	500	case '%':
	501	value = a % b;
	502	break;
	503	default:
	504	printf("invalid op\n");
	505	return 1;
	506	}
	507
	508	env_set_hex(argv[1], value);
	509	}
d058698f	510
2c02152a SG	511	if (w == CMD_DATA_SIZE_STR) {
	512	free(aval.sval);
	513	free(bval.sval);
	514	}
	515
	516	return ret;
d058698f KG	517	}
	518
	519	U_BOOT_CMD(
f4f8d8bb	520	setexpr, 8, 0, do_setexpr,
2fb2604d	521	"set environment variable as the result of eval expression",
2c02152a	522	"[.b, .w, .l, .s] name []value1 <op> []value2\n"
d058698f	523	" - set environment variable 'name' to the result of the evaluated\n"
855f18ea	524	" expression specified by <op>. <op> can be &, \|, ^, +, -, *, /, %\n"
2c02152a	525	" (for strings only + is supported)\n"
4823b45d JH	526	" size argument is only meaningful if value1 and/or value2 are\n"
4823b45d JH	527	" memory addresses (*)\n"
103c94b1 WD	528	"setexpr[.b, .w, .l] name [*]value\n"
103c94b1 WD	529	" - load a value into a variable"
f4f8d8bb RG	530	#ifdef CONFIG_CMD_SETEXPR_FMT
	531	"\n"
	532	"setexpr name fmt <format> [value1] [value2] [value3] [value4]\n"
	533	" - set environment variable 'name' to the result of the bash like\n"
	534	" format string evaluation of value."
	535	#endif
855f18ea WD	536	#ifdef CONFIG_REGEX
	537	"\n"
	538	"setexpr name gsub r s [t]\n"
	539	" - For each substring matching the regular expression <r> in the\n"
	540	" string <t>, substitute the string <s>. The result is\n"
	541	" assigned to <name>. If <t> is not supplied, use the old\n"
4c736306 MM	542	" value of <name>. If no substring matching <r> is found in <t>,\n"
4c736306 MM	543	" assign <t> to <name>.\n"
855f18ea WD	544	"setexpr name sub r s [t]\n"
	545	" - Just like gsub(), but replace only the first matching substring"
	546	#endif
d058698f	547	);