[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.1 and 1.2.2.3

version 1.1, 2010/04/16 13:20:29 version 1.2.2.3, 2010/06/04 13:51:21
Line 11 Line 11
   
 #pragma GCC visibility push(hidden)  #pragma GCC visibility push(hidden)
   
cliCommands_t cli_stdCmds[] = {/*
 commands_t cli_stdCmds[] = {
         { "test", cli_Cmd_Unsupported, "Test - Don`t use default command structure!", "test <cr>", cli_Comp_Filename },           { "test", cli_Cmd_Unsupported, "Test - Don`t use default command structure!", "test <cr>", cli_Comp_Filename }, 
         { "-------", NULL, "---------------------", NULL, NULL },           { "-------", NULL, "---------------------", NULL, NULL }, 
         { "help", cli_Cmd_Help, "Help screen", "help [command] <cr>", NULL },           { "help", cli_Cmd_Help, "Help screen", "help [command] <cr>", NULL }, 
         { "exit", cli_Cmd_Exit, "Exit from console", "exit <cr>", NULL },           { "exit", cli_Cmd_Exit, "Exit from console", "exit <cr>", NULL }, 
         { NULL, NULL, NULL, NULL }          { NULL, NULL, NULL, NULL }
 };  };
   */
   
 // ------------------------------------------------  // ------------------------------------------------
   
Line 26  char cli_Error[STRSIZ]; Line 28  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 int cli_GetErrno()inline int
 cli_GetErrno()
 {  {
         return cli_Errno;          return cli_Errno;
 }  }
   
 // io_GetError() Get error text of last operation  // io_GetError() Get error text of last operation
inline const char *cli_GetError()inline const char *
 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 void cli_SetErr(int eno, char *estr, ...)inline void
 cli_SetErr(int eno, char *estr, ...)
 {  {
         va_list lst;          va_list lst;
   
Line 53  inline void cli_SetErr(int eno, char *estr, ...) Line 57  inline void cli_SetErr(int eno, char *estr, ...)
   
 // ------------------------------------------------------------  // ------------------------------------------------------------
   
   static inline void
   clrscrEOL(linebuffer_t * __restrict buf)
   {
           register int i;
   
           if (buf) {
                   write(buf->line_out, K_CR, 1);
   
                   for (i = 0; i < buf->line_len; i++)
                           write(buf->line_out, K_SPACE, 1);
           }
   }
   
   static inline void
   printfEOL(linebuffer_t * __restrict buf, int len, int prompt)
   {
           if (buf) {
                   write(buf->line_out, K_CR, 1);
   
                   if (prompt && buf->line_prompt)
                           write(buf->line_out, buf->line_prompt, buf->line_bol);
   
                   write(buf->line_out, buf->line_buf, len == -1 ? buf->line_eol - buf->line_bol: len);
           }
   }
   
   static inline void
   printfCR(linebuffer_t * __restrict buf, int prompt)
   {
           if (buf) {
                   write(buf->line_out, K_CR, 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)
   {
           if (buf && text && textlen) {
                   if (prompt && buf->line_prompt)
                           write(buf->line_out, buf->line_prompt, buf->line_bol);
   
                   write(buf->line_out, text, textlen);
           }
   }
   
   // ------------------------------------------------------------
   
   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;
   }
   
   // ---------------------------------------------------------------
   
 /*  /*
 * cli_Printf() Printf CLI features * cli_BindKey() Bind function to key
 * @out = Output stream * @key = key structure
 * @csFormat = Printf format string * @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 text
  * 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) {
                 LOGERR;
                 return RETCODE_ERR;
         }
 
         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   * return: none
 */  */
inline int cli_Printf(FILE *out, const char *csFormat, ...)inline void
 cli_resetHistory(linebuffer_t * __restrict buffer)
 {  {
        va_list lst;        buffer->line_h = NULL;
        int ret;}
   
         va_start(lst, csFormat);  
   
        ret = vfprintf(out, csFormat, lst);/*
        if (-1 == ret) * 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;
 
         if (buffer) {
                 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;
 
         memset(&t, 0, sizeof t);
         /* init buffer */
         buffer = malloc(sizeof (linebuffer_t));
         if (!buffer) {
                 LOGERR;                  LOGERR;
                   return NULL;
           } else {
                   memset(buffer, 0, sizeof(linebuffer_t));
   
        va_end(lst);                buffer->line_in = fin;
        return ret;                buffer->line_out = fout;
 
                 TAILQ_INIT(&buffer->line_history);
 
                 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_iflag |= IGNBRK;
         t.c_cc[VMIN] = 1;
         t.c_cc[VTIME] = 0;
         tcsetattr(buffer->line_in, TCSANOW, &t);
 
         buffer->line_keys = keys;
         return buffer;
 }  }
   
   
   
 /*  /*
 * cliComp() Initialize completion CLI features * cliNetInit() Initialize Readline if CLI bind to socket
 * @cmdComplete = Completion function * @csProg = program name
 * @cmdEntry = Compentry function * @pty = Master pty
  * @term = stdin termios
  * return: none   * return: none
 */  */
inline void cliComp(cli_Completion_t *cmdComplete, cli_CompEntry_t *cmdEntry)/*
 void cliNetInit(const char *csProg, int pty, struct termios *term)
 {  {
        // command completon        struct termios t;
        rl_attempted_completion_function = cmdComplete;        int on = 1;
        rl_completion_entry_function = cmdEntry;
         memset(&t, 0, sizeof t);
         if (term)
                 t = *term;
         else {
                 t.c_lflag = TTYDEF_LFLAG;
                 t.c_iflag = TTYDEF_IFLAG;
                 t.c_oflag = TTYDEF_OFLAG;
                 t.c_cflag = TTYDEF_CFLAG;
                 cfsetspeed(&t, B9600);
         }
 
         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_cc[VMIN] = 1;
         t.c_cc[VTIME] = 0;
         tcsetattr(pty, TCSANOW, &t);
 
         ioctl(pty, TIOCPKT, &on);
 
         rl_readline_name = csProg;
         rl_variable_bind("editing-mode", "emacs");
 
         rl_instream = fdopen(pty, "r");
         rl_outstream = NULL;
 }  }
   */
   /*
    * cliNetExec() Execute net CLI main loop
    * @cmdList = Commands list
    * @csPrompt = Prompt text
    * @sock = client socket
    * @term = stdin termios
    * @win = window size of tty
    * return: -1 error, 0 = exit w/^+D, 1 done.
   */
   int
   cliNetExec(commands_t *cmdList, const char *csPrompt, int sock, struct termios *term, struct winsize *win)
   {
           int pty, ret = 0, r, s, alen, attrlen, flg;
           fd_set fds;
           struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
           u_char buf[BUFSIZ];
           struct telnetAttrs *a, Attr[10];
   
           switch (forkpty(&pty, NULL, term, win)) {
                   case -1:
                           LOGERR;
                           return -1;
                   case 0:
                           close(sock);
   
                           ret = cliExec(cmdList, csPrompt) < 0 ? 1 : 0;
                           /* spawn Shell mode */
                           /*
                           execl("/bin/tcsh", "tcsh", NULL);
                           */
                           _exit(ret);
                   default:
                           /* spawn Shell mode */
                           telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
                           telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
                           telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);
                           telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);
                           telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);
                           if ((ret = telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1) {
                                   cli_Errno = telnet_GetErrno();
                                   strlcpy(cli_Error, telnet_GetError(), STRSIZ);
                                   return -1;
                           } else
                                   flg = 0;
   
                           while (42) {
                                   FD_ZERO(&fds);
                                   FD_SET(sock, &fds);
                                   FD_SET(pty, &fds);
                                   if ((ret = select(FD_SETSIZE, &fds, NULL, NULL, &tv)) < 1) {
                                           if (!ret)
                                                   cli_SetErr(ETIMEDOUT, "Client session timeout ...");
   
                                           break;
                                   }
   
                                   r = FD_ISSET(sock, &fds) ? sock : pty;
                                   s = FD_ISSET(sock, &fds) ? pty : sock;
   
                                   if ((ret = telnetRecv(r, &a, &alen, buf, BUFSIZ)) < 0) {
                                           if (a)
                                                   free(a);
   
                                           if (-2 == ret)
                                                   continue;
                                           // EOF
                                           if (-3 == ret)
                                                   shutdown(r, SHUT_RD);
                                           else {
                                                   cli_Errno = telnet_GetErrno();
                                                   strlcpy(cli_Error, telnet_GetError(), STRSIZ);
                                           }
                                           break;
                                   }
                                   attrlen = 0;
                                   if (1 == flg && alen) {
                                           telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);
                                           telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);
                                   }
                                   if (2 == flg && alen) {
                                           telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);
                                           telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
                                                           LFLOW_OFF, NULL, 0);
                                           telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
                                                           LFLOW_RESTART_XON, NULL, 0);
                                           telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
                                   }
                                   if (a)
                                           free(a);
   
                                   if ((ret = telnetSend(s, Attr, pty == s ? 0 : attrlen, buf, ret, 0)) == -1) {
                                           cli_Errno = telnet_GetErrno();
                                           strlcpy(cli_Error, telnet_GetError(), STRSIZ);
                                           break;
                                   } else
                                           flg++;
                           }
   
                           close(pty);
           }
   
           return ret;
   }
   
 /*  /*
  * cliExec() Execute CLI main loop   * cliExec() Execute CLI main loop
  * @cmdList = Commands list   * @cmdList = Commands list
  * @out = Output handle  
  * @csPrompt = Prompt text   * @csPrompt = Prompt text
  * return: -1 error, 0 = exit w/^+D, 1 done.   * return: -1 error, 0 = exit w/^+D, 1 done.
 */  */
