[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.3 and 1.8

version 1.3, 2011/03/16 17:24:03 version 1.8, 2013/09/02 11:26:36
Line 5 Line 5
 * $Author$  * $Author$
 * $Id$  * $Id$
 *  *
*************************************************************************/**************************************************************************
 The ELWIX and AITNET software is distributed under the following
 terms:
 
 All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
 
 Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
         by Michael Pounov <misho@elwix.org>.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 3. All advertising materials mentioning features or use of this software
    must display the following acknowledgement:
 This product includes software developed by Michael Pounov <misho@elwix.org>
 ELWIX - Embedded LightWeight unIX and its contributors.
 4. Neither the name of AITNET nor the names of its contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.
 */
 #include "global.h"  #include "global.h"
 #include "cli.h"  #include "cli.h"
   
   
 #pragma GCC visibility push(hidden)  #pragma GCC visibility push(hidden)
   
 // ------------------------------------------------  
   
 int cli_Errno;  int cli_Errno;
 char cli_Error[STRSIZ];  char cli_Error[STRSIZ];
   
 #pragma GCC visibility pop  #pragma GCC visibility pop
   
 // cli_GetErrno() Get error code of last operation  // cli_GetErrno() Get error code of last operation
inline intint
 cli_GetErrno()  cli_GetErrno()
 {  {
         return cli_Errno;          return cli_Errno;
 }  }
   
// io_GetError() Get error text of last operation// cli_GetError() Get error text of last operation
inline const char *const char *
 cli_GetError()  cli_GetError()
 {  {
         return cli_Error;          return cli_Error;
 }  }
   
 // cli_SetErr() Set error to variables for internal use!!!  // cli_SetErr() Set error to variables for internal use!!!
inline voidvoid
 cli_SetErr(int eno, char *estr, ...)  cli_SetErr(int eno, char *estr, ...)
 {  {
         va_list lst;          va_list lst;
   
         cli_Errno = eno;          cli_Errno = eno;
        memset(cli_Error, 0, STRSIZ);        memset(cli_Error, 0, sizeof cli_Error);
         va_start(lst, estr);          va_start(lst, estr);
        vsnprintf(cli_Error, STRSIZ, estr, lst);        vsnprintf(cli_Error, sizeof cli_Error, estr, lst);
         va_end(lst);          va_end(lst);
 }  }
   
Line 101  printfNL(linebuffer_t * __restrict buf, int prompt) Line 136  printfNL(linebuffer_t * __restrict buf, int prompt)
 // ------------------------------------------------------------  // ------------------------------------------------------------
   
 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;
   
        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 132  bufCHAR(int idx, void * __restrict buffer) Line 167  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 153  bufEOF(int idx, void * __restrict buffer) Line 188  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 184  bufUP(int idx, void * __restrict buffer) Line 219  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 215  bufDOWN(int idx, void * __restrict buffer) Line 250  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 253  bufBS(int idx, void * __restrict buffer) Line 288  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 273  bufBTAB(int idx, void * __restrict buffer) Line 308  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 285  bufMODE(int idx, void * __restrict buffer) Line 320  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 299  bufBEGIN(int idx, void * __restrict buffer) Line 334  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 313  bufEND(int idx, void * __restrict buffer) Line 348  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 327  bufLEFT(int idx, void * __restrict buffer) Line 362  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 341  bufRIGHT(int idx, void * __restrict buffer) Line 376  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 363  bufDEL(int idx, void * __restrict buffer) Line 398  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;
   
        if (!buffer || idx < 0 || idx > MAX_BINDKEY)        if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        str = strdup(buf->line_buf);        str = e_strdup(buf->line_buf);
         if (!str)          if (!str)
                 return RETCODE_ERR;                  return RETCODE_ERR;
         else {          else {
                 s = str;                  s = str;
                io_TrimStr((u_char*) s);                str_Trim(s);
         }          }
   
         i = j = 0;          i = j = 0;
Line 451  bufComp(int idx, void * __restrict buffer) Line 486  bufComp(int idx, void * __restrict buffer)
         }          }
   
 endcomp:  endcomp:
        free(str);        e_free(str);
         return ret;          return ret;
 }  }
   
 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, -1, NULL);
Line 470  bufHelp(int idx, void * __restrict buffer) Line 505  bufHelp(int idx, void * __restrict buffer)
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
 // ---------------------------------------------------------------  
   
 /*  /*
 * 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
 */  */
