/* * (C) Copyright 2014-2016 Leo C. * * (C) Copyright 2000 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. * * Add to readline cmdline-editing by * (C) Copyright 2005 * JinHua Luo, GuangDong Linux Center, * * SPDX-License-Identifier: GPL-2.0 */ #include "cli.h" #include "common.h" #include #include #include #include #include "config.h" #include "command.h" #include "xmalloc.h" #include "debug.h" #include "env.h" #include "cli_readline.h" #include "con-utils.h" /* FIXME: Quoting problems */ #define DEBUG_PARSER 0 /* set to 1 to debug */ #define debug_parser(fmt, args...) \ debug_cond(DEBUG_PARSER, fmt, ##args) static bool opt_xtrace; static bool opt_verbose; static int_least8_t command_level; static void cli_trace_cmd(int_fast8_t level, int argc, char *argv[]) { while (level-- > 0) putchar('+'); for (int_fast8_t i = 0; i < argc; i++) printf_P(PSTR(" %s"), argv[i]); putchar('\n'); } static int cli_parse_line(char *line, char *argv[]) { uint_fast8_t state = 0; uint_fast8_t nargs = 0; char *inp, *outp; char c, quote; debug_parser("%s: \"%s\"\n", __func__, line); for (outp = inp = line, quote = '\0'; (c = *inp) != '\0'; inp++) { switch (state) { case 0: /* before arg string, waiting for arg start */ if (isblank(c)) continue; argv[nargs++] = inp; /* begin of argument string */ outp = inp; state = 1; /* fall thru */ case 1: /* in arg string, waiting for end of arg string */ if (c == '\\') { ++state; continue; } if (c == '\"' || c == '\'') { quote = c; state = 3; continue; } if (isblank(c)) { c = '\0'; state = 0; } break; case 3: /* in quote */ if (c == '\\' && quote == '\"') { ++state; continue; } if (c == quote) { state = 1; continue; } break; case 2: /* waiting for next char */ case 4: --state; break; } if (nargs > CONFIG_SYS_MAXARGS) { --nargs; break; } *outp++ = c; } if (*inp != '\0') printf_P(PSTR("** Too many args (max. %d) **\n"), CONFIG_SYS_MAXARGS); *outp = '\0'; argv[nargs] = NULL; debug_parser("%s: nargs=%d\n", __func__, nargs); #if 0 for (int i = 0; i < nargs; i++) debug_parser("%s: arg %d: >%s<\n", __func__, i, argv[i]); #endif return nargs; } static void append_char(uint_fast8_t pass, char **p, char c) { if (pass) { **p = c; } ++(*p); } static char *process_macros(char *input, char *output) { char c, prev, *inp, *outp; const char *varname = NULL; for(uint_fast8_t pass = 0; pass < 2; pass++) { uint_fast8_t state = 0; /* 0 = waiting for '$' */ /* 1 = waiting for '{' */ /* 2 = waiting for '}' */ /* 3 = waiting for ''' */ if (pass == 0) { outp = output; } else { int outputlen = outp - output; outp = xrealloc(output, outputlen); output = outp; } inp = input; debug_parser("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen(inp), inp); for (prev = '\0'; (c = *inp++) != '\0'; prev = c) { switch (state) { case 0: /* Waiting for (unescaped) $ */ if ((c == '\'') && (prev != '\\')) { state = 3; break; } if ((c == '$') && (prev != '\\')) { state++; continue; } break; case 1: /* Waiting for { */ if (c == '{') { state++; varname = inp; continue; } else { state = 0; append_char(pass, &outp, '$'); } break; case 2: /* Waiting for } */ if (c == '}') { /* Terminate variable name */ *(inp-1) = '\0'; const char *envval = getenv_str(varname); *(inp-1) = '}'; /* Copy into the line if it exists */ if (envval != NULL) while (*envval) append_char(pass, &outp, *(envval++)); /* Look for another '$' */ state = 0; } continue; case 3: /* Waiting for ' */ if (c == '\'') state = 0; break; } append_char(pass, &outp, c); } append_char(pass, &outp, 0); } debug_parser("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n", strlen(output), output); return output; } /** * * * WARNING: * * We must create a temporary copy of the command since the command we get * may be the result from getenv_str(), 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). * * * @param cmd * @param flag * @returns * */ static int cli_run_command(const char *cmd, int flag) { char *cmdbuf; /* working copy of cmd */ char *token; /* start of token in cmdbuf */ char *sep; /* end of token (separator) in cmdbuf */ char *finaltoken = NULL; /* token after macro expansion */ char *str; char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */ int argc; uint_fast8_t inquotes, repeatable = 1; int rc = 0; opt_verbose = 0; opt_xtrace = 0; char *optenv = getenv_str(PSTR("cli")); if (optenv) { opt_verbose = (strstr_P(optenv, PSTR("verbose")) != NULL); opt_xtrace = (strstr_P(optenv, PSTR("xtrace")) != NULL); } debug_parser("[RUN_COMMAND] cmd[%p]=\"%s\"\n", cmd, cmd ? cmd : "NULL"); if (opt_verbose) printf_P(PSTR("%s\n"), cmd, cmd ? cmd : ""); clear_ctrlc(); /* forget any previous Control C */ if (!cmd || !*cmd) return -1; /* empty command */ cmdbuf = strdup(cmd); if (!cmdbuf) return -1; /* not enough memory */ ++command_level; str = cmdbuf; /* 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 != str) && /* past string start */ (*(sep - 1) != '\\')) /* and NOT escaped */ inquotes = !inquotes; if (!inquotes && (*sep == ';' || *sep == '\n' /* separator */ || *sep == '#') && /* or start of comment */ ((sep == str) || /* string start */ (*(sep - 1) != '\\'))) /* or NOT escaped */ break; } /* no more commands after unescaped '#' token */ if (*sep == '#') *sep = '\0'; /* 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 */ finaltoken = process_macros(token, finaltoken); /* Extract arguments */ argc = cli_parse_line(finaltoken, argv); if (argc == 0) { //rc = -1; continue; /* no command at all */ } if (opt_xtrace) cli_trace_cmd(command_level, argc, argv); rc = cmd_process(flag, argc, argv, &repeatable); if (rc != CMD_RET_SUCCESS) { if (opt_verbose) printf_P(PSTR("Command failed, result=%d\n"), rc); rc = -1; } /* Did the user stop this? */ if (had_ctrlc()) { rc = -1; /* if stopped then not repeatable */ break; } } free(cmdbuf); free(finaltoken); --command_level; return rc ? rc : repeatable; } static int cli_run_command_list(const char *cmd) { return (cli_run_command(cmd, 0) < 0); } /******************************************************************************/ /* * Run a command. * * @param cmd Command to run * @param flag Execution flags (CMD_FLAG_...) * @return 0 on success, or != 0 on error. */ int run_command(const char *cmd, int flag) { /* * cli_run_command can return 0 or 1 for success, so clean up * its result. */ if (cli_run_command(cmd, flag) == -1) return 1; return 0; } /* * Run a command using the selected parser, and check if it is repeatable. * * @param cmd Command to run * @param flag Execution flags (CMD_FLAG_...) * @return 0 (not repeatable) or 1 (repeatable) on success, -1 on error. */ static int run_command_repeatable(const char *cmd, int flag) { return cli_run_command(cmd, flag); } int run_command_list(const char *cmd, int len) { (void) len; return cli_run_command_list(cmd); } /****************************************************************************/ void cli_loop(void) { char *lastcommand = NULL; int len; int flag; int rc = 1; for (;;) { len = cli_readline(lastcommand ? PSTR(CONFIG_SYS_PROMPT_REPEAT) : PSTR(CONFIG_SYS_PROMPT), 1); flag = 0; /* assume no special flags for now */ if (len > 0) { free (lastcommand); lastcommand = strdup(console_buffer); } else if (len == 0) flag |= CMD_FLAG_REPEAT; if (len == -1) { if (opt_verbose) my_puts_P(PSTR("\n")); } else rc = run_command_repeatable(lastcommand, flag); if (rc <= 0) { /* invalid command or not repeatable, forget it */ free(lastcommand); lastcommand = NULL; } } }