[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.5 and 1.5.4.2

version 1.5, 2012/07/22 22:37:08 version 1.5.4.2, 2013/01/17 16:20:19
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, 2012Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
         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 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
   
 #pragma GCC visibility push(hidden)  #pragma GCC visibility push(hidden)
   
 // ------------------------------------------------  
   
 int cli_Errno;  int cli_Errno;
 char cli_Error[STRSIZ];  char cli_Error[STRSIZ];
   
Line 63  cli_GetErrno() Line 61  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 *  inline const char *
 cli_GetError()  cli_GetError()
 {  {
Line 77  cli_SetErr(int eno, char *estr, ...) Line 75  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 411  bufComp(int idx, void * __restrict buffer) Line 409  bufComp(int idx, void * __restrict buffer)
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        str = io_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(s);                str_Trim(s);
         }          }
   
         i = j = 0;          i = j = 0;
Line 488  bufComp(int idx, void * __restrict buffer) Line 486  bufComp(int idx, void * __restrict buffer)
         }          }
   
 endcomp:  endcomp:
        io_free(str);        e_free(str);
         return ret;          return ret;
 }  }
   
Line 507  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   * @buffer = CLI buffer
  * @fmt = printf format string   * @fmt = printf format string
  * @... = arguments defined in fmt   * @... = arguments defined in fmt
Line 533  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   * @buffer = CLI buffer
  * return: none   * return: none
 */  */
