[BACK]Return to aitcli.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitcli / src

Diff for /libaitcli/src/aitcli.c between versions 1.6 and 1.19

version 1.6, 2013/05/30 09:16:42 version 1.19, 2022/12/05 22:23:38
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013Copyright 2004 - 2022
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 87  static inline void Line 87  static inline void
 clrscrEOL(linebuffer_t * __restrict buf)  clrscrEOL(linebuffer_t * __restrict buf)
 {  {
         register int i;          register int i;
           int ign __attribute__((unused));
   
        if (buf) {        if (buf && buf->line_prompt) {
                write(buf->line_out, K_CR, 1);                ign = write(buf->line_out, K_CR, 1);
   
                 for (i = 0; i < buf->line_len; i++)                  for (i = 0; i < buf->line_len; i++)
                        write(buf->line_out, K_SPACE, 1);                        ign = write(buf->line_out, K_SPACE, 1);
         }          }
 }  }
   
 static inline void  static inline void
 printfEOL(linebuffer_t * __restrict buf, int len, int prompt)  printfEOL(linebuffer_t * __restrict buf, int len, int prompt)
 {  {
           int ign __attribute__((unused));
   
         if (buf) {          if (buf) {
                write(buf->line_out, K_CR, 1);                if (prompt && buf->line_prompt) {
                         ign = write(buf->line_out, K_CR, 1);
                         ign = write(buf->line_out, buf->line_prompt, buf->line_bol);
                 }
   
                if (prompt && buf->line_prompt)                ign = write(buf->line_out, buf->line_buf, len == -1 ? 
                        write(buf->line_out, buf->line_prompt, buf->line_bol);                                buf->line_eol - buf->line_bol : len);
 
                write(buf->line_out, buf->line_buf, len == -1 ? buf->line_eol - buf->line_bol: len); 
         }          }
 }  }
   
 static inline void  static inline void
 printfCR(linebuffer_t * __restrict buf, int prompt)  printfCR(linebuffer_t * __restrict buf, int prompt)
 {  {
        if (buf) {        int ign __attribute__((unused));
                write(buf->line_out, K_CR, 1); 
   
                if (prompt)        if (buf && prompt && buf->line_prompt) {
                        if (prompt && buf->line_prompt)                ign = write(buf->line_out, K_CR, 1);
                                write(buf->line_out, buf->line_prompt, buf->line_bol);                ign = write(buf->line_out, buf->line_prompt, buf->line_bol);
         }          }
 }  }
   
 static inline void  static inline void
 printfNL(linebuffer_t * __restrict buf, int prompt)  printfNL(linebuffer_t * __restrict buf, int prompt)
 {  {
           int ign __attribute__((unused));
   
         if (buf) {          if (buf) {
                write(buf->line_out, K_ENTER, 1);                ign = write(buf->line_out, K_ENTER, 1);
   
                 if (prompt)                  if (prompt)
                         if (prompt && buf->line_prompt)                          if (prompt && buf->line_prompt)
                                write(buf->line_out, buf->line_prompt, buf->line_bol);                                ign = write(buf->line_out, buf->line_prompt, buf->line_bol);
         }          }
 }  }
   
 // ------------------------------------------------------------  // ------------------------------------------------------------
   
 static int  static int