int cliExec(cliCommands_t *cmdList, FILE *out, const char *csPrompt)/*
 int cliExec(cliCommands_t *cmdList, const char *csPrompt)
 {  {
         char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];          char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
         int ret = 0;          int ret = 0;
         register int i;          register int i;
         cliCommands_t *cmd = NULL;          cliCommands_t *cmd = NULL;
           FILE *out;
   
         inline int inline_help()          inline int inline_help()
         {          {
Line 143  int cliExec(cliCommands_t *cmdList, FILE *out, const c Line 1100  int cliExec(cliCommands_t *cmdList, FILE *out, const c
         {          {
                 return NULL;                  return NULL;
         }          }
*/
         /* --- main body of CLI --- */          /* --- main body of CLI --- */
   /*
           out = rl_outstream;
           if (!out)
                   out = stdout;
   
         rl_bind_key('?', inline_help);          rl_bind_key('?', inline_help);
         if (!rl_attempted_completion_function)           if (!rl_attempted_completion_function) 
Line 170  int cliExec(cliCommands_t *cmdList, FILE *out, const c Line 1131  int cliExec(cliCommands_t *cmdList, FILE *out, const c
                         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);
   
                         /*  
                         for (i = 0; i < MAX_PROMPT_ITEMS; i++)  
                                 cli_Printf(out, "i=%d %s\n", i, items[i]);  
                                 */  
   
                         // exec_cmd ...                          // exec_cmd ...
                         for (cmd = NULL, i = 0; cmdList[i].cmd_name; i++)                          for (cmd = NULL, i = 0; cmdList[i].cmd_name; i++)
                                 if (*items[0] && !strncmp(cmdList[i].cmd_name, items[0], strlen(items[0]))) {                                  if (*items[0] && !strncmp(cmdList[i].cmd_name, items[0], strlen(items[0]))) {
Line 193  int cliExec(cliCommands_t *cmdList, FILE *out, const c Line 1149  int cliExec(cliCommands_t *cmdList, FILE *out, const c
   
         return ret;          return ret;
 }  }
   */
Removed from v.1.1  
changed lines
  Added in v.1.2.2.3

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