mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
338 lines
7.3 KiB
338 lines
7.3 KiB
// 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 <console.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; |
|
}
|
|
|