inline voidvoid
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 496  cli_Printf(linebuffer_t * __restrict buffer, char *fmt Line 531  cli_Printf(linebuffer_t * __restrict buffer, char *fmt
                 vfprintf(f, fmt, lst);                  vfprintf(f, fmt, lst);
                 va_end(lst);                  va_end(lst);
         } else          } else
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
   
 /*  /*
 * cli_PrintHelp() Print help screen * cli_PrintHelp() - Print help screen
 * @buffer = CLI buffer *
  * @cli_buffer = CLI buffer
  * return: none   * return: none
 */  */
inline voidvoid
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, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
   
   
 /*  /*
 * 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, "Error:: 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 543  cli_BindKey(bindkey_t * __restrict key, linebuffer_t * Line 581  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 unprivi(view from all), 0 main config, 1 sub config ...
  * @funcCmd = Callback function when user call command   * @funcCmd = Callback function when user call command
Line 553  cli_BindKey(bindkey_t * __restrict key, linebuffer_t * Line 592  cli_BindKey(bindkey_t * __restrict key, linebuffer_t *
  * 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, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        cmd = malloc(sizeof(struct tagCommand));        cmd = e_malloc(sizeof(struct tagCommand));
         if (!cmd) {          if (!cmd) {
                 LOGERR;                  LOGERR;
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 577  cli_addCommand(linebuffer_t * __restrict buffer, const Line 617  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 unprivi(view from all), 0 main config, 1 sub config ...
  * 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, "Error:: 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);
                        free(cmd);                        e_free(cmd);
                         break;                          break;
                 }                  }
   
Line 611  cli_delCommand(linebuffer_t * __restrict buffer, const Line 652  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 unprivi(view from all), 0 main config, 1 sub config ...
  * @funcCmd = Callback function when user call command   * @funcCmd = Callback function when user call command
Line 621  cli_delCommand(linebuffer_t * __restrict buffer, const Line 663  cli_delCommand(linebuffer_t * __restrict buffer, const
  * 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, "Error:: 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;
   
Line 651  cli_updCommand(linebuffer_t * __restrict buffer, const Line 694  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, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        if (!(h = malloc(sizeof(struct tagHistory)))) {        if (!(h = e_malloc(sizeof(struct tagHistory)))) {
                 LOGERR;                  LOGERR;
                 return RETCODE_ERR;                  return RETCODE_ERR;
         } else          } else
Line 674  cli_addHistory(linebuffer_t * __restrict buffer, const Line 718  cli_addHistory(linebuffer_t * __restrict buffer, const
   
         if (str) {          if (str) {
                 if (!*str) {                  if (!*str) {
                        free(h);                        e_free(h);
                         return RETCODE_OK;                          return RETCODE_OK;
                 }                  }
   
                 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) {
                        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));
                io_TrimStr((u_char*) 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, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
         if (!histfile)          if (!histfile)
Line 725  cli_saveHistory(linebuffer_t * __restrict buffer, cons Line 770  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 741  cli_saveHistory(linebuffer_t * __restrict buffer, cons Line 786  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, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
         if (!histfile)          if (!histfile)
Line 770  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 816  cli_loadHistory(linebuffer_t * __restrict buffer, cons
                 if (!*buf || *buf == '#')                  if (!*buf || *buf == '#')
                         continue;                          continue;
                 else                  else
                        io_TrimStr((u_char*) buf);                        str_Trim(buf);
   
                if (!(h = malloc(sizeof(struct tagHistory)))) {                if (!(h = e_malloc(sizeof(struct tagHistory)))) {
                         LOGERR;                          LOGERR;
                         fclose(f);                          fclose(f);
                         return RETCODE_ERR;                          return RETCODE_ERR;
Line 780  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 826  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 789  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 835  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
 */  */
inline voidvoid
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
 */  */
inline intint
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)
                        free(buffer->line_buf);                        e_free(cli_buffer->line_buf);
   
                buffer->line_buf = 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
                         LOGERR;                          LOGERR;
         } else          } else
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
   
         return code;          return code;
 }  }
   
 /*  /*
 * 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
 */  */
