[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.2.2.2 and 1.2.2.5

version 1.2.2.2, 2010/06/04 12:46:27 version 1.2.2.5, 2010/06/07 09:04:46
Line 96  printfCR(linebuffer_t * __restrict buf, int prompt) Line 96  printfCR(linebuffer_t * __restrict buf, int prompt)
 }  }
   
 static inline void  static inline void
   printfNL(linebuffer_t * __restrict buf, int prompt)
   {
           if (buf) {
                   write(buf->line_out, K_ENTER, 1);
   
                   if (prompt)
                           if (prompt && buf->line_prompt)
                                   write(buf->line_out, buf->line_prompt, buf->line_bol);
           }
   }
   
   static inline void
 printfCLI(linebuffer_t * __restrict buf, const unsigned char *text, int textlen, int prompt)  printfCLI(linebuffer_t * __restrict buf, const unsigned char *text, int textlen, int prompt)
 {  {
         if (buf && text && textlen) {          if (buf && text && textlen) {
Line 108  printfCLI(linebuffer_t * __restrict buf, const unsigne Line 120  printfCLI(linebuffer_t * __restrict buf, const unsigne
   
 // ------------------------------------------------------------  // ------------------------------------------------------------
   
   static int
   bufCHAR(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
           int pos;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           pos = buf->line_eol - buf->line_bol;
   
           if (buf->line_mode == LINEMODE_INS)
                   memmove(buf->line_buf + pos + buf->line_keys[idx].key_len, buf->line_buf + pos, 
                                   buf->line_len - buf->line_eol);
           if (buf->line_mode == LINEMODE_INS || buf->line_eol == buf->line_len - 1)
                   buf->line_len += buf->line_keys[idx].key_len;
           buf->line_eol += buf->line_keys[idx].key_len;
   
           memcpy(buf->line_buf + pos, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
           buf->line_buf[buf->line_len - 1] = 0;
   
           write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
   
           if (buf->line_mode == LINEMODE_INS) {
                   printfCLI(buf, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len, 
                                   buf->line_len - buf->line_eol, 0);
                   printfEOL(buf, -1, 1);
           }
           return RETCODE_OK;
   }
   
   static int
   bufEOL(int idx, void * __restrict buffer)
   {
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           printfCR(buffer, 1);
           return RETCODE_EOL;
   }
   
   static int
   bufEOF(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
           return RETCODE_EOF;
   }
   
   static int
   bufUP(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
           int pos;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (!buf->line_h)
                   buf->line_h = TAILQ_FIRST(&buf->line_history);
           else
                   buf->line_h = TAILQ_NEXT(buf->line_h, hist_next);
           if (!buf->line_h)
                   return RETCODE_OK;
   
           clrscrEOL(buf);
           cli_freeLine(buf);
   
           pos = buf->line_eol - buf->line_bol;
   
           buf->line_len += buf->line_h->hist_len;
           buf->line_eol += buf->line_h->hist_len;
   
           memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len);
           buf->line_buf[buf->line_len - 1] = 0;
   
           printfEOL(buf, -1, 1);
           return RETCODE_OK;
   }
   
   static int
   bufDOWN(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
           int pos;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (!buf->line_h)
                   buf->line_h = TAILQ_LAST(&buf->line_history, tqHistoryHead);
           else
                   buf->line_h = TAILQ_PREV(buf->line_h, tqHistoryHead, hist_next);
           if (!buf->line_h)
                   return RETCODE_OK;
   
           clrscrEOL(buf);
           cli_freeLine(buf);
   
           pos = buf->line_eol - buf->line_bol;
   
           buf->line_len += buf->line_h->hist_len;
           buf->line_eol += buf->line_h->hist_len;
   
           memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len);
           buf->line_buf[buf->line_len - 1] = 0;
   
           printfEOL(buf, -1, 1);
           return RETCODE_OK;
   }
   
   static int
   bufCLR(int idx, void * __restrict buffer)
   {
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           clrscrEOL(buffer);
           cli_freeLine(buffer);
   
           printfCR(buffer, 1);
           return RETCODE_OK;
   }
   
   static int
   bufBS(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_bol < buf->line_eol) {
                   clrscrEOL(buf);
   
                   buf->line_eol--;
                   buf->line_len--;
                   memmove(buf->line_buf + buf->line_eol - buf->line_bol, 
                                   buf->line_buf + buf->line_eol - buf->line_bol + 1, 
                                   buf->line_len - buf->line_eol);
                   buf->line_buf[buf->line_len - 1] = 0;
   
                   printfEOL(buf, buf->line_len - 1, 1);
                   printfEOL(buf, -1, 1);
           }
   
           return RETCODE_OK;
   }
   
   static int
   bufBTAB(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_bol < buf->line_eol) {
                   clrscrEOL(buf);
   
                   buf->line_len = buf->line_eol - buf->line_bol + 1;
                   buf->line_buf[buf->line_len - 1] = 0;
   
                   printfEOL(buf, -1, 1);
           }
   
           return RETCODE_OK;
   }
   
   static int
   bufMODE(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           buf->line_mode = !buf->line_mode ? LINEMODE_OVER : LINEMODE_INS;
           return RETCODE_OK;
   }
   
   static int
   bufBEGIN(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           buf->line_eol = buf->line_bol;
   
           printfCR(buf, 1);
           return RETCODE_OK;
   }
   
   static int
   bufEND(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           buf->line_eol = buf->line_len - 1;
   
           printfEOL(buf, -1, 1);
           return RETCODE_OK;
   }
   
   static int
   bufLEFT(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_bol < buf->line_eol)
                   printfEOL(buf, --buf->line_eol - buf->line_bol, 1);
   
           return RETCODE_OK;
   }
   
   static int
   bufRIGHT(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_eol < buf->line_len - 1)
                   printfEOL(buf, ++buf->line_eol - buf->line_bol, 1);
   
           return RETCODE_OK;
   }
   
   static int
   bufDEL(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           clrscrEOL(buf);
   
           buf->line_len--;
           memmove(buf->line_buf + buf->line_eol - buf->line_bol, 
                           buf->line_buf + buf->line_eol - buf->line_bol + 1, 
                           buf->line_len - buf->line_eol);
           buf->line_buf[buf->line_len - 1] = 0;
   
           printfEOL(buf, buf->line_len - 1, 1);
           printfEOL(buf, -1, 1);
   
           return RETCODE_OK;
   }
   
   // ---------------------------------------------------------------
   
 /*  /*
 * cliNetInit() Initialize Readline if CLI bind to socket * cli_Printf() Send message to CLI session
 * @csProg = program name * @buffer = CLI buffer
 * @pty = Master pty * @fmt = printf format string
 * @term = stdin termios * @... = arguments defined in fmt
  * return: none   * return: none
 */  */
   inline void
   cli_Printf(linebuffer_t * __restrict buffer, char *fmt, ...)
   {
           va_list lst;
           FILE *f;
   
           if (fmt) {
                   f = fdopen(buffer->line_out, "a");
                   if (!f) {
                           LOGERR;
                           return;
                   }
   
                   va_start(lst, fmt);
                   vfprintf(f, fmt, lst);
                   va_end(lst);
           } else
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
   }
   
 /*  /*
void cliNetInit(const char *csProg, int pty, struct termios *term) * cli_BindKey() Bind function to key
  * @key = key structure
  * @buffer = CLI buffer
  * return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position
 */
 int
 cli_BindKey(bindkey_t * __restrict key, linebuffer_t * __restrict buffer)
 {  {
           register int i;
   
           if (!key || !buffer) {
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                   return RETCODE_ERR;
           }
   
           for (i = 0; i < MAX_BINDKEY; i++)
                   if (key->key_len == buffer->line_keys[i].key_len && 
                                   !memcmp(key->key_ch, buffer->line_keys[i].key_ch, key->key_len)) {
                           buffer->line_keys[i].key_func = key->key_func;
                           return i;
                   }
   
           return RETCODE_OK;
   }
   
   
   /*
    * cli_addHistory() Add line to history
    * @buffer = CLI buffer
    * @str = Add custom text or if NULL use readed line from CLI buffer
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   int
   cli_addHistory(linebuffer_t * __restrict buffer, const char * __restrict str)
   {
           struct tagHistory *h;
   
           if (!buffer) {
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                   return RETCODE_ERR;
           }
   
           if (!(h = malloc(sizeof(struct tagHistory)))) {
                   LOGERR;
                   return RETCODE_ERR;
           } else
                   memset(h, 0, sizeof(struct tagHistory));
   
           if (str) {
                   if (!*str) {
                           free(h);
                           return RETCODE_OK;
                   }
   
                   h->hist_len = strlcpy(h->hist_line, str, BUFSIZ);
           } else {
                   if (!*buffer->line_buf || buffer->line_len < 2) {
                           free(h);
                           return RETCODE_OK;
                   }
   
                   memcpy(h->hist_line, buffer->line_buf, (h->hist_len = buffer->line_len));
                   io_TrimStr((u_char*) h->hist_line);
                   h->hist_len = strlen(h->hist_line);
           }
   
           TAILQ_INSERT_HEAD(&buffer->line_history, h, hist_next);
           return h->hist_len;
   }
   
   /*
    * cli_saveHistory() Save history to file
    * @buffer = CLI buffer
    * @histfile = History filename, if NULL will be use default name
    * @lines = Maximum history lines to save
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   int
   cli_saveHistory(linebuffer_t * __restrict buffer, const char *histfile, int lines)
   {
           FILE *f;
           mode_t mode;
           char szFName[MAXPATHLEN];
           struct tagHistory *h;
   
           if (!buffer) {
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                   return RETCODE_ERR;
           }
           if (!histfile)
                   strlcpy(szFName, HISTORY_FILE, MAXPATHLEN);
           else
                   strlcpy(szFName, histfile, MAXPATHLEN);
   
           mode = umask(0177);
           f = fopen(szFName, "w");
           if (!f) {
                   LOGERR;
                   return RETCODE_ERR;
           }
   
           TAILQ_FOREACH(h, &buffer->line_history, hist_next) {
                   fprintf(f, "%s\n", h->hist_line);
   
                   if (lines)
                           lines--;
                   else
                           break;
           }
   
           fclose(f);
           umask(mode);
   
           return RETCODE_OK;
   }
   
   /*
    * cli_loadHistory() Load history from file
    * @buffer = CLI buffer
    * @histfile = History filename, if NULL will be use default name
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   int
   cli_loadHistory(linebuffer_t * __restrict buffer, const char *histfile)
   {
           FILE *f;
           char szFName[MAXPATHLEN], buf[BUFSIZ];
           struct tagHistory *h;
   
           if (!buffer) {
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                   return RETCODE_ERR;
           }
           if (!histfile)
                   strlcpy(szFName, HISTORY_FILE, MAXPATHLEN);
           else
                   strlcpy(szFName, histfile, MAXPATHLEN);
   
           f = fopen(szFName, "r");
           if (!f)
                   return RETCODE_OK;
   
           while (fgets(buf, BUFSIZ, f)) {
                   if (!*buf || *buf == '#')
                           continue;
                   else
                           io_TrimStr((u_char*) buf);
   
                   if (!(h = malloc(sizeof(struct tagHistory)))) {
                           LOGERR;
                           fclose(f);
                           return RETCODE_ERR;
                   } else
                           memset(h, 0, sizeof(struct tagHistory));
   
                   h->hist_len = strlcpy(h->hist_line, buf, BUFSIZ);
                   TAILQ_INSERT_TAIL(&buffer->line_history, h, hist_next);
           }
   
           fclose(f);
   
           return RETCODE_OK;
   }
   
   /*
    * cli_resetHistory() Reset history search in CLI session
    * @buffer = CLI buffer
    * return: none
   */
   inline void
   cli_resetHistory(linebuffer_t * __restrict buffer)
   {
           buffer->line_h = NULL;
   }
   
   
   /*
    * cli_freeLine() Clear entire line
    * @buffer = CLI buffer
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   inline int
   cli_freeLine(linebuffer_t * __restrict buffer)
   {
           int code = RETCODE_ERR;
   
           if (buffer) {
                   if (buffer->line_buf)
                           free(buffer->line_buf);
   
                   buffer->line_buf = malloc(BUFSIZ);
                   if (buffer->line_buf) {
                           memset(buffer->line_buf, 0, BUFSIZ);
                           buffer->line_eol = buffer->line_bol;
                           buffer->line_len = 1 + buffer->line_eol;
   
                           code = RETCODE_OK;
                   } else
                           LOGERR;
           } else
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
   
           return code;
   }
   
   /*
    * cli_setPrompt() Set new prompt for CLI session
    * @buffer = CLI buffer
    * @prompt = new text for prompt or if NULL disable prompt
    * return: none
   */
   inline void
   cli_setPrompt(linebuffer_t * __restrict buffer, const char *prompt)
   {
           if (buffer) {
                   if (buffer->line_prompt) {
                           free(buffer->line_prompt);
                           buffer->line_prompt = NULL;
                           buffer->line_bol = 0;
                   }
   
                   if (prompt) {
                           buffer->line_prompt = strdup(prompt);
                           if (buffer->line_prompt) {
                                   buffer->line_bol = strlen(buffer->line_prompt);
                                   buffer->line_eol = buffer->line_bol;
                                   buffer->line_len = 1 + buffer->line_eol;
                           } else
                                   LOGERR;
                   }
           } else
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
   }
   
   
   /*
    * cliEnd() Clear data, Free resources and close CLI session
    * @buffer = CLI buffer
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   void
   cliEnd(linebuffer_t * __restrict buffer)
   {
           struct tagHistory *h;
           struct tagCommand *c;
   
           if (buffer) {
                   while ((c = SLIST_FIRST(&buffer->line_cmds))) {
                           SLIST_REMOVE_HEAD(&buffer->line_cmds, cmd_next);
                           free(c);
                   }
                   while ((h = TAILQ_FIRST(&buffer->line_history))) {
                           TAILQ_REMOVE(&buffer->line_history, h, hist_next);
                           free(h);
                   }
   
                   if (buffer->line_prompt)
                           free(buffer->line_prompt);
   
                   if (buffer->line_keys)
                           free(buffer->line_keys);
                   if (buffer->line_buf)
                           free(buffer->line_buf);
   
                   free(buffer);
                   buffer = NULL;
           } else
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
   }
   
   /*
    * cliInit() Start CLI session, allocate memory for resources and bind keys
    * @fin = Input device handle
    * @fout = Output device handle
    * @prompt = text for prompt, if NULL disable prompt
    * return: NULL if error or !=NULL CLI buffer
   */
   linebuffer_t *
   cliInit(int fin, int fout, const char *prompt)
   {
           linebuffer_t *buffer;
           bindkey_t *keys;
           register int i;
         struct termios t;          struct termios t;
         int on = 1;  
   
         memset(&t, 0, sizeof t);          memset(&t, 0, sizeof t);
        if (term)        /* init buffer */
                t = *term;        buffer = malloc(sizeof (linebuffer_t));
        else {        if (!buffer) {
                t.c_lflag = TTYDEF_LFLAG;                LOGERR;
                t.c_iflag = TTYDEF_IFLAG;                return NULL;
                t.c_oflag = TTYDEF_OFLAG;        } else {
                t.c_cflag = TTYDEF_CFLAG;                memset(buffer, 0, sizeof(linebuffer_t));
                cfsetspeed(&t, B9600);
                 buffer->line_in = fin;
                 buffer->line_out = fout;
 
                 TAILQ_INIT(&buffer->line_history);
                 SLIST_INIT(&buffer->line_cmds);
 
                 if (prompt) {
                         buffer->line_prompt = strdup(prompt);
                         if (!buffer->line_prompt) {
                                 LOGERR;
                                 free(buffer);
                                 return NULL;
                         } else
                                 buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);
                 }
         }          }
           buffer->line_buf = malloc(BUFSIZ);
           if (!buffer->line_buf) {
                   LOGERR;
                   if (buffer->line_prompt)
                           free(buffer->line_prompt);
                   free(buffer);
                   return NULL;
           } else {
                   memset(buffer->line_buf, 0, BUFSIZ);
                   buffer->line_len = 1 + buffer->line_eol;
           }
           keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
           if (!keys) {
                   LOGERR;
                   if (buffer->line_prompt)
                           free(buffer->line_prompt);
                   free(buffer->line_buf);
                   free(buffer);
                   return NULL;
           } else
                   memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));
   
           /* fill key bindings */
           // ascii chars & ctrl+chars
           for (i = 0; i < 256; i++) {
                   *keys[i].key_ch = (u_char) i;
                   keys[i].key_len = 1;
   
                   if (!i || i == *K_CTRL_D)
                           keys[i].key_func = bufEOF;
                   if (i == *K_CTRL_M || i == *K_CTRL_J)
                           keys[i].key_func = bufEOL;
                   if (i == *K_CTRL_H || i == *K_BACKSPACE)
                           keys[i].key_func = bufBS;
                   if (i == *K_CTRL_C)
                           keys[i].key_func = bufCLR;
                   if (i == *K_CTRL_A)
                           keys[i].key_func = bufBEGIN;
                   if (i == *K_CTRL_E)
                           keys[i].key_func = bufEND;
                   if (i >= *K_SPACE && i < *K_BACKSPACE)
                           keys[i].key_func = bufCHAR;
                   if (i > *K_BACKSPACE && i < 0xff)
                           keys[i].key_func = bufCHAR;
           }
           // alt+chars
           for (i = 256; i < 512; i++) {
                   keys[i].key_ch[0] = 0x1b;
                   keys[i].key_ch[1] = (u_char) i - 256;
                   keys[i].key_len = 2;
           }
   
           // 3 bytes
           keys[i].key_len = sizeof K_F1 - 1;
           memcpy(keys[i].key_ch, K_F1, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F2 - 1;
           memcpy(keys[i].key_ch, K_F2, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F3 - 1;
           memcpy(keys[i].key_ch, K_F3, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F4 - 1;
           memcpy(keys[i].key_ch, K_F4, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F1 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F1, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F2 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F2, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F3 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F3, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F4 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F4, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F5 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F5, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F6 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F6, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F7 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F7, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F8 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F8, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F9 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F9, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F10 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F10, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F11 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F11, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_SH_F12 - 1;
           memcpy(keys[i].key_ch, K_CTRL_SH_F12, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F1 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F1, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F2 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F2, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F3 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F3, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F4 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F4, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F5 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F5, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F6 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F6, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F7 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F7, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F8 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F8, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F9 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F9, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F10 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F10, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F11 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F11, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_CTRL_F12 - 1;
           memcpy(keys[i].key_ch, K_CTRL_F12, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_HOME - 1;
           keys[i].key_func = bufBEGIN;
           memcpy(keys[i].key_ch, K_HOME, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_END - 1;
           keys[i].key_func = bufEND;
           memcpy(keys[i].key_ch, K_END, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_UP - 1;
           keys[i].key_func = bufUP;
           memcpy(keys[i].key_ch, K_UP, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_DOWN - 1;
           keys[i].key_func = bufDOWN;
           memcpy(keys[i].key_ch, K_DOWN, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_RIGHT - 1;
           keys[i].key_func = bufRIGHT;
           memcpy(keys[i].key_ch, K_RIGHT, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_LEFT - 1;
           keys[i].key_func = bufLEFT;
           memcpy(keys[i].key_ch, K_LEFT, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_BTAB - 1;
           keys[i].key_func = bufBTAB;
           memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);
           i++;
           // 4 bytes
           keys[i].key_len = sizeof K_INS - 1;
           keys[i].key_func = bufMODE;
           memcpy(keys[i].key_ch, K_INS, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_DEL - 1;
           keys[i].key_func = bufDEL;
           memcpy(keys[i].key_ch, K_DEL, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_PGUP - 1;
           memcpy(keys[i].key_ch, K_PGUP, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_PGDN - 1;
           memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);
           i++;
           // 5 bytes
           keys[i].key_len = sizeof K_F5 - 1;
           memcpy(keys[i].key_ch, K_F5, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F6 - 1;
           memcpy(keys[i].key_ch, K_F6, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F7 - 1;
           memcpy(keys[i].key_ch, K_F7, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F8 - 1;
           memcpy(keys[i].key_ch, K_F8, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F9 - 1;
           memcpy(keys[i].key_ch, K_F9, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F10 - 1;
           memcpy(keys[i].key_ch, K_F10, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F11 - 1;
           memcpy(keys[i].key_ch, K_F11, keys[i].key_len);
           i++;
           keys[i].key_len = sizeof K_F12 - 1;
           memcpy(keys[i].key_ch, K_F12, keys[i].key_len);
           i++;
   
           tcgetattr(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 &= ~(ICRNL | BRKINT | INPCK | ISTRIP | IXON);  
         t.c_iflag &= ~ICRNL;  
         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;
        tcsetattr(pty, TCSANOW, &t);        tcsetattr(buffer->line_in, TCSANOW, &t);
   
        ioctl(pty, TIOCPKT, &on);        buffer->line_keys = keys;
         return buffer;
 }
   
        rl_readline_name = csProg;/*
        rl_variable_bind("editing-mode", "emacs"); * cliReadLine() Read line from opened CLI session
  * @buffer = CLI buffer
  * return: NULL if error or !=NULL readed line, must be free after use!
 */
 char *
 cliReadLine(linebuffer_t * __restrict buffer)
 {
         int code, readLen;
         register int i;
         struct pollfd fds;
         char buf[BUFSIZ], *str = NULL;
   
        rl_instream = fdopen(pty, "r");        if (!buffer) {
        rl_outstream = NULL;                cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                 return NULL;
         }
 
         memset(&fds, 0, sizeof fds);
         fds.fd = buffer->line_in;
         fds.events = POLLIN;
 
         printfCR(buffer, 1);
         while (42) {
                 if (poll(&fds, 1, -1) < 1) {
                         LOGERR;
                         return str;
                 }
 
                 memset(buf, 0, sizeof buf);
                 readLen = read(buffer->line_in, buf, BUFSIZ);
                 if (readLen == -1) {
                         LOGERR;
                         return str;
                 }
                 if (!readLen) {
                         if (buffer->line_buf)
                                 str = strdup(buffer->line_buf);
                         else
                                 cli_SetErr(EPIPE, "Error:: unknown state ...");
                         return str;
                 }
 
 recheck:
                 for (code = RETCODE_OK, i = MAX_BINDKEY - 1; i > -1; i--)
                         if (readLen >= buffer->line_keys[i].key_len && 
                                         !memcmp(buffer->line_keys[i].key_ch, buf, 
                                                 buffer->line_keys[i].key_len)) {
                                 readLen -= buffer->line_keys[i].key_len;
                                 if (readLen)
                                         memmove(buf, buf + buffer->line_keys[i].key_len, readLen);
                                 else
                                         memset(buf, 0, buffer->line_keys[i].key_len);
 
                                 if (buffer->line_keys[i].key_func)
                                         if ((code = buffer->line_keys[i].key_func(i, buffer)))
                                                 readLen = 0;
 
                                 if (readLen)
                                         goto recheck;
                                 else
                                         break;
                         }
 
                 if (code)
                         break;
         }
 
         if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)
                 str = strdup(buffer->line_buf);
         return str;
 }  }
*/
 
 /*  /*
 * cliNetExec() Execute net CLI main loop * cliNetLoop() CLI network main loop binded to socket
 * @cmdList = Commands list * @buffer = CLI buffer
 * @csPrompt = Prompt text * @csHistFile = History file name
  * @sock = client socket   * @sock = client socket
  * @term = stdin termios   * @term = stdin termios
  * @win = window size of tty   * @win = window size of tty
 * return: -1 error, 0 = exit w/^+D, 1 done. * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cliNetExec(commands_t *cmdList, const char *csPrompt, int sock, struct termios *term, struct winsize *win)cliNetLoop(linebuffer_t * __restrict buffer, const char *csHistFile, int sock, 
                 struct termios *term, struct winsize *win)
 {  {
        int pty, ret = 0, r, s, alen, attrlen, flg;        u_char buf[BUFSIZ];
         int pty, r, s, alen, attrlen, flg, ret = 0;
         fd_set fds;          fd_set fds;
         struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };          struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
         u_char buf[BUFSIZ];  
         struct telnetAttrs *a, Attr[10];          struct telnetAttrs *a, Attr[10];
   
         switch (forkpty(&pty, NULL, term, win)) {          switch (forkpty(&pty, NULL, term, win)) {
Line 174  cliNetExec(commands_t *cmdList, const char *csPrompt,  Line 1040  cliNetExec(commands_t *cmdList, const char *csPrompt, 
                 case 0:                  case 0:
                         close(sock);                          close(sock);
   
                        ret = cliExec(cmdList, csPrompt) < 0 ? 1 : 0;//                      buffer = cliInit(STDIN_FILENO, STDOUT_FILENO, csPrompt);
 //                      if (!buffer)
 //                              return RETCODE_ERR;
 
                         ret = cliLoop(buffer, csHistFile) < 0 ? 1 : 0;
 
 //                      cliEnd(buffer);
 
                         /* spawn Shell mode */                          /* spawn Shell mode */
                         /*                          /*
                         execl("/bin/tcsh", "tcsh", NULL);                          execl("/bin/tcsh", "tcsh", NULL);
                         */                          */
   
                         _exit(ret);                          _exit(ret);
                 default:                  default:
                         /* spawn Shell mode */                          /* spawn Shell mode */
Line 254  cliNetExec(commands_t *cmdList, const char *csPrompt,  Line 1128  cliNetExec(commands_t *cmdList, const char *csPrompt, 
 }  }
   
 /*  /*
 * cliExec() Execute CLI main loop * cliLoop() CLI main loop
 * @cmdList = Commands list * @buffer = CLI buffer
 * @csPrompt = Prompt text * @csHistFile = History file name
 * return: -1 error, 0 = exit w/^+D, 1 done. * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
/*int
int cliExec(cliCommands_t *cmdList, const char *csPrompt)cliLoop(linebuffer_t * __restrict buffer, const char *csHistFile)
 {  {
         char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];          char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
         int ret = 0;  
         register int i;          register int i;
        cliCommands_t *cmd = NULL;        int ret = RETCODE_OK;
        FILE *out;        struct tagCommand *cmd;
   
           /*
         inline int inline_help()          inline int inline_help()
         {          {
                 cli_Cmd_Help(cmdList ? cmdList : cli_stdCmds, -1, out, NULL);                  cli_Cmd_Help(cmdList ? cmdList : cli_stdCmds, -1, out, NULL);
Line 305  int cliExec(cliCommands_t *cmdList, const char *csProm Line 1179  int cliExec(cliCommands_t *cmdList, const char *csProm
   
                 return matches;                  return matches;
         }          }
        char *cli_stdCompEntry(const char *ignore, int invoking_key)
        {
                return NULL;        */
        }
*/ 
         /* --- main body of CLI --- */          /* --- main body of CLI --- */
 /*  
         out = rl_outstream;  
         if (!out)  
                 out = stdout;  
   
        rl_bind_key('?', inline_help);        if (cli_loadHistory(buffer, csHistFile) == RETCODE_ERR)
        if (!rl_attempted_completion_function)                 return RETCODE_ERR;
                cliComp(cli_stdCompletion, cli_stdCompEntry); 
   
         do {          do {
                line = readline(csPrompt);                line = cliReadLine(buffer);
                if (!line) {    // ^+d                if (!line) {
                        cli_Printf(out, "\n");                        printfNL(buffer, 0);
                         break;                          break;
                }                } else
                         cli_addHistory(buffer, NULL);
                 // clear whitespaces                  // clear whitespaces
                 for (s = line; isspace(*s); s++);                  for (s = line; isspace(*s); s++);
                 if (*s) {                  if (*s) {
Line 334  int cliExec(cliCommands_t *cmdList, const char *csProm Line 1203  int cliExec(cliCommands_t *cmdList, const char *csProm
                 }                  }
   
                 if (*s) {                  if (*s) {
                         add_history(s);  
   
                         memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);                          memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);
                         for (app = items; app < items + MAX_PROMPT_ITEMS - 1 && (*app = strsep(&s, " \t"));                           for (app = items; app < items + MAX_PROMPT_ITEMS - 1 && (*app = strsep(&s, " \t")); 
                                         *app ? app++ : app);                                          *app ? app++ : app);
   
                         // exec_cmd ...                          // exec_cmd ...
                        for (cmd = NULL, i = 0; cmdList[i].cmd_name; i++)                        i = 0;
                                if (*items[0] && !strncmp(cmdList[i].cmd_name, items[0], strlen(items[0]))) {                        SLIST_FOREACH(cmd, &buffer->line_cmds, cmd_next) {
                                        cmd = &cmdList[i];                                if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))
                                         break;                                          break;
                                }                                else
                                         i++;
                         }
 
                         if (!cmd) {                          if (!cmd) {
                                cli_Printf(out, "Command '%s' not found!\n", items[0]);                                cli_Printf(buffer, "\nCommand '%s' not found!\n", items[0]);
                                 ret = -1;                                  ret = -1;
                         } else                          } else
                                ret = cmd->cmd_func(cmdList, i, out, items);                                ret = cmd->cmd_func(buffer, i, items);
                 }                  }
   
                   cli_freeLine(buffer);
                   cli_resetHistory(buffer);
                 free(line);                  free(line);
         } while (ret < 1);          } while (ret < 1);
   
           cli_saveHistory(buffer, csHistFile, HISTORY_LINES);
         return ret;          return ret;
 }  }
 */  
Removed from v.1.2.2.2  
changed lines
  Added in v.1.2.2.5

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