bufCHAR(int idx, void * __restrict buffer)bufCHAR(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
         int pos;          int pos;
           int ign __attribute__((unused));
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         pos = buf->line_eol - buf->line_bol;          pos = buf->line_eol - buf->line_bol;
Line 156  bufCHAR(int idx, void * __restrict buffer) Line 162  bufCHAR(int idx, void * __restrict buffer)
         memcpy(buf->line_buf + pos, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);          memcpy(buf->line_buf + pos, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
         buf->line_buf[buf->line_len - 1] = 0;          buf->line_buf[buf->line_len - 1] = 0;
   
        write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);        if (buf->line_prompt)
                 ign = write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
   
         if (buf->line_mode == LINEMODE_INS) {          if (buf->line_mode == LINEMODE_INS) {
                write(buf->line_out, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len,                 ign = write(buf->line_out, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len, 
                                 buf->line_len - buf->line_eol);                                  buf->line_len - buf->line_eol);
                 printfEOL(buf, -1, 1);                  printfEOL(buf, -1, 1);
         }          }
Line 167  bufCHAR(int idx, void * __restrict buffer) Line 174  bufCHAR(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufEOL(int idx, void * __restrict buffer)bufEOL(int idx, void * __restrict cli_buffer)
 {  {
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        printfCR(buffer, 1);        printfCR(cli_buffer, 1);
         return RETCODE_EOL;          return RETCODE_EOL;
 }  }
   
 static int  static int
bufEOF(int idx, void * __restrict buffer)bufEOF(int idx, void * __restrict cli_buffer)
 {  {
         /*          /*
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
         */          */
   
Line 188  bufEOF(int idx, void * __restrict buffer) Line 195  bufEOF(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufUP(int idx, void * __restrict buffer)bufUP(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
         int pos;          int pos;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         if (!buf->line_h)          if (!buf->line_h)
Line 219  bufUP(int idx, void * __restrict buffer) Line 226  bufUP(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufDOWN(int idx, void * __restrict buffer)bufDOWN(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
         int pos;          int pos;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         if (!buf->line_h)          if (!buf->line_h)
Line 250  bufDOWN(int idx, void * __restrict buffer) Line 257  bufDOWN(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufCLR(int idx, void * __restrict buffer)bufCLR(int idx, void * __restrict cli_buffer)
 {  {
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        clrscrEOL(buffer);        clrscrEOL(cli_buffer);
        cli_freeLine(buffer);        cli_freeLine(cli_buffer);
   
        printfCR(buffer, 1);        printfCR(cli_buffer, 1);
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
 static int  static int
bufBS(int idx, void * __restrict buffer)bufBS(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         if (buf->line_bol < buf->line_eol) {          if (buf->line_bol < buf->line_eol) {
Line 288  bufBS(int idx, void * __restrict buffer) Line 295  bufBS(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufBTAB(int idx, void * __restrict buffer)bufBTAB(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         if (buf->line_bol < buf->line_eol) {          if (buf->line_bol < buf->line_eol) {
Line 308  bufBTAB(int idx, void * __restrict buffer) Line 315  bufBTAB(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufMODE(int idx, void * __restrict buffer)bufMODE(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         buf->line_mode = !buf->line_mode ? LINEMODE_OVER : LINEMODE_INS;          buf->line_mode = !buf->line_mode ? LINEMODE_OVER : LINEMODE_INS;
Line 320  bufMODE(int idx, void * __restrict buffer) Line 327  bufMODE(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufBEGIN(int idx, void * __restrict buffer)bufBEGIN(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         buf->line_eol = buf->line_bol;          buf->line_eol = buf->line_bol;
Line 334  bufBEGIN(int idx, void * __restrict buffer) Line 341  bufBEGIN(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufEND(int idx, void * __restrict buffer)bufEND(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         buf->line_eol = buf->line_len - 1;          buf->line_eol = buf->line_len - 1;
Line 348  bufEND(int idx, void * __restrict buffer) Line 355  bufEND(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufLEFT(int idx, void * __restrict buffer)bufLEFT(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         if (buf->line_bol < buf->line_eol)          if (buf->line_bol < buf->line_eol)
Line 362  bufLEFT(int idx, void * __restrict buffer) Line 369  bufLEFT(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufRIGHT(int idx, void * __restrict buffer)bufRIGHT(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         if (buf->line_eol < buf->line_len - 1)          if (buf->line_eol < buf->line_len - 1)
Line 376  bufRIGHT(int idx, void * __restrict buffer) Line 383  bufRIGHT(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufDEL(int idx, void * __restrict buffer)bufDEL(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         clrscrEOL(buf);          clrscrEOL(buf);
Line 398  bufDEL(int idx, void * __restrict buffer) Line 405  bufDEL(int idx, void * __restrict buffer)
 }  }
   
 static int  static int
bufComp(int idx, void * __restrict buffer)bufComp(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
         char *str, *s, **app, *items[MAX_PROMPT_ITEMS], szLine[STRSIZ];          char *str, *s, **app, *items[MAX_PROMPT_ITEMS], szLine[STRSIZ];
         register int i, j;          register int i, j;
         struct tagCommand *cmd, *c;          struct tagCommand *cmd, *c;
         int pos, ret = RETCODE_OK;          int pos, ret = RETCODE_OK;
           int ign __attribute__((unused));
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         str = e_strdup(buf->line_buf);          str = e_strdup(buf->line_buf);
Line 422  bufComp(int idx, void * __restrict buffer) Line 430  bufComp(int idx, void * __restrict buffer)
         memset(szLine, 0, STRSIZ);          memset(szLine, 0, STRSIZ);
         if (*s) {          if (*s) {
                 memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);                  memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);
                for (app = items, i = 0; app < items + MAX_PROMPT_ITEMS - 1 && (*app = strsep(&s, " \t"));                 for (app = items, i = 0; app < items + MAX_PROMPT_ITEMS - 1 && 
                                 (*app = strsep(&s, " \t")); 
                                 *app ? i++ : i, *app ? app++ : app);                                  *app ? i++ : i, *app ? app++ : app);
   
                 if (i) {                  if (i) {
                         SLIST_FOREACH(cmd, &buf->line_cmds, cmd_next) {                          SLIST_FOREACH(cmd, &buf->line_cmds, cmd_next) {
                                if (cmd->cmd_level == buf->line_level &&                                 if (cmd->cmd_level & (1 << buf->line_level) && 
                                                !strncmp(cmd->cmd_name, items[0], strlen(items[0]))) {                                                !strncmp(cmd->cmd_name, items[0], 
                                        if (strncmp(cmd->cmd_name, CLI_CMD_SEP, strlen(CLI_CMD_SEP))) {                                                        strlen(items[0]))) {
                                         if (strncmp(cmd->cmd_name, CLI_CMD_SEP, 
                                                                 strlen(CLI_CMD_SEP))) {
                                                 j++;                                                  j++;
                                                 c = cmd;                                                  c = cmd;
                                                 strlcat(szLine, " ", STRSIZ);                                                  strlcat(szLine, " ", STRSIZ);
Line 451  bufComp(int idx, void * __restrict buffer) Line 462  bufComp(int idx, void * __restrict buffer)
         } else {          } else {
                 /* we on 0 position of prompt, show commands for this level */                  /* we on 0 position of prompt, show commands for this level */
                 SLIST_FOREACH(cmd, &buf->line_cmds, cmd_next) {                  SLIST_FOREACH(cmd, &buf->line_cmds, cmd_next) {
                        if (cmd->cmd_level == buf->line_level)                        if (cmd->cmd_level & (1 << buf->line_level))
                                 if (strncmp(cmd->cmd_name, CLI_CMD_SEP, strlen(CLI_CMD_SEP))) {                                  if (strncmp(cmd->cmd_name, CLI_CMD_SEP, strlen(CLI_CMD_SEP))) {
                                         j++;                                          j++;
                                         c = cmd;                                          c = cmd;
Line 464  bufComp(int idx, void * __restrict buffer) Line 475  bufComp(int idx, void * __restrict buffer)
         /* completion show actions ... */          /* completion show actions ... */
         if (j > 1 && c) {          if (j > 1 && c) {
                 printfNL(buf, 0);                  printfNL(buf, 0);
                write(buf->line_out, szLine, strlen(szLine));                ign = write(buf->line_out, szLine, strlen(szLine));
                 printfNL(buf, 1);                  printfNL(buf, 1);
                 printfEOL(buf, buf->line_len - 1, 1);                  printfEOL(buf, buf->line_len - 1, 1);
                 printfEOL(buf, -1, 1);                  printfEOL(buf, -1, 1);
Line 491  endcomp: Line 502  endcomp:
 }  }
   
 static int  static int
bufHelp(int idx, void * __restrict buffer)bufHelp(int idx, void * __restrict cli_buffer)
 {  {
        linebuffer_t *buf = buffer;        linebuffer_t *buf = cli_buffer;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        cli_Cmd_Help(buf, -1, NULL);        cli_Cmd_Help(buf, buf->line_level, NULL);
   
         printfEOL(buf, buf->line_len - 1, 1);          printfEOL(buf, buf->line_len - 1, 1);
         printfEOL(buf, -1, 1);          printfEOL(buf, -1, 1);
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
   static int
   bufEndNode(int idx, void * __restrict cli_buffer)
   {
           linebuffer_t *buf = cli_buffer;
   
           if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_level > 0) {
                   printfNL(cli_buffer, 0);
                   buf->line_level--;
                   cli_Printf(buf, "Enter to config level %d\n", buf->line_level);
           }
   
           return bufCLR(idx, cli_buffer);
   }
   
   
 /*  /*
  * cli_Printf() - Send message to CLI session   * cli_Printf() - Send message to CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @fmt = printf format string   * @fmt = printf format string
  * @... = arguments defined in fmt   * @... = arguments defined in fmt
  * return: none   * return: none
 */  */
 void  void
cli_Printf(linebuffer_t * __restrict buffer, char *fmt, ...)cli_Printf(linebuffer_t * __restrict cli_buffer, char *fmt, ...)
 {  {
         va_list lst;          va_list lst;
         FILE *f;          FILE *f;
   
         if (fmt) {          if (fmt) {
                f = fdopen(buffer->line_out, "a");                f = fdopen(cli_buffer->line_out, "a");
                 if (!f) {                  if (!f) {
                         LOGERR;                          LOGERR;
                         return;                          return;
Line 537  cli_Printf(linebuffer_t * __restrict buffer, char *fmt Line 565  cli_Printf(linebuffer_t * __restrict buffer, char *fmt
 /*  /*
  * cli_PrintHelp() - Print help screen   * cli_PrintHelp() - Print help screen
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * return: none   * return: none
 */  */
 void  void
cli_PrintHelp(linebuffer_t * __restrict buffer)cli_PrintHelp(linebuffer_t * __restrict cli_buffer)
 {  {
        if (buffer) {        if (cli_buffer) {
                bufHelp(0, buffer);                bufHelp(0, cli_buffer);
                clrscrEOL(buffer);                clrscrEOL(cli_buffer);
         } else          } else
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
Line 555  cli_PrintHelp(linebuffer_t * __restrict buffer) Line 583  cli_PrintHelp(linebuffer_t * __restrict buffer)
  * cli_BindKey() - Bind function to key   * cli_BindKey() - Bind function to key
  *   *
  * @key = key structure   * @key = key structure
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position   * return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position
 */  */
 int  int
cli_BindKey(bindkey_t * __restrict key, linebuffer_t * __restrict buffer)cli_BindKey(bindkey_t * __restrict key, linebuffer_t * __restrict cli_buffer)
 {  {
         register int i;          register int i;
   
        if (!key || !buffer) {        if (!key || !cli_buffer) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
         for (i = 0; i < MAX_BINDKEY; i++)          for (i = 0; i < MAX_BINDKEY; i++)
                if (key->key_len == buffer->line_keys[i].key_len &&                 if (key->key_len == cli_buffer->line_keys[i].key_len && 
                                !memcmp(key->key_ch, buffer->line_keys[i].key_ch, key->key_len)) {                                !memcmp(key->key_ch, cli_buffer->line_keys[i].key_ch, 
                        buffer->line_keys[i].key_func = key->key_func;                                        key->key_len)) {
                         cli_buffer->line_keys[i].key_func = key->key_func;
                         return i;                          return i;
                 }                  }
   
Line 582  cli_BindKey(bindkey_t * __restrict key, linebuffer_t * Line 611  cli_BindKey(bindkey_t * __restrict key, linebuffer_t *
 /*  /*
  * cli_addCommand() - Add command to CLI session   * cli_addCommand() - Add command to CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @csCmd = Command name   * @csCmd = Command name
 * @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ... * @cliLevel = Level in CLI, -1 view from all levels, 0 hidden, >0 mask levels
  * @funcCmd = Callback function when user call command   * @funcCmd = Callback function when user call command
  * @csInfo = Inline information for command   * @csInfo = Inline information for command
  * @csHelp = Help line when call help   * @csHelp = Help line when call help
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_addCommand(linebuffer_t * __restrict buffer, const char *csCmd, int cliLevel, cmd_func_t funcCmd, cli_addCommand(linebuffer_t * __restrict cli_buffer, const char *csCmd, 
                 int cliLevel, cmd_func_t funcCmd, 
                 const char *csInfo, const char *csHelp)                  const char *csInfo, const char *csHelp)
 {  {
         struct tagCommand *cmd;          struct tagCommand *cmd;
   
        if (!buffer || !csCmd) {        if (!cli_buffer || !csCmd) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
Line 615  cli_addCommand(linebuffer_t * __restrict buffer, const Line 645  cli_addCommand(linebuffer_t * __restrict buffer, const
                 strlcpy(cmd->cmd_info, csInfo, STRSIZ);                  strlcpy(cmd->cmd_info, csInfo, STRSIZ);
         if (csHelp)          if (csHelp)
                 strlcpy(cmd->cmd_help, csHelp, STRSIZ);                  strlcpy(cmd->cmd_help, csHelp, STRSIZ);
        SLIST_INSERT_HEAD(&buffer->line_cmds, cmd, cmd_next);        SLIST_INSERT_HEAD(&cli_buffer->line_cmds, cmd, cmd_next);
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
 /*  /*
  * cli_delCommand() - Delete command from CLI session   * cli_delCommand() - Delete command from CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @csCmd = Command name   * @csCmd = Command name
 * @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ... * @cliLevel = Level in CLI, -1 view from all levels, 0 hidden, >0 mask levels
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_delCommand(linebuffer_t * __restrict buffer, const char *csCmd, int cliLevel)cli_delCommand(linebuffer_t * __restrict cli_buffer, const char *csCmd, int cliLevel)
 {  {
         struct tagCommand *cmd;          struct tagCommand *cmd;
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
   
        if (!buffer || !csCmd) {        if (!cli_buffer || !csCmd) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        SLIST_FOREACH(cmd, &buffer->line_cmds, cmd_next)         SLIST_FOREACH(cmd, &cli_buffer->line_cmds, cmd_next) 
                 if (cmd->cmd_level == cliLevel && !strcmp(cmd->cmd_name, csCmd)) {                  if (cmd->cmd_level == cliLevel && !strcmp(cmd->cmd_name, csCmd)) {
                         ret = 1;                          ret = 1;
                        SLIST_REMOVE(&buffer->line_cmds, cmd, tagCommand, cmd_next);                        SLIST_REMOVE(&cli_buffer->line_cmds, cmd, tagCommand, cmd_next);
                         e_free(cmd);                          e_free(cmd);
                         break;                          break;
                 }                  }
Line 652  cli_delCommand(linebuffer_t * __restrict buffer, const Line 682  cli_delCommand(linebuffer_t * __restrict buffer, const
 /*  /*
  * cli_updCommand() - Update command in CLI session   * cli_updCommand() - Update command in CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @csCmd = Command name   * @csCmd = Command name
 * @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ... * @cliLevel = Level in CLI, -1 view from all levels, 0 hidden, >0 mask levels
  * @funcCmd = Callback function when user call command   * @funcCmd = Callback function when user call command
  * @csInfo = Inline information for command   * @csInfo = Inline information for command
  * @csHelp = Help line when call help   * @csHelp = Help line when call help
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_updCommand(linebuffer_t * __restrict buffer, const char *csCmd, int cliLevel, cmd_func_t funcCmd, cli_updCommand(linebuffer_t * __restrict cli_buffer, const char *csCmd, 
                 int cliLevel, cmd_func_t funcCmd, 
                 const char *csInfo, const char *csHelp)                  const char *csInfo, const char *csHelp)
 {  {
         struct tagCommand *cmd;          struct tagCommand *cmd;
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
   
        if (!buffer || !csCmd) {        if (!cli_buffer || !csCmd) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        SLIST_FOREACH(cmd, &buffer->line_cmds, cmd_next)         SLIST_FOREACH(cmd, &cli_buffer->line_cmds, cmd_next)
                if (cmd->cmd_level == cliLevel && !strcmp(cmd->cmd_name, csCmd)) {                if ((!cmd->cmd_level || cmd->cmd_level == cliLevel) && 
                        ret = 1;                                !strcmp(cmd->cmd_name, csCmd)) {
                        if (!cmd->cmd_level)
                                 cmd->cmd_level = cliLevel;
                         if (funcCmd)                          if (funcCmd)
                                 cmd->cmd_func = funcCmd;                                  cmd->cmd_func = funcCmd;
                         if (csInfo)                          if (csInfo)
Line 693  cli_updCommand(linebuffer_t * __restrict buffer, const Line 725  cli_updCommand(linebuffer_t * __restrict buffer, const
 /*  /*
  * cli_addHistory() - Add line to history   * cli_addHistory() - Add line to history
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @str = Add custom text or if NULL use readed line from CLI buffer   * @str = Add custom text or if NULL use readed line from CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_addHistory(linebuffer_t * __restrict buffer, const char * __restrict str)cli_addHistory(linebuffer_t * __restrict cli_buffer, const char * __restrict str)
 {  {
         struct tagHistory *h;          struct tagHistory *h;
   
        if (!buffer) {        if (!cli_buffer) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
Line 721  cli_addHistory(linebuffer_t * __restrict buffer, const Line 753  cli_addHistory(linebuffer_t * __restrict buffer, const
   
                 h->hist_len = strlcpy(h->hist_line, str, BUFSIZ);                  h->hist_len = strlcpy(h->hist_line, str, BUFSIZ);
         } else {          } else {
                if (!*buffer->line_buf || buffer->line_len < 2) {                if (!*cli_buffer->line_buf || cli_buffer->line_len < 2) {
                         e_free(h);                          e_free(h);
                         return RETCODE_OK;                          return RETCODE_OK;
                 }                  }
   
                memcpy(h->hist_line, buffer->line_buf, (h->hist_len = buffer->line_len));                memcpy(h->hist_line, cli_buffer->line_buf, (h->hist_len = cli_buffer->line_len));
                 str_Trim(h->hist_line);                  str_Trim(h->hist_line);
                 h->hist_len = strlen(h->hist_line);                  h->hist_len = strlen(h->hist_line);
         }          }
   
        TAILQ_INSERT_HEAD(&buffer->line_history, h, hist_next);        TAILQ_INSERT_HEAD(&cli_buffer->line_history, h, hist_next);
         return h->hist_len;          return h->hist_len;
 }  }
   
 /*  /*
  * cli_saveHistory() - Save history to file   * cli_saveHistory() - Save history to file
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @histfile = History filename, if NULL will be use default name   * @histfile = History filename, if NULL will be use default name
  * @lines = Maximum history lines to save   * @lines = Maximum history lines to save
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_saveHistory(linebuffer_t * __restrict buffer, const char *histfile, int lines)cli_saveHistory(linebuffer_t * __restrict cli_buffer, const char *histfile, int lines)
 {  {
         FILE *f;          FILE *f;
         mode_t mode;          mode_t mode;
         char szFName[MAXPATHLEN];          char szFName[MAXPATHLEN];
         struct tagHistory *h;          struct tagHistory *h;
   
        if (!buffer) {        if (!cli_buffer) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
Line 767  cli_saveHistory(linebuffer_t * __restrict buffer, cons Line 799  cli_saveHistory(linebuffer_t * __restrict buffer, cons
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        TAILQ_FOREACH(h, &buffer->line_history, hist_next) {        TAILQ_FOREACH(h, &cli_buffer->line_history, hist_next) {
                 fprintf(f, "%s\n", h->hist_line);                  fprintf(f, "%s\n", h->hist_line);
   
                 if (lines)                  if (lines)
Line 785  cli_saveHistory(linebuffer_t * __restrict buffer, cons Line 817  cli_saveHistory(linebuffer_t * __restrict buffer, cons
 /*  /*
  * cli_loadHistory() - Load history from file   * cli_loadHistory() - Load history from file
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @histfile = History filename, if NULL will be use default name   * @histfile = History filename, if NULL will be use default name
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_loadHistory(linebuffer_t * __restrict buffer, const char *histfile)cli_loadHistory(linebuffer_t * __restrict cli_buffer, const char *histfile)
 {  {
         FILE *f;          FILE *f;
         char szFName[MAXPATHLEN], buf[BUFSIZ];          char szFName[MAXPATHLEN], buf[BUFSIZ];
         struct tagHistory *h;          struct tagHistory *h;
   
        if (!buffer) {        if (!cli_buffer) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
Line 823  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 855  cli_loadHistory(linebuffer_t * __restrict buffer, cons
                         memset(h, 0, sizeof(struct tagHistory));                          memset(h, 0, sizeof(struct tagHistory));
   
                 h->hist_len = strlcpy(h->hist_line, buf, BUFSIZ);                  h->hist_len = strlcpy(h->hist_line, buf, BUFSIZ);
                TAILQ_INSERT_TAIL(&buffer->line_history, h, hist_next);                TAILQ_INSERT_TAIL(&cli_buffer->line_history, h, hist_next);
         }          }
   
         fclose(f);          fclose(f);
Line 834  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 866  cli_loadHistory(linebuffer_t * __restrict buffer, cons
 /*  /*
  * cli_resetHistory() - Reset history search in CLI session   * cli_resetHistory() - Reset history search in CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * return: none   * return: none
 */  */
 void  void
cli_resetHistory(linebuffer_t * __restrict buffer)cli_resetHistory(linebuffer_t * __restrict cli_buffer)
 {  {
        buffer->line_h = NULL;        cli_buffer->line_h = NULL;
 }  }
   
   
 /*  /*
  * cli_freeLine() - Clear entire line   * cli_freeLine() - Clear entire line
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cli_freeLine(linebuffer_t * __restrict buffer)cli_freeLine(linebuffer_t * __restrict cli_buffer)
 {  {
         int code = RETCODE_ERR;          int code = RETCODE_ERR;
   
        if (buffer) {        if (cli_buffer) {
                if (buffer->line_buf)                if (cli_buffer->line_buf)
                        e_free(buffer->line_buf);                        e_free(cli_buffer->line_buf);
   
                buffer->line_buf = e_malloc(BUFSIZ);                cli_buffer->line_buf = e_malloc(BUFSIZ);
                if (buffer->line_buf) {                if (cli_buffer->line_buf) {
                        memset(buffer->line_buf, 0, BUFSIZ);                        memset(cli_buffer->line_buf, 0, BUFSIZ);
                        buffer->line_eol = buffer->line_bol;                        cli_buffer->line_eol = cli_buffer->line_bol;
                        buffer->line_len = 1 + buffer->line_eol;                        cli_buffer->line_len = 1 + cli_buffer->line_eol;
   
                         code = RETCODE_OK;                          code = RETCODE_OK;
                 } else                  } else
Line 877  cli_freeLine(linebuffer_t * __restrict buffer) Line 909  cli_freeLine(linebuffer_t * __restrict buffer)
 /*  /*
  * cli_setPrompt() - Set new prompt for CLI session   * cli_setPrompt() - Set new prompt for CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @prompt = new text for prompt or if NULL disable prompt   * @prompt = new text for prompt or if NULL disable prompt
  * return: none   * return: none
 */  */
 void  void
cli_setPrompt(linebuffer_t * __restrict buffer, const char *prompt)cli_setPrompt(linebuffer_t * __restrict cli_buffer, const char *prompt)
 {  {
        if (buffer) {        if (cli_buffer) {
                if (buffer->line_prompt) {                if (cli_buffer->line_prompt) {
                        e_free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
                        buffer->line_prompt = NULL;                        cli_buffer->line_prompt = NULL;
                        buffer->line_bol = 0;                        cli_buffer->line_bol = 0;
                 }                  }
   
                 if (prompt) {                  if (prompt) {
                        buffer->line_prompt = e_strdup(prompt);                        cli_buffer->line_prompt = e_strdup(prompt);
                        if (buffer->line_prompt) {                        if (cli_buffer->line_prompt) {
                                buffer->line_bol = strlen(buffer->line_prompt);                                cli_buffer->line_bol = strlen(cli_buffer->line_prompt);
                                buffer->line_eol = buffer->line_bol;                                cli_buffer->line_eol = cli_buffer->line_bol;
                                buffer->line_len = 1 + buffer->line_eol;                                cli_buffer->line_len = 1 + cli_buffer->line_eol;
                         } else                          } else
                                 LOGERR;                                  LOGERR;
                 }                  }
Line 908  cli_setPrompt(linebuffer_t * __restrict buffer, const  Line 940  cli_setPrompt(linebuffer_t * __restrict buffer, const 
 /*  /*
  * cliEnd() - Clear data, Free resources and close CLI session   * cliEnd() - Clear data, Free resources and close CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 void  void
cliEnd(linebuffer_t * __restrict buffer)cliEnd(linebuffer_t * __restrict cli_buffer)
 {  {
         struct tagHistory *h;          struct tagHistory *h;
         struct tagCommand *c;          struct tagCommand *c;
   
        if (buffer) {        if (cli_buffer) {
                while ((c = SLIST_FIRST(&buffer->line_cmds))) {                while ((c = SLIST_FIRST(&cli_buffer->line_cmds))) {
                        SLIST_REMOVE_HEAD(&buffer->line_cmds, cmd_next);                        SLIST_REMOVE_HEAD(&cli_buffer->line_cmds, cmd_next);
                         e_free(c);                          e_free(c);
                 }                  }
                while ((h = TAILQ_FIRST(&buffer->line_history))) {                while ((h = TAILQ_FIRST(&cli_buffer->line_history))) {
                        TAILQ_REMOVE(&buffer->line_history, h, hist_next);                        TAILQ_REMOVE(&cli_buffer->line_history, h, hist_next);
                         e_free(h);                          e_free(h);
                 }                  }
   
                if (buffer->line_prompt)                if (cli_buffer->line_prompt)
                        e_free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
   
                if (buffer->line_keys)                if (cli_buffer->line_keys)
                        e_free(buffer->line_keys);                        e_free(cli_buffer->line_keys);
                if (buffer->line_buf)                if (cli_buffer->line_buf)
                        e_free(buffer->line_buf);                        e_free(cli_buffer->line_buf);
   
                e_free(buffer);                e_free(cli_buffer);
                buffer = NULL;                cli_buffer = NULL;
         } else          } else
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
Line 952  cliEnd(linebuffer_t * __restrict buffer) Line 984  cliEnd(linebuffer_t * __restrict buffer)
 linebuffer_t *  linebuffer_t *
 cliInit(int fin, int fout, const char *prompt)  cliInit(int fin, int fout, const char *prompt)
 {  {
        linebuffer_t *buffer;        linebuffer_t *cli_buffer;
         bindkey_t *keys;          bindkey_t *keys;
         register int i;          register int i;
           char szPrompt[STRSIZ + 16] = {[0 ... STRSIZ + 15] = 0};
   
         /* init buffer */          /* init buffer */
        buffer = e_malloc(sizeof(linebuffer_t));        cli_buffer = e_malloc(sizeof(linebuffer_t));
        if (!buffer) {        if (!cli_buffer) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
         } else {          } else {
                memset(buffer, 0, sizeof(linebuffer_t));                memset(cli_buffer, 0, sizeof(linebuffer_t));
   
                buffer->line_in = fin;                cli_buffer->line_in = fin;
                buffer->line_out = fout;                cli_buffer->line_out = fout;
   
                TAILQ_INIT(&buffer->line_history);                TAILQ_INIT(&cli_buffer->line_history);
                SLIST_INIT(&buffer->line_cmds);                SLIST_INIT(&cli_buffer->line_cmds);
   
                 if (prompt) {                  if (prompt) {
                        buffer->line_prompt = e_strdup(prompt);                        strlcpy(cli_buffer->line_porigin, prompt, sizeof cli_buffer->line_porigin);
                        if (!buffer->line_prompt) {                        snprintf(szPrompt, sizeof szPrompt, "%s{%d}> ", cli_buffer->line_porigin, cli_buffer->line_level);
                         cli_buffer->line_prompt = e_strdup(szPrompt);
                         if (!cli_buffer->line_prompt) {
                                 LOGERR;                                  LOGERR;
                                e_free(buffer);                                e_free(cli_buffer);
                                 return NULL;                                  return NULL;
                         } else                          } else
                                buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);                                cli_buffer->line_eol = cli_buffer->line_bol = 
                }                                        strlen(cli_buffer->line_prompt);
                 } else
                         cli_buffer->line_mode = LINEMODE_OVER;
         }          }
        buffer->line_buf = e_malloc(BUFSIZ);        cli_buffer->line_buf = e_malloc(BUFSIZ);
        if (!buffer->line_buf) {        if (!cli_buffer->line_buf) {
                 LOGERR;                  LOGERR;
                if (buffer->line_prompt)                if (cli_buffer->line_prompt)
                        e_free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
                e_free(buffer);                e_free(cli_buffer);
                 return NULL;                  return NULL;
         } else {          } else {
                memset(buffer->line_buf, 0, BUFSIZ);                memset(cli_buffer->line_buf, 0, BUFSIZ);
                buffer->line_len = 1 + buffer->line_eol;                cli_buffer->line_len = 1 + cli_buffer->line_eol;
         }          }
         keys = e_calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));          keys = e_calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
         if (!keys) {          if (!keys) {
                 LOGERR;                  LOGERR;
                if (buffer->line_prompt)                if (cli_buffer->line_prompt)
                        e_free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
                e_free(buffer->line_buf);                e_free(cli_buffer->line_buf);
                e_free(buffer);                e_free(cli_buffer);
                 return NULL;                  return NULL;
         } else          } else
                 memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));                  memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));
   
         /* add helper functions */          /* add helper functions */
        cli_addCommand(buffer, "exit", 0, cli_Cmd_Exit, "exit <cr>", "Exit from console");        cli_addCommand(cli_buffer, "exit", 1, cli_Cmd_Exit, "exit <cr>", "Exit from console");
        cli_addCommand(buffer, "help", 0, cli_Cmd_Help, "help [command] <cr>", "Help screen");        cli_addCommand(cli_buffer, "help", -1, cli_Cmd_Help, "help [command] <cr>", "Help screen");
        cli_addCommand(buffer, "-------", 0, NULL, "-------------------------", NULL);        cli_addCommand(cli_buffer, "-------", -1, NULL, "-------------------------", NULL);
         cli_addCommand(cli_buffer, "where", -1, cli_Cmd_WhereAmI, "where <cr>", 
                         "Query current level of console");
         cli_addCommand(cli_buffer, "top", -1, cli_Cmd_Top, "top <cr>", "Top level of console");
         cli_addCommand(cli_buffer, "end", -1, cli_Cmd_End, "end <cr>", "End level of console");
         cli_addCommand(cli_buffer, "config", -1, cli_Cmd_Config, "config <cr>", 
                         "Config next level of console");
         cli_addCommand(cli_buffer, "-------", -1, NULL, "-------------------------", NULL);
   
         /* fill key bindings */          /* fill key bindings */
         /* ascii chars & ctrl+chars */          /* ascii chars & ctrl+chars */
Line 1017  cliInit(int fin, int fout, const char *prompt) Line 1061  cliInit(int fin, int fout, const char *prompt)
                         keys[i].key_func = bufEOF;                          keys[i].key_func = bufEOF;
                 if (i == *K_CTRL_M || i == *K_CTRL_J)                  if (i == *K_CTRL_M || i == *K_CTRL_J)
                         keys[i].key_func = bufEOL;                          keys[i].key_func = bufEOL;
                if (i == *K_CTRL_H || i == *K_BACKSPACE)                if (cli_buffer->line_prompt && (i == *K_CTRL_H || i == *K_BACKSPACE))
                         keys[i].key_func = bufBS;                          keys[i].key_func = bufBS;
                 if (i == *K_CTRL_C)                  if (i == *K_CTRL_C)
                         keys[i].key_func = bufCLR;                          keys[i].key_func = bufCLR;
                if (i == *K_CTRL_A)                if (cli_buffer->line_prompt && i == *K_CTRL_A)
                         keys[i].key_func = bufBEGIN;                          keys[i].key_func = bufBEGIN;
                if (i == *K_CTRL_E)                if (cli_buffer->line_prompt && i == *K_CTRL_E)
                         keys[i].key_func = bufEND;                          keys[i].key_func = bufEND;
                if (i == *K_TAB)                if (cli_buffer->line_prompt && i == *K_TAB)
                         keys[i].key_func = bufComp;                          keys[i].key_func = bufComp;
                   if (i == *K_CTRL_Z)
                           keys[i].key_func = bufEndNode;
                 if (i >= *K_SPACE && i < *K_BACKSPACE)                  if (i >= *K_SPACE && i < *K_BACKSPACE)
                         keys[i].key_func = bufCHAR;                          keys[i].key_func = bufCHAR;
                 if (i > *K_BACKSPACE && i < 0xff)                  if (i > *K_BACKSPACE && i < 0xff)
                         keys[i].key_func = bufCHAR;                          keys[i].key_func = bufCHAR;
                if (i == '?')                if (cli_buffer->line_prompt && i == '?')
                         keys[i].key_func = bufHelp;                          keys[i].key_func = bufHelp;
         }          }
         /* alt+chars */          /* alt+chars */
Line 1127  cliInit(int fin, int fout, const char *prompt) Line 1173  cliInit(int fin, int fout, const char *prompt)
         memcpy(keys[i].key_ch, K_CTRL_F12, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F12, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_HOME - 1;          keys[i].key_len = sizeof K_HOME - 1;
        keys[i].key_func = bufBEGIN;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufBEGIN;
         memcpy(keys[i].key_ch, K_HOME, keys[i].key_len);          memcpy(keys[i].key_ch, K_HOME, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_END - 1;          keys[i].key_len = sizeof K_END - 1;
        keys[i].key_func = bufEND;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufEND;
         memcpy(keys[i].key_ch, K_END, keys[i].key_len);          memcpy(keys[i].key_ch, K_END, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_UP - 1;          keys[i].key_len = sizeof K_UP - 1;
        keys[i].key_func = bufUP;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufUP;
         memcpy(keys[i].key_ch, K_UP, keys[i].key_len);          memcpy(keys[i].key_ch, K_UP, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_DOWN - 1;          keys[i].key_len = sizeof K_DOWN - 1;
        keys[i].key_func = bufDOWN;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufDOWN;
         memcpy(keys[i].key_ch, K_DOWN, keys[i].key_len);          memcpy(keys[i].key_ch, K_DOWN, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_RIGHT - 1;          keys[i].key_len = sizeof K_RIGHT - 1;
        keys[i].key_func = bufRIGHT;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufRIGHT;
         memcpy(keys[i].key_ch, K_RIGHT, keys[i].key_len);          memcpy(keys[i].key_ch, K_RIGHT, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_LEFT - 1;          keys[i].key_len = sizeof K_LEFT - 1;
        keys[i].key_func = bufLEFT;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufLEFT;
         memcpy(keys[i].key_ch, K_LEFT, keys[i].key_len);          memcpy(keys[i].key_ch, K_LEFT, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_BTAB - 1;          keys[i].key_len = sizeof K_BTAB - 1;
        keys[i].key_func = bufBTAB;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufBTAB;
         memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);          memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);
         i++;          i++;
         /* 4 bytes */          /* 4 bytes */
         keys[i].key_len = sizeof K_INS - 1;          keys[i].key_len = sizeof K_INS - 1;
        keys[i].key_func = bufMODE;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufMODE;
         memcpy(keys[i].key_ch, K_INS, keys[i].key_len);          memcpy(keys[i].key_ch, K_INS, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_DEL - 1;          keys[i].key_len = sizeof K_DEL - 1;
        keys[i].key_func = bufDEL;        if (cli_buffer->line_prompt)
                 keys[i].key_func = bufDEL;
         memcpy(keys[i].key_ch, K_DEL, keys[i].key_len);          memcpy(keys[i].key_ch, K_DEL, keys[i].key_len);
         i++;          i++;
         keys[i].key_len = sizeof K_PGUP - 1;          keys[i].key_len = sizeof K_PGUP - 1;
Line 1195  cliInit(int fin, int fout, const char *prompt) Line 1250  cliInit(int fin, int fout, const char *prompt)
         memcpy(keys[i].key_ch, K_F12, keys[i].key_len);          memcpy(keys[i].key_ch, K_F12, keys[i].key_len);
         i++;          i++;
   
        buffer->line_keys = keys;        cli_buffer->line_keys = keys;
        return buffer;        return cli_buffer;
 }  }
   
 /*  /*
 * cliInitLine() - Init CLI input line terminal * cliSetLine() - Set CLI input line terminal
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
 * return: none * @old = Old terminal settings
  * return: -1 error or 0 ok
 */  */
 int  int
cliInitLine(linebuffer_t * __restrict buffer)cliSetLine(linebuffer_t * __restrict cli_buffer, struct termios * __restrict old)
 {  {
         struct termios t;          struct termios t;
   
         memset(&t, 0, sizeof t);          memset(&t, 0, sizeof t);
        tcgetattr(buffer->line_in, &t);        tcgetattr(cli_buffer->line_in, &t);
        t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOCTL | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT);        if (old)
                 memcpy(old, &t, sizeof(struct termios));
         t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | 
                         ECHOCTL | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT);
         t.c_iflag |= IGNBRK;          t.c_iflag |= IGNBRK;
         t.c_cc[VMIN] = 1;          t.c_cc[VMIN] = 1;
         t.c_cc[VTIME] = 0;          t.c_cc[VTIME] = 0;
        return tcsetattr(buffer->line_in, TCSANOW, &t);        return tcsetattr(cli_buffer->line_in, TCSANOW, &t);
 }  }
   
 /*  /*
    * cliResetLine() - Reset CLI input line terminal
    *
    * @cli_buffer = CLI buffer
    * @old = Original terminal settings
    * return: -1 error or 0 ok
   */
   int
   cliResetLine(linebuffer_t * __restrict cli_buffer, struct termios * __restrict orig)
   {
           return tcsetattr(cli_buffer->line_in, TCSANOW, orig);
   }
   
   /*
  * cliReadLine() - Read line from opened CLI session   * cliReadLine() - Read line from opened CLI session
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @timeout = Session timeout (-1 infinit)
  * return: NULL if error or !=NULL readed line, must be e_free after use!   * return: NULL if error or !=NULL readed line, must be e_free after use!
 */  */
 char *  char *
cliReadLine(linebuffer_t * __restrict buffer)cliReadLine(linebuffer_t * __restrict cli_buffer, int timeout)
 {  {
        int code, readLen;        int code, readLen, ret;
         register int i;          register int i;
         struct pollfd fds;          struct pollfd fds;
         char buf[BUFSIZ], *str = NULL;          char buf[BUFSIZ], *str = NULL;
   
        if (!buffer) {        if (!cli_buffer) {
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return NULL;                  return NULL;
        }        } else if (timeout > 0)
                 timeout *= 1000;        /* convert from sec to ms */
   
         memset(&fds, 0, sizeof fds);          memset(&fds, 0, sizeof fds);
        fds.fd = buffer->line_in;        fds.fd = cli_buffer->line_in;
         fds.events = POLLIN;          fds.events = POLLIN;
   
        printfCR(buffer, 1);        printfCR(cli_buffer, 1);
         while (42) {          while (42) {
                if (poll(&fds, 1, -1) < 1) {                if ((ret = poll(&fds, 1, timeout)) < 1) {
                        LOGERR;                        if (!ret) {
                                 cli_buffer->line_kill = 1;
                                 if (str) {
                                         e_free(str);
                                         str = NULL;
                                 }
                         } else
                                 LOGERR;
                         return str;                          return str;
                 }                  }
   
                 memset(buf, 0, sizeof buf);                  memset(buf, 0, sizeof buf);
                readLen = read(buffer->line_in, buf, BUFSIZ);                readLen = read(cli_buffer->line_in, buf, BUFSIZ);
                if (readLen == -1) {                if (readLen < 1) {
                        LOGERR;                        if (readLen)
                        return str;                                LOGERR;
                         return NULL;
                 }                  }
                 if (!readLen) {  
                         if (buffer->line_buf)  
                                 str = e_strdup(buffer->line_buf);  
                         else  
                                 cli_SetErr(EPIPE, "Unknown state ...");  
                         return str;  
                 }  
   
 recheck:  recheck:
                 for (code = RETCODE_OK, i = MAX_BINDKEY - 1; i > -1; i--)                  for (code = RETCODE_OK, i = MAX_BINDKEY - 1; i > -1; i--)
                        if (readLen >= buffer->line_keys[i].key_len &&                         if (readLen >= cli_buffer->line_keys[i].key_len && 
                                        !memcmp(buffer->line_keys[i].key_ch, buf,                                         !memcmp(cli_buffer->line_keys[i].key_ch, buf, 
                                                buffer->line_keys[i].key_len)) {                                                cli_buffer->line_keys[i].key_len)) {
                                readLen -= buffer->line_keys[i].key_len;                                readLen -= cli_buffer->line_keys[i].key_len;
                                 if (readLen)                                  if (readLen)
                                        memmove(buf, buf + buffer->line_keys[i].key_len, readLen);                                        memmove(buf, buf + cli_buffer->line_keys[i].key_len, readLen);
                                 else                                  else
                                        memset(buf, 0, buffer->line_keys[i].key_len);                                        memset(buf, 0, cli_buffer->line_keys[i].key_len);
   
                                if (buffer->line_keys[i].key_func)                                if (cli_buffer->line_keys[i].key_func)
                                        if ((code = buffer->line_keys[i].key_func(i, buffer)))                                        if ((code = cli_buffer->line_keys[i].key_func(i, cli_buffer)))
                                                 readLen = 0;                                                  readLen = 0;
   
                                 if (readLen)                                  if (readLen)
Line 1288  recheck: Line 1363  recheck:
                         break;                          break;
         }          }
   
        if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)        if (code != RETCODE_ERR && code != RETCODE_EOF && cli_buffer->line_buf)
                str = e_strdup(buffer->line_buf);                str = e_strdup(cli_buffer->line_buf);
         return str;          return str;
 }  }
   
Line 1297  recheck: Line 1372  recheck:
 /*  /*
  * cliNetLoop() - CLI network main loop binded to socket   * cliNetLoop() - CLI network main loop binded to socket
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
  * @csHistFile = History file name   * @csHistFile = History file name
  * @sock = client socket   * @sock = client socket
    * @timeout = Session timeout (-1 infinit)
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cliNetLoop(linebuffer_t * __restrict buffer, const char *csHistFile, int sock)cliNetLoop(linebuffer_t * __restrict cli_buffer, const char *csHistFile, 
                 int sock, int timeout)
 {  {
         u_char buf[BUFSIZ];          u_char buf[BUFSIZ];
        int pid, stat, pty, r, s, alen, flg, attrlen = 0, ret = 0;        int pid, stat, pty, s, alen, flg, attrlen = 0, ret = 0;
         fd_set fds;          fd_set fds;
         struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };          struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
         struct telnetAttrs *a, Attr[10];          struct telnetAttrs *a, Attr[10];
Line 1316  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1393  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
                 case 0:                  case 0:
                        if (!buffer) {                        if (!cli_buffer) {
                                 cli_SetErr(EINVAL, "Invalid input parameters ...");                                  cli_SetErr(EINVAL, "Invalid input parameters ...");
                                 return -1;                                  return -1;
                         } else                          } else
                                 close(sock);                                  close(sock);
   
                        ret = cliLoop(buffer, csHistFile) < 0 ? 1 : 0;                        ret = cliLoop(cli_buffer, csHistFile, timeout) < 0 ? 1 : 0;
                        cliEnd(buffer);                        cliEnd(cli_buffer);
   
                        exit(ret);                        _exit(ret);
                 default:                  default:
                         cli_telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);                          cli_telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
                         cli_telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);                          cli_telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
Line 1351  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1428  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                                         break;                                          break;
                                 }                                  }
   
                                 r = FD_ISSET(sock, &fds) ? sock : pty;  
                                 s = FD_ISSET(sock, &fds) ? pty : sock;                                  s = FD_ISSET(sock, &fds) ? pty : sock;
   
                                 if (FD_ISSET(sock, &fds)) {                                  if (FD_ISSET(sock, &fds)) {
Line 1391  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1467  cliNetLoop(linebuffer_t * __restrict buffer, const cha
   
                                 if (FD_ISSET(pty, &fds)) {                                  if (FD_ISSET(pty, &fds)) {
                                         memset(buf, 0, BUFSIZ);                                          memset(buf, 0, BUFSIZ);
                                        if ((ret = read(pty, buf, BUFSIZ)) == -1) {                                        if ((ret = read(pty, buf, BUFSIZ)) < 1) {
                                                LOGERR;                                                if (ret)
                                                         LOGERR;
                                                 break;                                                  break;
                                         }                                          }
   
Line 1411  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1488  cliNetLoop(linebuffer_t * __restrict buffer, const cha
 }  }
   
 /*  /*
 * cliLoop() - CLI main loop * cliRun() - CLI run command line
  *   *
 * @buffer = CLI buffer * @cli_buffer = CLI buffer
 * @csHistFile = History file name * @psInput = Input command line
  * @prompt = Display prompt after command
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cliLoop(linebuffer_t * __restrict buffer, const char *csHistFile)cliRun(linebuffer_t * __restrict cli_buffer, char *psInput, int prompt)
 {  {
         char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];          char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
         register int i;          register int i;
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
         struct tagCommand *cmd;          struct tagCommand *cmd;
   
           if (!psInput)
                   return RETCODE_ERR;
           else
                   line = psInput;
   
           // clear whitespaces
           for (s = line; isspace((int) *s); s++);
           if (*s) {
                   for (t = s + strlen(s) - 1; t > s && isspace((int) *t); t--);
                   *++t = 0;
           }
   
           if (*s) {
                   memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);
                   for (app = items; app < items + MAX_PROMPT_ITEMS - 1 && 
                                   (*app = strsep(&s, " \t")); *app ? app++ : app);
   
                   // exec_cmd ...
                   i = 0;
                   SLIST_FOREACH(cmd, &cli_buffer->line_cmds, cmd_next) {
                           if (!(cmd->cmd_level & (1 << cli_buffer->line_level)))
                                   continue;
                           if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))
                                   break;
                           else
                                   i++;
                   }
   
                   if (!cmd) {
                           cli_Printf(cli_buffer, "%sCommand '%s' not found!\n", 
                                           cli_buffer->line_prompt ? "\n" : "", items[0]);
                           ret = RETCODE_ERR;
                   } else
                           if (cmd->cmd_func) {
                                   if (prompt && cli_buffer->line_prompt)
                                           cli_Printf(cli_buffer, "\n");
                                   ret = cmd->cmd_func(cli_buffer, 
                                                   cli_buffer->line_level, items);
                           } else if (prompt) {
                                   clrscrEOL(cli_buffer);
                                   printfCR(cli_buffer, 1);
                           }
           }
   
           return ret;
   }
   
   /*
    * cliLoop() - CLI main loop
    *
    * @cli_buffer = CLI buffer
    * @csHistFile = History file name
    * @timeout = Session timeout (-1 infinit)
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   int
   cliLoop(linebuffer_t * __restrict cli_buffer, const char *csHistFile, int timeout)
   {
           char *line;
           int ret = RETCODE_OK;
           struct termios t;
   
         /* --- main body of CLI --- */          /* --- main body of CLI --- */
        cliInitLine(buffer);        cliSetLine(cli_buffer, &t);
   
        if (cli_loadHistory(buffer, csHistFile) == RETCODE_ERR)        if (cli_loadHistory(cli_buffer, csHistFile) == RETCODE_ERR)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         do {          do {
                line = cliReadLine(buffer);                line = cliReadLine(cli_buffer, timeout);
                 if (!line) {                  if (!line) {
                        printfNL(buffer, 0);                        printfNL(cli_buffer, 0);
                         break;                          break;
                 } else                  } else
                        cli_addHistory(buffer, NULL);                        cli_addHistory(cli_buffer, NULL);
                // clear whitespaces 
                for (s = line; isspace((int) *s); s++); 
                if (*s) { 
                        for (t = s + strlen(s) - 1; t > s && isspace((int) *t); t--); 
                        *++t = 0; 
                } 
   
                if (*s) {                ret = cliRun(cli_buffer, line, 42);
                        memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS); 
                        for (app = items; app < items + MAX_PROMPT_ITEMS - 1 && (*app = strsep(&s, " \t"));  
                                        *app ? app++ : app); 
   
                        // exec_cmd ...                cli_freeLine(cli_buffer);
                        i = 0;                cli_resetHistory(cli_buffer);
                        SLIST_FOREACH(cmd, &buffer->line_cmds, cmd_next) {                e_free(line);
                                if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))        } while (!cli_buffer->line_kill);
                                        break; 
                                else 
                                        i++; 
                        } 
   
                        if (!cmd) {        cli_saveHistory(cli_buffer, csHistFile, HISTORY_LINES);
                                cli_Printf(buffer, "\nCommand '%s' not found!\n", items[0]); 
                                ret = -1; 
                        } else 
                                if (cmd->cmd_func) { 
                                        cli_Printf(buffer, "\n"); 
                                        ret = cmd->cmd_func(buffer, i, items); 
                                } else { 
                                        clrscrEOL(buffer); 
                                        printfCR(buffer, 1); 
                                } 
                } 
   
                cli_freeLine(buffer);        /* --- restore tty --- */
                cli_resetHistory(buffer);        cliResetLine(cli_buffer, &t);
                e_free(line); 
        } while (ret < 1); 
   
         cli_saveHistory(buffer, csHistFile, HISTORY_LINES);  
         return ret;          return ret;
 }  }
Removed from v.1.6  
changed lines
  Added in v.1.19

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>