inline voidvoid
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) {
                        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 = 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;
                 }                  }
         } else          } else
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
   
   
 /*  /*
 * 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);
                        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);
                        free(h);                        e_free(h);
                 }                  }
   
                if (buffer->line_prompt)                if (cli_buffer->line_prompt)
                        free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
   
                if (buffer->line_keys)                if (cli_buffer->line_keys)
                        free(buffer->line_keys);                        e_free(cli_buffer->line_keys);
                if (buffer->line_buf)                if (cli_buffer->line_buf)
                        free(buffer->line_buf);                        e_free(cli_buffer->line_buf);
   
                free(buffer);                e_free(cli_buffer);
                buffer = NULL;                cli_buffer = NULL;
         } else          } else
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
   
 /*  /*
 * cliInit() Start CLI session, allocate memory for resources and bind keys * cliInit() - Start CLI session, allocate memory for resources and bind keys
  *
  * @fin = Input device handle   * @fin = Input device handle
  * @fout = Output device handle   * @fout = Output device handle
  * @prompt = text for prompt, if NULL disable prompt   * @prompt = text for prompt, if NULL disable prompt
Line 904  cliEnd(linebuffer_t * __restrict buffer) Line 955  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;
   
         /* init buffer */          /* init buffer */
        buffer = 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 = strdup(prompt);                        cli_buffer->line_prompt = e_strdup(prompt);
                        if (!buffer->line_prompt) {                        if (!cli_buffer->line_prompt) {
                                 LOGERR;                                  LOGERR;
                                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);
                 }                  }
         }          }
        buffer->line_buf = 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)
                        free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
                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 = 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)
                        free(buffer->line_prompt);                        e_free(cli_buffer->line_prompt);
                free(buffer->line_buf);                e_free(cli_buffer->line_buf);
                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", 0, 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", 0, cli_Cmd_Help, "help [command] <cr>", "Help screen");
        cli_addCommand(buffer, "-------", 0, NULL, "-------------------------", NULL);        cli_addCommand(cli_buffer, "-------", 0, NULL, "-------------------------", NULL);
   
         /* fill key bindings */          /* fill key bindings */
        // ascii chars & ctrl+chars        /* ascii chars & ctrl+chars */
         for (i = 0; i < 256; i++) {          for (i = 0; i < 256; i++) {
                 *keys[i].key_ch = (u_char) i;                  *keys[i].key_ch = (u_char) i;
                 keys[i].key_len = 1;                  keys[i].key_len = 1;
Line 986  cliInit(int fin, int fout, const char *prompt) Line 1038  cliInit(int fin, int fout, const char *prompt)
                 if (i == '?')                  if (i == '?')
                         keys[i].key_func = bufHelp;                          keys[i].key_func = bufHelp;
         }          }
        // alt+chars        /* alt+chars */
         for (i = 256; i < 512; i++) {          for (i = 256; i < 512; i++) {
                 keys[i].key_ch[0] = 0x1b;                  keys[i].key_ch[0] = 0x1b;
                 keys[i].key_ch[1] = (u_char) i - 256;                  keys[i].key_ch[1] = (u_char) i - 256;
                 keys[i].key_len = 2;                  keys[i].key_len = 2;
         }          }
   
        // 3 bytes        /* 3 bytes */
         keys[i].key_len = sizeof K_F1 - 1;          keys[i].key_len = sizeof K_F1 - 1;
         memcpy(keys[i].key_ch, K_F1, keys[i].key_len);          memcpy(keys[i].key_ch, K_F1, keys[i].key_len);
         i++;          i++;
Line 1106  cliInit(int fin, int fout, const char *prompt) Line 1158  cliInit(int fin, int fout, const char *prompt)
         keys[i].key_func = bufBTAB;          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;          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);
Line 1121  cliInit(int fin, int fout, const char *prompt) Line 1173  cliInit(int fin, int fout, const char *prompt)
         keys[i].key_len = sizeof K_PGDN - 1;          keys[i].key_len = sizeof K_PGDN - 1;
         memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);          memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);
         i++;          i++;
        // 5 bytes        /* 5 bytes */
         keys[i].key_len = sizeof K_F5 - 1;          keys[i].key_len = sizeof K_F5 - 1;
         memcpy(keys[i].key_ch, K_F5, keys[i].key_len);          memcpy(keys[i].key_ch, K_F5, keys[i].key_len);
         i++;          i++;
Line 1147  cliInit(int fin, int fout, const char *prompt) Line 1199  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 * cliInitLine() - Init CLI input line terminal
 * @buffer = CLI buffer *
  * @cli_buffer = CLI buffer
  * return: none   * return: none
 */  */
 int  int
