[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.2.3 and 1.4.2.1

version 1.3.2.3, 2011/05/29 22:48:23 version 1.4.2.1, 2012/05/23 15:04:11
Line 411  bufComp(int idx, void * __restrict buffer) Line 411  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 = strdup(buf->line_buf);        str = io_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);                io_TrimStr(s);
         }          }
   
         i = j = 0;          i = j = 0;
Line 488  bufComp(int idx, void * __restrict buffer) Line 488  bufComp(int idx, void * __restrict buffer)
         }          }
   
 endcomp:  endcomp:
        free(str);        io_free(str);
         return ret;          return ret;
 }  }
   
Line 600  cli_addCommand(linebuffer_t * __restrict buffer, const Line 600  cli_addCommand(linebuffer_t * __restrict buffer, const
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        cmd = malloc(sizeof(struct tagCommand));        cmd = io_malloc(sizeof(struct tagCommand));
         if (!cmd) {          if (!cmd) {
                 LOGERR;                  LOGERR;
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 640  cli_delCommand(linebuffer_t * __restrict buffer, const Line 640  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);
                        free(cmd);                        io_free(cmd);
                         break;                          break;
                 }                  }
   
Line 703  cli_addHistory(linebuffer_t * __restrict buffer, const Line 703  cli_addHistory(linebuffer_t * __restrict buffer, const
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
   
        if (!(h = malloc(sizeof(struct tagHistory)))) {        if (!(h = io_malloc(sizeof(struct tagHistory)))) {
                 LOGERR;                  LOGERR;
                 return RETCODE_ERR;                  return RETCODE_ERR;
         } else          } else
Line 711  cli_addHistory(linebuffer_t * __restrict buffer, const Line 711  cli_addHistory(linebuffer_t * __restrict buffer, const
   
         if (str) {          if (str) {
                 if (!*str) {                  if (!*str) {
                        free(h);                        io_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) {
                        free(h);                        io_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((u_char*) h->hist_line);                io_TrimStr(h->hist_line);
                 h->hist_len = strlen(h->hist_line);                  h->hist_len = strlen(h->hist_line);
         }          }
   
Line 807  cli_loadHistory(linebuffer_t * __restrict buffer, cons Line 807  cli_loadHistory(linebuffer_t * __restrict buffer, cons
                 if (!*buf || *buf == '#')                  if (!*buf || *buf == '#')
                         continue;                          continue;
                 else                  else
                        io_TrimStr((u_char*) buf);                        io_TrimStr(buf);
   
                if (!(h = malloc(sizeof(struct tagHistory)))) {                if (!(h = io_malloc(sizeof(struct tagHistory)))) {
                         LOGERR;                          LOGERR;
                         fclose(f);                          fclose(f);
                         return RETCODE_ERR;                          return RETCODE_ERR;
Line 849  cli_freeLine(linebuffer_t * __restrict buffer) Line 849  cli_freeLine(linebuffer_t * __restrict buffer)
   
         if (buffer) {          if (buffer) {
                 if (buffer->line_buf)                  if (buffer->line_buf)
                        free(buffer->line_buf);                        io_free(buffer->line_buf);
   
                buffer->line_buf = malloc(BUFSIZ);                buffer->line_buf = io_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 877  cli_setPrompt(linebuffer_t * __restrict buffer, const  Line 877  cli_setPrompt(linebuffer_t * __restrict buffer, const 
 {  {
         if (buffer) {          if (buffer) {
                 if (buffer->line_prompt) {                  if (buffer->line_prompt) {
                        free(buffer->line_prompt);                        io_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 = strdup(prompt);                        buffer->line_prompt = io_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 910  cliEnd(linebuffer_t * __restrict buffer) Line 910  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);
                        free(c);                        io_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);
                        free(h);                        io_free(h);
                 }                  }
   
                 if (buffer->line_prompt)                  if (buffer->line_prompt)
                        free(buffer->line_prompt);                        io_free(buffer->line_prompt);
   
                 if (buffer->line_keys)                  if (buffer->line_keys)
                        free(buffer->line_keys);                        io_free(buffer->line_keys);
                 if (buffer->line_buf)                  if (buffer->line_buf)
                        free(buffer->line_buf);                        io_free(buffer->line_buf);
   
                free(buffer);                io_free(buffer);
                 buffer = NULL;                  buffer = NULL;
         } else          } else
                 cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                  cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
Line 946  cliInit(int fin, int fout, const char *prompt) Line 946  cliInit(int fin, int fout, const char *prompt)
         register int i;          register int i;
   
         /* init buffer */          /* init buffer */
        buffer = malloc(sizeof(linebuffer_t));        buffer = io_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 960  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 = strdup(prompt);                        buffer->line_prompt = io_strdup(prompt);
                         if (!buffer->line_prompt) {                          if (!buffer->line_prompt) {
                                 LOGERR;                                  LOGERR;
                                free(buffer);                                io_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 = malloc(BUFSIZ);        buffer->line_buf = io_malloc(BUFSIZ);
         if (!buffer->line_buf) {          if (!buffer->line_buf) {
                 LOGERR;                  LOGERR;
                 if (buffer->line_prompt)                  if (buffer->line_prompt)
                        free(buffer->line_prompt);                        io_free(buffer->line_prompt);
                free(buffer);                io_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 = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));        keys = io_calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
         if (!keys) {          if (!keys) {
                 LOGERR;                  LOGERR;
                 if (buffer->line_prompt)                  if (buffer->line_prompt)
                        free(buffer->line_prompt);                        io_free(buffer->line_prompt);
                free(buffer->line_buf);                io_free(buffer->line_buf);
                free(buffer);                io_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 1210  cliInitLine(linebuffer_t * __restrict buffer) Line 1210  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 free after use! * return: NULL if error or !=NULL readed line, must be io_free after use!
 */  */
 char *  char *
 cliReadLine(linebuffer_t * __restrict buffer)  cliReadLine(linebuffer_t * __restrict buffer)
Line 1244  cliReadLine(linebuffer_t * __restrict buffer) Line 1244  cliReadLine(linebuffer_t * __restrict buffer)
                 }                  }
                 if (!readLen) {                  if (!readLen) {
                         if (buffer->line_buf)                          if (buffer->line_buf)
                                str = strdup(buffer->line_buf);                                str = io_strdup(buffer->line_buf);
                         else                          else
                                 cli_SetErr(EPIPE, "Error:: unknown state ...");                                  cli_SetErr(EPIPE, "Error:: unknown state ...");
                         return str;                          return str;
Line 1276  recheck: Line 1276  recheck:
         }          }
   
         if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)          if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)
                str = strdup(buffer->line_buf);                str = io_strdup(buffer->line_buf);
         return str;          return str;
 }  }
   
Line 1344  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1344  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)
                                                        free(a);                                                        io_free(a);
   
                                                 if (-2 == ret)                                                  if (-2 == ret)
                                                         continue;                                                          continue;
Line 1367  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1367  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)
                                                free(a);                                                io_free(a);
   
                                         if ((ret = write(pty, buf, ret)) == -1) {                                          if ((ret = write(pty, buf, ret)) == -1) {
                                                 LOGERR;                                                  LOGERR;
Line 1459  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1459  cliLoop(linebuffer_t * __restrict buffer, const char *
   
                 cli_freeLine(buffer);                  cli_freeLine(buffer);
                 cli_resetHistory(buffer);                  cli_resetHistory(buffer);
                free(line);                io_free(line);
         } while (ret < 1);          } while (ret < 1);
   
         cli_saveHistory(buffer, csHistFile, HISTORY_LINES);          cli_saveHistory(buffer, csHistFile, HISTORY_LINES);
Removed from v.1.3.2.3  
changed lines
  Added in v.1.4.2.1

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