Line 548  cli_PrintHelp(linebuffer_t * __restrict buffer) Line 547  cli_PrintHelp(linebuffer_t * __restrict buffer)
                 bufHelp(0, buffer);                  bufHelp(0, buffer);
                 clrscrEOL(buffer);                  clrscrEOL(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   * @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
Line 564  cli_BindKey(bindkey_t * __restrict key, linebuffer_t * Line 564  cli_BindKey(bindkey_t * __restrict key, linebuffer_t *
         register int i;          register int i;
   
         if (!key || !buffer) {          if (!key || !buffer) {
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
Line 580  cli_BindKey(bindkey_t * __restrict key, linebuffer_t * Line 580  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   * @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 ...
Line 596  cli_addCommand(linebuffer_t * __restrict buffer, const Line 597  cli_addCommand(linebuffer_t * __restrict buffer, const
         struct tagCommand *cmd;          struct tagCommand *cmd;
   
         if (!buffer || !csCmd) {          if (!buffer || !csCmd) {
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        cmd = io_malloc(sizeof(struct tagCommand));        cmd = e_malloc(sizeof(struct tagCommand));
         if (!cmd) {          if (!cmd) {
                 LOGERR;                  LOGERR;
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 619  cli_addCommand(linebuffer_t * __restrict buffer, const Line 620  cli_addCommand(linebuffer_t * __restrict buffer, const
 }  }
   
 /*  /*
 * cli_delCommand() Delete command from CLI session * cli_delCommand() - Delete command from CLI session
  *
  * @buffer = CLI buffer   * @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 ...
Line 632  cli_delCommand(linebuffer_t * __restrict buffer, const Line 634  cli_delCommand(linebuffer_t * __restrict buffer, const
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
   
         if (!buffer || !csCmd) {          if (!buffer || !csCmd) {
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
Line 640  cli_delCommand(linebuffer_t * __restrict buffer, const Line 642  cli_delCommand(linebuffer_t * __restrict buffer, const
                 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(&buffer->line_cmds, cmd, tagCommand, cmd_next);
                        io_free(cmd);                        e_free(cmd);
                         break;                          break;
                 }                  }
   
Line 648  cli_delCommand(linebuffer_t * __restrict buffer, const Line 650  cli_delCommand(linebuffer_t * __restrict buffer, const
 }  }
   
 /*  /*
 * cli_updCommand() Update command in CLI session * cli_updCommand() - Update command in CLI session
  *
  * @buffer = CLI buffer   * @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 ...
Line 665  cli_updCommand(linebuffer_t * __restrict buffer, const Line 668  cli_updCommand(linebuffer_t * __restrict buffer, const
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
   
         if (!buffer || !csCmd) {          if (!buffer || !csCmd) {
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
Line 688  cli_updCommand(linebuffer_t * __restrict buffer, const Line 691  cli_updCommand(linebuffer_t * __restrict buffer, const
   
   
 /*  /*
 * cli_addHistory() Add line to history * cli_addHistory() - Add line to history
  *
  * @buffer = CLI buffer   * @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
Line 699  cli_addHistory(linebuffer_t * __restrict buffer, const Line 703  cli_addHistory(linebuffer_t * __restrict buffer, const
         struct tagHistory *h;          struct tagHistory *h;
   
         if (!buffer) {          if (!buffer) {
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        if (!(h = io_malloc(sizeof(struct tagHistory)))) {        if (!(h = e_malloc(sizeof(struct tagHistory)))) {
                 LOGERR;                  LOGERR;
                 return RETCODE_ERR;                  return RETCODE_ERR;
         } else          } else
Line 711  cli_addHistory(linebuffer_t * __restrict buffer, const Line 715  cli_addHistory(linebuffer_t * __restrict buffer, const
   
         if (str) {          if (str) {
                 if (!*str) {                  if (!*str) {
                        io_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 (!*buffer->line_buf || buffer->line_len < 2) {
                        io_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, buffer->line_buf, (h->hist_len = buffer->line_len));
                io_TrimStr(h->hist_line);                str_Trim(h->hist_line);
                 h->hist_len = strlen(h->hist_line);                  h->hist_len = strlen(h->hist_line);
         }          }
   
Line 732  cli_addHistory(linebuffer_t * __restrict buffer, const Line 736  cli_addHistory(linebuffer_t * __restrict buffer, const
 }  }
   
 /*  /*
 * cli_saveHistory() Save history to file * cli_saveHistory() - Save history to file
  *
  * @buffer = CLI buffer   * @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
Line 747  cli_saveHistory(linebuffer_t * __restrict buffer, cons Line 752  cli_saveHistory(linebuffer_t * __restrict buffer, cons
         struct tagHistory *h;          struct tagHistory *h;
   
         if (!buffer) {          if (!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 778  cli_saveHistory(linebuffer_t * __restrict buffer, cons Line 783  cli_saveHistory(linebuffer_t * __restrict buffer, cons
 }  }
   
 /*  /*
 * cli_loadHistory() Load history from file * cli_loadHistory() - Load history from file
  *
  * @buffer = CLI buffer   * @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
Line 791  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 797  cli_loadHistory(linebuffer_t * __restrict buffer, cons
         struct tagHistory *h;          struct tagHistory *h;
   
         if (!buffer) {          if (!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 807  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 813  cli_loadHistory(linebuffer_t * __restrict buffer, cons
                 if (!*buf || *buf == '#')                  if (!*buf || *buf == '#')
                         continue;                          continue;
                 else                  else
                        io_TrimStr(buf);                        str_Trim(buf);
   
                if (!(h = io_malloc(sizeof(struct tagHistory)))) {                if (!(h = e_malloc(sizeof(struct tagHistory)))) {
                         LOGERR;                          LOGERR;
                         fclose(f);                          fclose(f);
                         return RETCODE_ERR;                          return RETCODE_ERR;
Line 826  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 832  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   * @buffer = CLI buffer
  * return: none   * return: none
 */  */
Line 838  cli_resetHistory(linebuffer_t * __restrict buffer) Line 845  cli_resetHistory(linebuffer_t * __restrict buffer)
   
   
 /*  /*
 * cli_freeLine() Clear entire line * cli_freeLine() - Clear entire line
  *
  * @buffer = CLI buffer   * @buffer = CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
Line 849  cli_freeLine(linebuffer_t * __restrict buffer) Line 857  cli_freeLine(linebuffer_t * __restrict buffer)
   
         if (buffer) {          if (buffer) {
                 if (buffer->line_buf)                  if (buffer->line_buf)
                        io_free(buffer->line_buf);                        e_free(buffer->line_buf);
   
                buffer->line_buf = io_malloc(BUFSIZ);                buffer->line_buf = e_malloc(BUFSIZ);
                 if (buffer->line_buf) {                  if (buffer->line_buf) {
                         memset(buffer->line_buf, 0, BUFSIZ);                          memset(buffer->line_buf, 0, BUFSIZ);
                         buffer->line_eol = buffer->line_bol;                          buffer->line_eol = buffer->line_bol;
Line 861  cli_freeLine(linebuffer_t * __restrict buffer) Line 869  cli_freeLine(linebuffer_t * __restrict buffer)
                 } 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   * @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
Line 877  cli_setPrompt(linebuffer_t * __restrict buffer, const  Line 886  cli_setPrompt(linebuffer_t * __restrict buffer, const 
 {  {
         if (buffer) {          if (buffer) {
                 if (buffer->line_prompt) {                  if (buffer->line_prompt) {
                        io_free(buffer->line_prompt);                        e_free(buffer->line_prompt);
                         buffer->line_prompt = NULL;                          buffer->line_prompt = NULL;
                         buffer->line_bol = 0;                          buffer->line_bol = 0;
                 }                  }
   
                 if (prompt) {                  if (prompt) {
                        buffer->line_prompt = io_strdup(prompt);                        buffer->line_prompt = e_strdup(prompt);
                         if (buffer->line_prompt) {                          if (buffer->line_prompt) {
                                 buffer->line_bol = strlen(buffer->line_prompt);                                  buffer->line_bol = strlen(buffer->line_prompt);
                                 buffer->line_eol = buffer->line_bol;                                  buffer->line_eol = buffer->line_bol;
Line 892  cli_setPrompt(linebuffer_t * __restrict buffer, const  Line 901  cli_setPrompt(linebuffer_t * __restrict buffer, const 
                                 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   * @buffer = CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
Line 910  cliEnd(linebuffer_t * __restrict buffer) Line 920  cliEnd(linebuffer_t * __restrict buffer)
         if (buffer) {          if (buffer) {
                 while ((c = SLIST_FIRST(&buffer->line_cmds))) {                  while ((c = SLIST_FIRST(&buffer->line_cmds))) {
                         SLIST_REMOVE_HEAD(&buffer->line_cmds, cmd_next);                          SLIST_REMOVE_HEAD(&buffer->line_cmds, cmd_next);
                        io_free(c);                        e_free(c);
                 }                  }
                 while ((h = TAILQ_FIRST(&buffer->line_history))) {                  while ((h = TAILQ_FIRST(&buffer->line_history))) {
                         TAILQ_REMOVE(&buffer->line_history, h, hist_next);                          TAILQ_REMOVE(&buffer->line_history, h, hist_next);
                        io_free(h);                        e_free(h);
                 }                  }
   
                 if (buffer->line_prompt)                  if (buffer->line_prompt)
                        io_free(buffer->line_prompt);                        e_free(buffer->line_prompt);
   
                 if (buffer->line_keys)                  if (buffer->line_keys)
                        io_free(buffer->line_keys);                        e_free(buffer->line_keys);
                 if (buffer->line_buf)                  if (buffer->line_buf)
                        io_free(buffer->line_buf);                        e_free(buffer->line_buf);
   
                io_free(buffer);                e_free(buffer);
                 buffer = NULL;                  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 946  cliInit(int fin, int fout, const char *prompt) Line 957  cliInit(int fin, int fout, const char *prompt)
         register int i;          register int i;
   
         /* init buffer */          /* init buffer */
        buffer = io_malloc(sizeof(linebuffer_t));        buffer = e_malloc(sizeof(linebuffer_t));
         if (!buffer) {          if (!buffer) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 960  cliInit(int fin, int fout, const char *prompt) Line 971  cliInit(int fin, int fout, const char *prompt)
                 SLIST_INIT(&buffer->line_cmds);                  SLIST_INIT(&buffer->line_cmds);
   
                 if (prompt) {                  if (prompt) {
                        buffer->line_prompt = io_strdup(prompt);                        buffer->line_prompt = e_strdup(prompt);
                         if (!buffer->line_prompt) {                          if (!buffer->line_prompt) {
                                 LOGERR;                                  LOGERR;
                                io_free(buffer);                                e_free(buffer);
                                 return NULL;                                  return NULL;
                         } else                          } else
                                 buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);                                  buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);
                 }                  }
         }          }
        buffer->line_buf = io_malloc(BUFSIZ);        buffer->line_buf = e_malloc(BUFSIZ);
         if (!buffer->line_buf) {          if (!buffer->line_buf) {
                 LOGERR;                  LOGERR;
                 if (buffer->line_prompt)                  if (buffer->line_prompt)
                        io_free(buffer->line_prompt);                        e_free(buffer->line_prompt);
                io_free(buffer);                e_free(buffer);
                 return NULL;                  return NULL;
         } else {          } else {
                 memset(buffer->line_buf, 0, BUFSIZ);                  memset(buffer->line_buf, 0, BUFSIZ);
                 buffer->line_len = 1 + buffer->line_eol;                  buffer->line_len = 1 + buffer->line_eol;
         }          }
        keys = io_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 (buffer->line_prompt)
                        io_free(buffer->line_prompt);                        e_free(buffer->line_prompt);
                io_free(buffer->line_buf);                e_free(buffer->line_buf);
                io_free(buffer);                e_free(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));
Line 997  cliInit(int fin, int fout, const char *prompt) Line 1008  cliInit(int fin, int fout, const char *prompt)
         cli_addCommand(buffer, "-------", 0, NULL, "-------------------------", NULL);          cli_addCommand(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 1023  cliInit(int fin, int fout, const char *prompt) Line 1034  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 1143  cliInit(int fin, int fout, const char *prompt) Line 1154  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 1158  cliInit(int fin, int fout, const char *prompt) Line 1169  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 1189  cliInit(int fin, int fout, const char *prompt) Line 1200  cliInit(int fin, int fout, const char *prompt)
 }  }
   
 /*  /*
 * cliInitLine() Init CLI input line terminal * cliInitLine() - Init CLI input line terminal
  *
  * @buffer = CLI buffer   * @buffer = CLI buffer
  * return: none   * return: none
 */  */
Line 1208  cliInitLine(linebuffer_t * __restrict buffer) Line 1220  cliInitLine(linebuffer_t * __restrict buffer)
 }  }
   
 /*  /*
 * cliReadLine() Read line from opened CLI session * cliReadLine() - Read line from opened CLI session
  *
  * @buffer = CLI buffer   * @buffer = CLI buffer
 * return: NULL if error or !=NULL readed line, must be io_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 buffer)
Line 1221  cliReadLine(linebuffer_t * __restrict buffer) Line 1234  cliReadLine(linebuffer_t * __restrict buffer)
         char buf[BUFSIZ], *str = NULL;          char buf[BUFSIZ], *str = NULL;
   
         if (!buffer) {          if (!buffer) {
                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                cli_SetErr(EINVAL, "Invalid input parameters ...");
                 return NULL;                  return NULL;
         }          }
   
Line 1244  cliReadLine(linebuffer_t * __restrict buffer) Line 1257  cliReadLine(linebuffer_t * __restrict buffer)
                 }                  }
                 if (!readLen) {                  if (!readLen) {
                         if (buffer->line_buf)                          if (buffer->line_buf)
                                str = io_strdup(buffer->line_buf);                                str = e_strdup(buffer->line_buf);
                         else                          else
                                cli_SetErr(EPIPE, "Error:: unknown state ...");                                cli_SetErr(EPIPE, "Unknown state ...");
                         return str;                          return str;
                 }                  }
   
Line 1276  recheck: Line 1289  recheck:
         }          }
   
         if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)          if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)
                str = io_strdup(buffer->line_buf);                str = e_strdup(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   * @buffer = CLI buffer
  * @csHistFile = History file name   * @csHistFile = History file name
  * @sock = client socket   * @sock = client socket
Line 1303  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1317  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                         return -1;                          return -1;
                 case 0:                  case 0:
                         if (!buffer) {                          if (!buffer) {
                                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                                cli_SetErr(EINVAL, "Invalid input parameters ...");
                                 return -1;                                  return -1;
                         } else                          } else
                                 close(sock);                                  close(sock);
Line 1344  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1358  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                                         memset(buf, 0, BUFSIZ);                                          memset(buf, 0, BUFSIZ);
                                         if ((ret = cli_telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {                                          if ((ret = cli_telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {
                                                 if (a)                                                  if (a)
                                                        io_free(a);                                                        e_free(a);
   
                                                 if (-2 == ret)                                                  if (-2 == ret)
                                                         continue;                                                          continue;
Line 1367  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1381  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                                                 cli_telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);                                                  cli_telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
                                         }                                          }
                                         if (a)                                          if (a)
                                                io_free(a);                                                e_free(a);
   
                                         if ((ret = write(pty, buf, ret)) == -1) {                                          if ((ret = write(pty, buf, ret)) == -1) {
                                                 LOGERR;                                                  LOGERR;
Line 1397  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1411  cliNetLoop(linebuffer_t * __restrict buffer, const cha
 }  }
   
 /*  /*
 * cliLoop() CLI main loop * cliLoop() - CLI main loop
  *
  * @buffer = CLI buffer   * @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
Line 1459  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1474  cliLoop(linebuffer_t * __restrict buffer, const char *
   
                 cli_freeLine(buffer);                  cli_freeLine(buffer);
                 cli_resetHistory(buffer);                  cli_resetHistory(buffer);
                io_free(line);                e_free(line);
         } while (ret < 1);          } while (ret < 1);
   
         cli_saveHistory(buffer, csHistFile, HISTORY_LINES);          cli_saveHistory(buffer, csHistFile, HISTORY_LINES);
Removed from v.1.5  
changed lines
  Added in v.1.5.4.2

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