cliInitLine(linebuffer_t * __restrict buffer)cliInitLine(linebuffer_t * __restrict cli_buffer)
 {  {
         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);          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);
 }  }
   
 /*  /*
 * cliReadLine() Read line from opened CLI session * cliReadLine() - Read line from opened CLI session
 * @buffer = CLI buffer *
 * return: NULL if error or !=NULL readed line, must be free after use! * @cli_buffer = CLI buffer
  * 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 code, readLen;          int code, readLen;
         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, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return NULL;                  return NULL;
         }          }
   
         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 (poll(&fds, 1, -1) < 1) {
                         LOGERR;                          LOGERR;
Line 1200  cliReadLine(linebuffer_t * __restrict buffer) Line 1254  cliReadLine(linebuffer_t * __restrict buffer)
                 }                  }
   
                 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;                          LOGERR;
                         return str;                          return str;
                 }                  }
                 if (!readLen) {                  if (!readLen) {
                        if (buffer->line_buf)                        if (cli_buffer->line_buf)
                                str = strdup(buffer->line_buf);                                str = e_strdup(cli_buffer->line_buf);
                         else                          else
                                cli_SetErr(EPIPE, "Error:: unknown state ...");                                cli_SetErr(EPIPE, "Unknown state ...");
                         return str;                          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 1238  recheck: Line 1292  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 = strdup(buffer->line_buf);                str = e_strdup(cli_buffer->line_buf);
         return str;          return str;
 }  }
   
   
 /*  /*
 * 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
  * 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)
 {  {
         u_char buf[BUFSIZ];          u_char buf[BUFSIZ];
         int pid, stat, pty, r, s, alen, flg, attrlen = 0, ret = 0;          int pid, stat, pty, r, s, alen, flg, attrlen = 0, ret = 0;
Line 1265  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1320  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, "Error:: 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) < 0 ? 1 : 0;
                        cliEnd(buffer);                        cliEnd(cli_buffer);
   
                        exit(ret);                        _exit(ret);
                 default:                  default:
                        telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);                        cli_telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
                        telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);                        cli_telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
                        telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);                        cli_telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);
                        telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);                        cli_telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);
                        telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);                        cli_telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);
                        if ((ret = telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1) {                        if ((ret = cli_telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1)
                                cli_Errno = telnet_GetErrno(); 
                                strlcpy(cli_Error, telnet_GetError(), STRSIZ); 
                                 return -1;                                  return -1;
                        } else                        else
                                 flg = 0;                                  flg = 0;
   
                         while (42) {                          while (42) {
Line 1307  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1360  cliNetLoop(linebuffer_t * __restrict buffer, const cha
   
                                 if (FD_ISSET(sock, &fds)) {                                  if (FD_ISSET(sock, &fds)) {
                                         memset(buf, 0, BUFSIZ);                                          memset(buf, 0, BUFSIZ);
                                        if ((ret = telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {                                        if ((ret = cli_telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {
                                                 if (a)                                                  if (a)
                                                        free(a);                                                        e_free(a);
   
                                                 if (-2 == ret)                                                  if (-2 == ret)
                                                         continue;                                                          continue;
                                                 // EOF                                                  // EOF
                                                 if (-3 == ret)                                                  if (-3 == ret)
                                                         shutdown(sock, SHUT_RD);                                                          shutdown(sock, SHUT_RD);
                                                 else {  
                                                         cli_Errno = telnet_GetErrno();  
                                                         strlcpy(cli_Error, telnet_GetError(), STRSIZ);  
                                                 }  
                                                 break;                                                  break;
                                         }                                          }
                                         attrlen = 0;                                          attrlen = 0;
                                         if (1 == flg && alen) {                                          if (1 == flg && alen) {
                                                telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);                                                cli_telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);
                                                telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);                                                cli_telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);
                                         }                                          }
                                         if (2 == flg && alen) {                                          if (2 == flg && alen) {
                                                telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);                                                cli_telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);
                                                telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW,                                                 cli_telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
                                                                 LFLOW_OFF, NULL, 0);                                                                  LFLOW_OFF, NULL, 0);
                                                telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW,                                                 cli_telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
                                                                 LFLOW_RESTART_XON, NULL, 0);                                                                  LFLOW_RESTART_XON, NULL, 0);
                                                telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);                                                cli_telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
                                         }                                          }
                                         if (a)                                          if (a)
                                                free(a);                                                e_free(a);
   
                                         if ((ret = write(pty, buf, ret)) == -1) {                                          if ((ret = write(pty, buf, ret)) == -1) {
                                                 LOGERR;                                                  LOGERR;
Line 1351  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1400  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                                                 break;                                                  break;
                                         }                                          }
   
                                        if ((ret = telnetSend(sock, Attr, pty == s ? 0 : attrlen, buf, ret, 0)) == -1) {                                        if ((ret = cli_telnetSend(sock, Attr, pty == s ? 0 : attrlen, 
                                                cli_Errno = telnet_GetErrno();                                                                        buf, ret, 0)) == -1)
                                                strlcpy(cli_Error, telnet_GetError(), STRSIZ); 
                                                 break;                                                  break;
                                        } else                                        else
                                                 flg++;                                                  flg++;
                                 }                                  }
                         }                          }
Line 1367  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1415  cliNetLoop(linebuffer_t * __restrict buffer, const cha
 }  }
   
 /*  /*
 * cliLoop() CLI main loop * cliLoop() - CLI main loop
 * @buffer = CLI buffer *
  * @cli_buffer = CLI buffer
  * @csHistFile = History file name   * @csHistFile = History file name
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cliLoop(linebuffer_t * __restrict buffer, const char *csHistFile)cliLoop(linebuffer_t * __restrict cli_buffer, const char *csHistFile)
 {  {
         char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];          char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
         register int i;          register int i;
Line 1381  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1430  cliLoop(linebuffer_t * __restrict buffer, const char *
         struct tagCommand *cmd;          struct tagCommand *cmd;
   
         /* --- main body of CLI --- */          /* --- main body of CLI --- */
        cliInitLine(buffer);        cliInitLine(cli_buffer);
   
        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);
                 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                  // clear whitespaces
                for (s = line; isspace(*s); s++);                for (s = line; isspace((int) *s); s++);
                 if (*s) {                  if (*s) {
                        for (t = s + strlen(s) - 1; t > s && isspace(*t); t--);                        for (t = s + strlen(s) - 1; t > s && isspace((int) *t); t--);
                         *++t = 0;                          *++t = 0;
                 }                  }
   
