[J-u-boot.git] / common / cli_simple.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2000
 * Wolfgang Denk, DENX Software Engineering, [email protected].
 *
 * Add to readline cmdline-editing by
 * (C) Copyright 2005
 * JinHua Luo, GuangDong Linux Center, <[email protected]>
 */

#include <common.h>
#include <bootretry.h>
#include <cli.h>
#include <command.h>
#include <console.h>
#include <env.h>
#include <linux/ctype.h>

#define DEBUG_PARSER	0	/* set to 1 to debug */

#define debug_parser(fmt, args...)		\
	debug_cond(DEBUG_PARSER, fmt, ##args)


int cli_simple_parse_line(char *line, char *argv[])
{
	int nargs = 0;

	debug_parser("%s: \"%s\"\n", __func__, line);
	while (nargs < CONFIG_SYS_MAXARGS) {
		/* skip any white space */
		while (isblank(*line))
			++line;

		if (*line == '\0') {	/* end of line, no more args	*/
			argv[nargs] = NULL;
			debug_parser("%s: nargs=%d\n", __func__, nargs);
			return nargs;
		}

		argv[nargs++] = line;	/* begin of argument string	*/

		/* find end of string */
		while (*line && !isblank(*line))
			++line;

		if (*line == '\0') {	/* end of line, no more args	*/
			argv[nargs] = NULL;
			debug_parser("parse_line: nargs=%d\n", nargs);
			return nargs;
		}

		*line++ = '\0';		/* terminate current arg	 */
	}

	printf("** Too many args (max. %d) **\n", CONFIG_SYS_MAXARGS);

	debug_parser("%s: nargs=%d\n", __func__, nargs);
	return nargs;
}

void cli_simple_process_macros(const char *input, char *output)
{
	char c, prev;
	const char *varname_start = NULL;
	int inputcnt = strlen(input);
	int outputcnt = CONFIG_SYS_CBSIZE;
	int state = 0;		/* 0 = waiting for '$'  */

	/* 1 = waiting for '(' or '{' */
	/* 2 = waiting for ')' or '}' */
	/* 3 = waiting for '''  */
	char __maybe_unused *output_start = output;

	debug_parser("[PROCESS_MACROS] INPUT len %zd: \"%s\"\n", strlen(input),
		     input);

	prev = '\0';		/* previous character   */

	while (inputcnt && outputcnt) {
		c = *input++;
		inputcnt--;

		if (state != 3) {
			/* remove one level of escape characters */
			if ((c == '\\') && (prev != '\\')) {
				if (inputcnt-- == 0)
					break;
				prev = c;
				c = *input++;
			}
		}

		switch (state) {
		case 0:	/* Waiting for (unescaped) $    */
			if ((c == '\'') && (prev != '\\')) {
				state = 3;
				break;
			}
			if ((c == '$') && (prev != '\\')) {
				state++;
			} else {
				*(output++) = c;
				outputcnt--;
			}
			break;
		case 1:	/* Waiting for (        */
			if (c == '(' || c == '{') {
				state++;
				varname_start = input;
			} else {
				state = 0;
				*(output++) = '$';
				outputcnt--;

				if (outputcnt) {
					*(output++) = c;
					outputcnt--;
				}
			}
			break;
		case 2:	/* Waiting for )        */
			if (c == ')' || c == '}') {
				int i;
				char envname[CONFIG_SYS_CBSIZE], *envval;
				/* Varname # of chars */
				int envcnt = input - varname_start - 1;

				/* Get the varname */
				for (i = 0; i < envcnt; i++)
					envname[i] = varname_start[i];
				envname[i] = 0;

				/* Get its value */
				envval = env_get(envname);

				/* Copy into the line if it exists */
				if (envval != NULL)
					while ((*envval) && outputcnt) {
						*(output++) = *(envval++);
						outputcnt--;
					}
				/* Look for another '$' */
				state = 0;
			}
			break;
		case 3:	/* Waiting for '        */
			if ((c == '\'') && (prev != '\\')) {
				state = 0;
			} else {
				*(output++) = c;
				outputcnt--;
			}
			break;
		}
		prev = c;
	}

	if (outputcnt)
		*output = 0;
	else
		*(output - 1) = 0;

	debug_parser("[PROCESS_MACROS] OUTPUT len %zd: \"%s\"\n",
		     strlen(output_start), output_start);
}

 /*
 * WARNING:
 *
 * We must create a temporary copy of the command since the command we get
 * may be the result from env_get(), which returns a pointer directly to
 * the environment data, which may change magicly when the command we run
 * creates or modifies environment variables (like "bootp" does).
 */
int cli_simple_run_command(const char *cmd, int flag)
{
	char cmdbuf[CONFIG_SYS_CBSIZE];	/* working copy of cmd		*/
	char *token;			/* start of token in cmdbuf	*/
	char *sep;			/* end of token (separator) in cmdbuf */
	char finaltoken[CONFIG_SYS_CBSIZE];
	char *str = cmdbuf;
	char *argv[CONFIG_SYS_MAXARGS + 1];	/* NULL terminated	*/
	int argc, inquotes;
	int repeatable = 1;
	int rc = 0;

	debug_parser("[RUN_COMMAND] cmd[%p]=\"", cmd);
	if (DEBUG_PARSER) {
		/* use puts - string may be loooong */
		puts(cmd ? cmd : "NULL");
		puts("\"\n");
	}
	clear_ctrlc();		/* forget any previous Control C */

	if (!cmd || !*cmd)
		return -1;	/* empty command */

	if (strlen(cmd) >= CONFIG_SYS_CBSIZE) {
		puts("## Command too long!\n");
		return -1;
	}

	strcpy(cmdbuf, cmd);

	/* Process separators and check for invalid
	 * repeatable commands
	 */

	debug_parser("[PROCESS_SEPARATORS] %s\n", cmd);
	while (*str) {
		/*
		 * Find separator, or string end
		 * Allow simple escape of ';' by writing "\;"
		 */
		for (inquotes = 0, sep = str; *sep; sep++) {
			if ((*sep == '\'') &&
			    (*(sep - 1) != '\\'))
				inquotes = !inquotes;

			if (!inquotes &&
			    (*sep == ';') &&	/* separator		*/
			    (sep != str) &&	/* past string start	*/
			    (*(sep - 1) != '\\'))	/* and NOT escaped */
				break;
		}

		/*
		 * Limit the token to data between separators
		 */
		token = str;
		if (*sep) {
			str = sep + 1;	/* start of command for next pass */
			*sep = '\0';
		} else {
			str = sep;	/* no more commands for next pass */
		}
		debug_parser("token: \"%s\"\n", token);

		/* find macros in this token and replace them */
		cli_simple_process_macros(token, finaltoken);

		/* Extract arguments */
		argc = cli_simple_parse_line(finaltoken, argv);
		if (argc == 0) {
			rc = -1;	/* no command at all */
			continue;
		}

		if (cmd_process(flag, argc, argv, &repeatable, NULL))
			rc = -1;

		/* Did the user stop this? */
		if (had_ctrlc())
			return -1;	/* if stopped then not repeatable */
	}

	return rc ? rc : repeatable;
}

void cli_simple_loop(void)
{
	static char lastcommand[CONFIG_SYS_CBSIZE + 1] = { 0, };

	int len;
	int flag;
	int rc = 1;

	for (;;) {
		if (rc >= 0) {
			/* Saw enough of a valid command to
			 * restart the timeout.
			 */
			bootretry_reset_cmd_timeout();
		}
		len = cli_readline(CONFIG_SYS_PROMPT);

		flag = 0;	/* assume no special flags for now */
		if (len > 0)
			strlcpy(lastcommand, console_buffer,
				CONFIG_SYS_CBSIZE + 1);
		else if (len == 0)
			flag |= CMD_FLAG_REPEAT;
#ifdef CONFIG_BOOT_RETRY_TIME
		else if (len == -2) {
			/* -2 means timed out, retry autoboot
			 */
			puts("\nTimed out waiting for command\n");
# ifdef CONFIG_RESET_TO_RETRY
			/* Reinit board to run initialization code again */
			do_reset(NULL, 0, 0, NULL);
# else
			return;		/* retry autoboot */
# endif
		}
#endif

		if (len == -1)
			puts("<INTERRUPT>\n");
		else
			rc = run_command_repeatable(lastcommand, flag);

		if (rc <= 0) {
			/* invalid command or not repeatable, forget it */
			lastcommand[0] = 0;
		}
	}
}

int cli_simple_run_command_list(char *cmd, int flag)
{
	char *line, *next;
	int rcode = 0;

	/*
	 * Break into individual lines, and execute each line; terminate on
	 * error.
	 */
	next = cmd;
	line = cmd;
	while (*next) {
		if (*next == '\n') {
			*next = '\0';
			/* run only non-empty commands */
			if (*line) {
				debug("** exec: \"%s\"\n", line);
				if (cli_simple_run_command(line, 0) < 0) {
					rcode = 1;
					break;
				}
			}
			line = next + 1;
		}
		++next;
	}
	if (rcode == 0 && *line)
		rcode = (cli_simple_run_command(line, 0) < 0);

	return rcode;
}
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
6493ccc7 SG	2	/*
	3	* (C) Copyright 2000
	4	* Wolfgang Denk, DENX Software Engineering, [email protected].
	5	*
	6	* Add to readline cmdline-editing by
	7	* (C) Copyright 2005
	8	* JinHua Luo, GuangDong Linux Center, <[email protected]>
6493ccc7 SG	9	*/
	10
	11	#include <common.h>
0098e179	12	#include <bootretry.h>
6493ccc7	13	#include <cli.h>
288b29e4	14	#include <command.h>
24b852a7	15	#include <console.h>
7b51b576	16	#include <env.h>
6493ccc7 SG	17	#include <linux/ctype.h>
	18
	19	#define DEBUG_PARSER 0 /* set to 1 to debug */
	20
	21	#define debug_parser(fmt, args...) \
	22	debug_cond(DEBUG_PARSER, fmt, ##args)
	23
	24
e1bf824d	25	int cli_simple_parse_line(char line, char argv[])
6493ccc7 SG	26	{
	27	int nargs = 0;
	28
	29	debug_parser("%s: \"%s\"\n", __func__, line);
	30	while (nargs < CONFIG_SYS_MAXARGS) {
	31	/* skip any white space */
	32	while (isblank(*line))
	33	++line;
	34
	35	if (line == '\0') { / end of line, no more args */
	36	argv[nargs] = NULL;
	37	debug_parser("%s: nargs=%d\n", __func__, nargs);
	38	return nargs;
	39	}
	40
	41	argv[nargs++] = line; /* begin of argument string */
	42
	43	/* find end of string */
	44	while (line && !isblank(line))
	45	++line;
	46
	47	if (line == '\0') { / end of line, no more args */
	48	argv[nargs] = NULL;
	49	debug_parser("parse_line: nargs=%d\n", nargs);
	50	return nargs;
	51	}
	52
	53	line++ = '\0'; / terminate current arg */
	54	}
	55
	56	printf(" Too many args (max. %d) \n", CONFIG_SYS_MAXARGS);
	57
	58	debug_parser("%s: nargs=%d\n", __func__, nargs);
	59	return nargs;
	60	}
	61
a06be2d0	62	void cli_simple_process_macros(const char input, char output)
6493ccc7 SG	63	{
	64	char c, prev;
	65	const char *varname_start = NULL;
	66	int inputcnt = strlen(input);
	67	int outputcnt = CONFIG_SYS_CBSIZE;
	68	int state = 0; /* 0 = waiting for '$' */
	69
	70	/* 1 = waiting for '(' or '{' */
	71	/* 2 = waiting for ')' or '}' */
	72	/* 3 = waiting for ''' */
80402f34	73	char __maybe_unused *output_start = output;
6493ccc7 SG	74
	75	debug_parser("[PROCESS_MACROS] INPUT len %zd: \"%s\"\n", strlen(input),
	76	input);
	77
	78	prev = '\0'; /* previous character */
	79
	80	while (inputcnt && outputcnt) {
	81	c = *input++;
	82	inputcnt--;
	83
	84	if (state != 3) {
	85	/* remove one level of escape characters */
	86	if ((c == '\\') && (prev != '\\')) {
	87	if (inputcnt-- == 0)
	88	break;
	89	prev = c;
	90	c = *input++;
	91	}
	92	}
	93
	94	switch (state) {
	95	case 0: /* Waiting for (unescaped) $ */
	96	if ((c == '\'') && (prev != '\\')) {
	97	state = 3;
	98	break;
	99	}
	100	if ((c == '$') && (prev != '\\')) {
	101	state++;
	102	} else {
	103	*(output++) = c;
	104	outputcnt--;
	105	}
	106	break;
	107	case 1: /* Waiting for ( */
	108	if (c == '(' \|\| c == '{') {
	109	state++;
	110	varname_start = input;
	111	} else {
	112	state = 0;
	113	*(output++) = '$';
	114	outputcnt--;
	115
	116	if (outputcnt) {
	117	*(output++) = c;
	118	outputcnt--;
	119	}
	120	}
	121	break;
	122	case 2: /* Waiting for ) */
	123	if (c == ')' \|\| c == '}') {
	124	int i;
	125	char envname[CONFIG_SYS_CBSIZE], *envval;
	126	/* Varname # of chars */
	127	int envcnt = input - varname_start - 1;
	128
	129	/* Get the varname */
	130	for (i = 0; i < envcnt; i++)
	131	envname[i] = varname_start[i];
	132	envname[i] = 0;
	133
	134	/* Get its value */
00caae6d	135	envval = env_get(envname);
6493ccc7 SG	136
	137	/* Copy into the line if it exists */
	138	if (envval != NULL)
	139	while ((*envval) && outputcnt) {
	140	(output++) = (envval++);
	141	outputcnt--;
	142	}
	143	/* Look for another '$' */
	144	state = 0;
	145	}
	146	break;
	147	case 3: /* Waiting for ' */
	148	if ((c == '\'') && (prev != '\\')) {
	149	state = 0;
	150	} else {
	151	*(output++) = c;
	152	outputcnt--;
	153	}
	154	break;
	155	}
	156	prev = c;
	157	}
	158
	159	if (outputcnt)
	160	*output = 0;
	161	else
	162	*(output - 1) = 0;
	163
	164	debug_parser("[PROCESS_MACROS] OUTPUT len %zd: \"%s\"\n",
	165	strlen(output_start), output_start);
	166	}
	167
	168	/*
	169	* WARNING:
	170	*
	171	* We must create a temporary copy of the command since the command we get
00caae6d	172	* may be the result from env_get(), which returns a pointer directly to
6493ccc7 SG	173	* the environment data, which may change magicly when the command we run
	174	* creates or modifies environment variables (like "bootp" does).
	175	*/
	176	int cli_simple_run_command(const char *cmd, int flag)
	177	{
	178	char cmdbuf[CONFIG_SYS_CBSIZE]; /* working copy of cmd */
	179	char token; / start of token in cmdbuf */
	180	char sep; / end of token (separator) in cmdbuf */
	181	char finaltoken[CONFIG_SYS_CBSIZE];
	182	char *str = cmdbuf;
	183	char argv[CONFIG_SYS_MAXARGS + 1]; / NULL terminated */
	184	int argc, inquotes;
	185	int repeatable = 1;
	186	int rc = 0;
	187
	188	debug_parser("[RUN_COMMAND] cmd[%p]=\"", cmd);
	189	if (DEBUG_PARSER) {
	190	/* use puts - string may be loooong */
	191	puts(cmd ? cmd : "NULL");
	192	puts("\"\n");
	193	}
	194	clear_ctrlc(); /* forget any previous Control C */
	195
	196	if (!cmd \|\| !*cmd)
	197	return -1; /* empty command */
	198
	199	if (strlen(cmd) >= CONFIG_SYS_CBSIZE) {
	200	puts("## Command too long!\n");
	201	return -1;
	202	}
	203
	204	strcpy(cmdbuf, cmd);
	205
	206	/* Process separators and check for invalid
	207	* repeatable commands
	208	*/
	209
	210	debug_parser("[PROCESS_SEPARATORS] %s\n", cmd);
	211	while (*str) {
	212	/*
	213	* Find separator, or string end
	214	* Allow simple escape of ';' by writing "\;"
	215	*/
	216	for (inquotes = 0, sep = str; *sep; sep++) {
	217	if ((*sep == '\'') &&
	218	(*(sep - 1) != '\\'))
	219	inquotes = !inquotes;
	220
	221	if (!inquotes &&
	222	(sep == ';') && / separator */
	223	(sep != str) && /* past string start */
	224	((sep - 1) != '\\')) / and NOT escaped */
	225	break;
	226	}
	227
	228	/*
	229	* Limit the token to data between separators
	230	*/
	231	token = str;
	232	if (*sep) {
	233	str = sep + 1; /* start of command for next pass */
	234	*sep = '\0';
	235	} else {
	236	str = sep; /* no more commands for next pass */
237	}
238	debug_parser("token: \"%s\"\n", token);
239
240	/* find macros in this token and replace them */
a06be2d0	241	cli_simple_process_macros(token, finaltoken);
6493ccc7 SG	242
6493ccc7 SG	243	/* Extract arguments */
e1bf824d	244	argc = cli_simple_parse_line(finaltoken, argv);
6493ccc7 SG	245	if (argc == 0) {
	246	rc = -1; /* no command at all */
	247	continue;
	248	}
	249
	250	if (cmd_process(flag, argc, argv, &repeatable, NULL))
	251	rc = -1;
	252
	253	/* Did the user stop this? */
	254	if (had_ctrlc())
	255	return -1; /* if stopped then not repeatable */
	256	}
	257
	258	return rc ? rc : repeatable;
	259	}
	260
c1bb2cd0	261	void cli_simple_loop(void)
6493ccc7	262	{
ca7def60	263	static char lastcommand[CONFIG_SYS_CBSIZE + 1] = { 0, };
6493ccc7 SG	264
	265	int len;
	266	int flag;
	267	int rc = 1;
	268
	269	for (;;) {
6493ccc7 SG	270	if (rc >= 0) {
	271	/* Saw enough of a valid command to
	272	* restart the timeout.
	273	*/
b26440f1	274	bootretry_reset_cmd_timeout();
6493ccc7	275	}
e1bf824d	276	len = cli_readline(CONFIG_SYS_PROMPT);
6493ccc7 SG	277
	278	flag = 0; /* assume no special flags for now */
	279	if (len > 0)
bb08a6e7 PF	280	strlcpy(lastcommand, console_buffer,
bb08a6e7 PF	281	CONFIG_SYS_CBSIZE + 1);
6493ccc7 SG	282	else if (len == 0)
	283	flag \|= CMD_FLAG_REPEAT;
	284	#ifdef CONFIG_BOOT_RETRY_TIME
	285	else if (len == -2) {
	286	/* -2 means timed out, retry autoboot
	287	*/
	288	puts("\nTimed out waiting for command\n");
	289	# ifdef CONFIG_RESET_TO_RETRY
	290	/* Reinit board to run initialization code again */
	291	do_reset(NULL, 0, 0, NULL);
	292	# else
	293	return; /* retry autoboot */
	294	# endif
	295	}
	296	#endif
	297
	298	if (len == -1)
	299	puts("<INTERRUPT>\n");
	300	else
52715f89	301	rc = run_command_repeatable(lastcommand, flag);
6493ccc7 SG	302
	303	if (rc <= 0) {
	304	/* invalid command or not repeatable, forget it */
	305	lastcommand[0] = 0;
	306	}
	307	}
	308	}
	309
	310	int cli_simple_run_command_list(char *cmd, int flag)
	311	{
	312	char line, next;
	313	int rcode = 0;
	314
	315	/*
	316	* Break into individual lines, and execute each line; terminate on
	317	* error.
	318	*/
	319	next = cmd;
	320	line = cmd;
	321	while (*next) {
	322	if (*next == '\n') {
	323	*next = '\0';
	324	/* run only non-empty commands */
	325	if (*line) {
	326	debug("** exec: \"%s\"\n", line);
	327	if (cli_simple_run_command(line, 0) < 0) {
	328	rcode = 1;
	329	break;
	330	}
	331	}
	332	line = next + 1;
	333	}
	334	++next;
	335	}
	336	if (rcode == 0 && *line)
4eb580b7	337	rcode = (cli_simple_run_command(line, 0) < 0);
6493ccc7 SG	338
	339	return rcode;
	340	}