Line 1407  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1456  cliLoop(linebuffer_t * __restrict buffer, const char *
   
                         // exec_cmd ...                          // exec_cmd ...
                         i = 0;                          i = 0;
                        SLIST_FOREACH(cmd, &buffer->line_cmds, cmd_next) {                        SLIST_FOREACH(cmd, &cli_buffer->line_cmds, cmd_next) {
                                 if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))                                  if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))
                                         break;                                          break;
                                 else                                  else
Line 1415  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1464  cliLoop(linebuffer_t * __restrict buffer, const char *
                         }                          }
   
                         if (!cmd) {                          if (!cmd) {
                                cli_Printf(buffer, "\nCommand '%s' not found!\n", items[0]);                                cli_Printf(cli_buffer, "\nCommand '%s' not found!\n", items[0]);
                                 ret = -1;                                  ret = -1;
                         } else                          } else
                                 if (cmd->cmd_func) {                                  if (cmd->cmd_func) {
                                        cli_Printf(buffer, "\n");                                        cli_Printf(cli_buffer, "\n");
                                        ret = cmd->cmd_func(buffer, i, items);                                        ret = cmd->cmd_func(cli_buffer, i, items);
                                 } else {                                  } else {
                                        clrscrEOL(buffer);                                        clrscrEOL(cli_buffer);
                                        printfCR(buffer, 1);                                        printfCR(cli_buffer, 1);
                                 }                                  }
                 }                  }
   
                cli_freeLine(buffer);                cli_freeLine(cli_buffer);
                cli_resetHistory(buffer);                cli_resetHistory(cli_buffer);
                free(line);                e_free(line);
         } while (ret < 1);          } while (ret < 1);
   
        cli_saveHistory(buffer, csHistFile, HISTORY_LINES);        cli_saveHistory(cli_buffer, csHistFile, HISTORY_LINES);
         return ret;          return ret;
 }  }
Removed from v.1.3  
changed lines
  Added in v.1.8

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