[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.7 and 1.2.2.21

version 1.2.2.7, 2010/06/07 11:54:00 version 1.2.2.21, 2010/12/07 16:33:46
Line 12 Line 12
   
 #pragma GCC visibility push(hidden)  #pragma GCC visibility push(hidden)
   
 /*  
 commands_t cli_stdCmds[] = {  
         { "test", cli_Cmd_Unsupported, "Test - Don`t use default command structure!", "test <cr>", cli_Comp_Filename },   
         { "-------", NULL, "---------------------", NULL, NULL },   
         { "help", cli_Cmd_Help, "Help screen", "help [command] <cr>", NULL },   
         { "exit", cli_Cmd_Exit, "Exit from console", "exit <cr>", NULL },   
         { NULL, NULL, NULL, NULL }  
 };  
 */  
   
 // ------------------------------------------------  // ------------------------------------------------
   
 int cli_Errno;  int cli_Errno;
Line 108  printfNL(linebuffer_t * __restrict buf, int prompt) Line 98  printfNL(linebuffer_t * __restrict buf, int prompt)
         }          }
 }  }
   
 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  static int
Line 145  bufCHAR(int idx, void * __restrict buffer) Line 124  bufCHAR(int idx, void * __restrict buffer)
         write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);          write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
   
         if (buf->line_mode == LINEMODE_INS) {          if (buf->line_mode == LINEMODE_INS) {
                printfCLI(buf, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len,                 write(buf->line_out, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len, 
                                buf->line_len - buf->line_eol, 0);                                buf->line_len - buf->line_eol);
                 printfEOL(buf, -1, 1);                  printfEOL(buf, -1, 1);
         }          }
         return RETCODE_OK;          return RETCODE_OK;
Line 165  bufEOL(int idx, void * __restrict buffer) Line 144  bufEOL(int idx, void * __restrict buffer)
 static int  static int
 bufEOF(int idx, void * __restrict buffer)  bufEOF(int idx, void * __restrict buffer)
 {  {
        linebuffer_t *buf = buffer;        /*
 
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
           */
   
         write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);  
         return RETCODE_EOF;          return RETCODE_EOF;
 }  }
   
Line 384  bufDEL(int idx, void * __restrict buffer) Line 362  bufDEL(int idx, void * __restrict buffer)
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
   static int
   bufComp(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
           char *str, *s, **app, *items[MAX_PROMPT_ITEMS], szLine[STRSIZ];
           register int i, j;
           struct tagCommand *cmd, *c;
           int pos, ret = RETCODE_OK;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           str = strdup(buf->line_buf);
           if (!str)
                   return RETCODE_ERR;
           else {
                   s = str;
                   io_TrimStr((u_char*) s);
           }
   
           i = j = 0;
           c = NULL;
           memset(szLine, 0, STRSIZ);
           if (*s) {
                   memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);
                   for (app = items, i = 0; app < items + MAX_PROMPT_ITEMS - 1 && (*app = strsep(&s, " \t")); 
                                   *app ? i++ : i, *app ? app++ : app);
   
                   if (i) {
                           SLIST_FOREACH(cmd, &buf->line_cmds, cmd_next) {
                                   if (cmd->cmd_level == buf->line_level && 
                                                   !strncmp(cmd->cmd_name, items[0], strlen(items[0]))) {
                                           if (strncmp(cmd->cmd_name, CLI_CMD_SEP, strlen(CLI_CMD_SEP))) {
                                                   j++;
                                                   c = cmd;
                                                   strlcat(szLine, " ", STRSIZ);
                                                   strlcat(szLine, cmd->cmd_name, STRSIZ);
                                           }
                                   }
                           }
   
                           if (i > 1 && c) {
                                   /* we are on argument of command and has complition info */
                                   j++;    // always must be j > 1 ;) for arguments
                                   strlcpy(szLine, c->cmd_info, STRSIZ);
                           }
                   } else {
                           /* we have valid char but i == 0, this case is illegal */
                           ret = RETCODE_ERR;
                           goto endcomp;
                   }
           } else {
                   /* we on 0 position of prompt, show commands for this level */
                   SLIST_FOREACH(cmd, &buf->line_cmds, cmd_next) {
                           if (cmd->cmd_level == buf->line_level)
                                   if (strncmp(cmd->cmd_name, CLI_CMD_SEP, strlen(CLI_CMD_SEP))) {
                                           j++;
                                           c = cmd;
                                           strlcat(szLine, " ", STRSIZ);
                                           strlcat(szLine, cmd->cmd_name, STRSIZ);
                                   }
                   }
           }
   
           /* completion show actions ... */
           if (j > 1 && c) {
                   printfNL(buf, 0);
                   write(buf->line_out, szLine, strlen(szLine));
                   printfNL(buf, 1);
                   printfEOL(buf, buf->line_len - 1, 1);
                   printfEOL(buf, -1, 1);
           }
           if (j == 1 && c) {
                   clrscrEOL(buf);
                   cli_freeLine(buf);
   
                   pos = buf->line_eol - buf->line_bol;
   
                   buf->line_len += c->cmd_len + 1;
                   buf->line_eol += c->cmd_len + 1;
   
                   memcpy(buf->line_buf + pos, c->cmd_name, c->cmd_len);
                   buf->line_buf[pos + c->cmd_len] = (u_char) *K_SPACE;
                   buf->line_buf[buf->line_len - 1] = 0;
   
                   printfEOL(buf, -1, 1);
           }
   
   endcomp:
           free(str);
           return ret;
   }
   
   static int
   bufHelp(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           cli_Cmd_Help(buf, -1, NULL);
   
           printfEOL(buf, buf->line_len - 1, 1);
           printfEOL(buf, -1, 1);
           return RETCODE_OK;
   }
   
 // ---------------------------------------------------------------  // ---------------------------------------------------------------
   
 /*  /*
Line 414  cli_Printf(linebuffer_t * __restrict buffer, char *fmt Line 500  cli_Printf(linebuffer_t * __restrict buffer, char *fmt
 }  }
   
 /*  /*
    * cli_PrintHelp() Print help screen
    * @buffer = CLI buffer
    * return: none
   */
   inline void
   cli_PrintHelp(linebuffer_t * __restrict buffer)
   {
           if (buffer) {
                   bufHelp(0, buffer);
                   clrscrEOL(buffer);
           } else
                   cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
   }
   
   
   /*
  * cli_BindKey() Bind function to key   * cli_BindKey() Bind function to key
  * @key = key structure   * @key = key structure
  * @buffer = CLI buffer   * @buffer = CLI buffer
Line 456  cli_addCommand(linebuffer_t * __restrict buffer, const Line 558  cli_addCommand(linebuffer_t * __restrict buffer, const
 {  {
         struct tagCommand *cmd;          struct tagCommand *cmd;
   
        if (!buffer || !csCmd || !funcCmd) {        if (!buffer || !csCmd) {
                 cli_SetErr(EINVAL, "Error:: invalid input parameters ...");                  cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                 return RETCODE_ERR;                  return RETCODE_ERR;
         }          }
Line 805  cliInit(int fin, int fout, const char *prompt) Line 907  cliInit(int fin, int fout, const char *prompt)
         linebuffer_t *buffer;          linebuffer_t *buffer;
         bindkey_t *keys;          bindkey_t *keys;
         register int i;          register int i;
         struct termios t;  
   
         memset(&t, 0, sizeof t);  
         /* init buffer */          /* init buffer */
        buffer = malloc(sizeof (linebuffer_t));        buffer = malloc(sizeof(linebuffer_t));
         if (!buffer) {          if (!buffer) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 856  cliInit(int fin, int fout, const char *prompt) Line 956  cliInit(int fin, int fout, const char *prompt)
   
         /* add helper functions */          /* add helper functions */
         cli_addCommand(buffer, "exit", 0, cli_Cmd_Exit, "exit <cr>", "Exit from console");          cli_addCommand(buffer, "exit", 0, cli_Cmd_Exit, "exit <cr>", "Exit from console");
           cli_addCommand(buffer, "help", 0, cli_Cmd_Help, "help [command] <cr>", "Help screen");
           cli_addCommand(buffer, "-------", 0, NULL, "-------------------------", NULL);
   
         /* fill key bindings */          /* fill key bindings */
         // ascii chars & ctrl+chars          // ascii chars & ctrl+chars
Line 875  cliInit(int fin, int fout, const char *prompt) Line 977  cliInit(int fin, int fout, const char *prompt)
                         keys[i].key_func = bufBEGIN;                          keys[i].key_func = bufBEGIN;
                 if (i == *K_CTRL_E)                  if (i == *K_CTRL_E)
                         keys[i].key_func = bufEND;                          keys[i].key_func = bufEND;
                   if (i == *K_TAB)
                           keys[i].key_func = bufComp;
                 if (i >= *K_SPACE && i < *K_BACKSPACE)                  if (i >= *K_SPACE && i < *K_BACKSPACE)
                         keys[i].key_func = bufCHAR;                          keys[i].key_func = bufCHAR;
                 if (i > *K_BACKSPACE && i < 0xff)                  if (i > *K_BACKSPACE && i < 0xff)
                         keys[i].key_func = bufCHAR;                          keys[i].key_func = bufCHAR;
                   if (i == '?')
                           keys[i].key_func = bufHelp;
         }          }
         // alt+chars          // alt+chars
         for (i = 256; i < 512; i++) {          for (i = 256; i < 512; i++) {
Line 1041  cliInit(int fin, int fout, const char *prompt) Line 1147  cliInit(int fin, int fout, const char *prompt)
         memcpy(keys[i].key_ch, K_F12, keys[i].key_len);          memcpy(keys[i].key_ch, K_F12, keys[i].key_len);
         i++;          i++;
   
           buffer->line_keys = keys;
           return buffer;
   }
   
   /*
    * cliInitLine() Init CLI input line terminal
    * @buffer = CLI buffer
    * return: none
   */
   int
   cliInitLine(linebuffer_t * __restrict buffer)
   {
           struct termios t;
   
           memset(&t, 0, sizeof t);
         tcgetattr(buffer->line_in, &t);          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 |= 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(buffer->line_in, TCSANOW, &t);        return tcsetattr(buffer->line_in, TCSANOW, &t);
 
        buffer->line_keys = keys; 
        return buffer; 
 }  }
   
 /*  /*
Line 1131  recheck: Line 1249  recheck:
  * @buffer = CLI buffer   * @buffer = CLI buffer
  * @csHistFile = History file name   * @csHistFile = History file name
  * @sock = client socket   * @sock = client socket
  * @term = stdin termios  
  * @win = window size of tty  
  * return: RETCODE_ERR error, RETCODE_OK ok   * return: RETCODE_ERR error, RETCODE_OK ok
 */  */
 int  int
cliNetLoop(linebuffer_t * __restrict buffer, const char *csHistFile, int sock, cliNetLoop(linebuffer_t * __restrict buffer, const char *csHistFile, int sock)
                struct termios *term, struct winsize *win) 
 {  {
         u_char buf[BUFSIZ];          u_char buf[BUFSIZ];
        int pty, r, s, alen, attrlen, flg, ret = 0;        int pid, stat, pty, r, s, alen, flg, attrlen = 0, ret = 0;
         fd_set fds;          fd_set fds;
         struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };          struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
         struct telnetAttrs *a, Attr[10];          struct telnetAttrs *a, Attr[10];
   
        switch (forkpty(&pty, NULL, term, win)) {        switch ((pid = forkpty(&pty, NULL, NULL, NULL))) {
                 case -1:                  case -1:
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
                 case 0:                  case 0:
                        close(sock);                        if (!buffer) {
                                 cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
                                 return -1;
                         } else
                                 close(sock);
   
 //                      buffer = cliInit(STDIN_FILENO, STDOUT_FILENO, csPrompt);  
 //                      if (!buffer)  
 //                              return RETCODE_ERR;  
   
                         ret = cliLoop(buffer, csHistFile) < 0 ? 1 : 0;                          ret = cliLoop(buffer, csHistFile) < 0 ? 1 : 0;
                           cliEnd(buffer);
   
//                      cliEnd(buffer);                        exit(ret);
 
                        /* spawn Shell mode */ 
                        /* 
                        execl("/bin/tcsh", "tcsh", NULL); 
                        */ 
 
                        _exit(ret); 
                 default:                  default:
                         /* spawn Shell mode */  
                         telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);                          telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
                         telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);                          telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
                         telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);                          telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);
Line 1181  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1289  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                                 flg = 0;                                  flg = 0;
   
                         while (42) {                          while (42) {
                                   if (waitpid(pid, &stat, WNOHANG))
                                           break;
   
                                 FD_ZERO(&fds);                                  FD_ZERO(&fds);
                                 FD_SET(sock, &fds);                                  FD_SET(sock, &fds);
                                 FD_SET(pty, &fds);                                  FD_SET(pty, &fds);
Line 1194  cliNetLoop(linebuffer_t * __restrict buffer, const cha Line 1305  cliNetLoop(linebuffer_t * __restrict buffer, const cha
                                 r = FD_ISSET(sock, &fds) ? sock : pty;                                  r = FD_ISSET(sock, &fds) ? sock : pty;
                                 s = FD_ISSET(sock, &fds) ? pty : sock;                                  s = FD_ISSET(sock, &fds) ? pty : sock;
   
                                if ((ret = telnetRecv(r, &a, &alen, buf, BUFSIZ)) < 0) {                                if (FD_ISSET(sock, &fds)) {
                                         memset(buf, 0, BUFSIZ);
                                         if ((ret = telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {
                                                 if (a)
                                                         free(a);
 
                                                 if (-2 == ret)
                                                         continue;
                                                 // EOF
                                                 if (-3 == ret)
                                                         shutdown(sock, 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)                                          if (a)
                                                 free(a);                                                  free(a);
   
                                        if (-2 == ret)                                        if ((ret = write(pty, buf, ret)) == -1) {
                                                continue;                                                LOGERR;
                                        // EOF                                                break;
                                        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) {                                if (FD_ISSET(pty, &fds)) {
                                        cli_Errno = telnet_GetErrno();                                        memset(buf, 0, BUFSIZ);
                                        strlcpy(cli_Error, telnet_GetError(), STRSIZ);                                        if ((ret = read(pty, buf, BUFSIZ)) == -1) {
                                        break;                                                LOGERR;
                                } else                                                break;
                                        flg++;                                        }
 
                                         if ((ret = telnetSend(sock, Attr, pty == s ? 0 : attrlen, buf, ret, 0)) == -1) {
                                                 cli_Errno = telnet_GetErrno();
                                                 strlcpy(cli_Error, telnet_GetError(), STRSIZ);
                                                 break;
                                         } else
                                                 flg++;
                                 }
                         }                          }
   
                         close(pty);                          close(pty);
Line 1253  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1380  cliLoop(linebuffer_t * __restrict buffer, const char *
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
         struct tagCommand *cmd;          struct tagCommand *cmd;
   
         /*  
         inline int inline_help()  
         {  
                 cli_Cmd_Help(cmdList ? cmdList : cli_stdCmds, -1, out, NULL);  
                 rl_on_new_line();  
                 return 0;  
         }  
   
         char **cli_stdCompletion(const char *text, int start, int end)  
         {  
                 register int i;  
                 char **matches = NULL;  
   
                 char *cmdCompGet(const char *text, int state)  
                 {  
                         int len = strlen(text);  
   
                         for (i = state; cmdList[i].cmd_name; i++) {  
                                 if (strncmp(cmdList[i].cmd_name, "---", 3) &&   
                                                 !strncmp(cmdList[i].cmd_name, text, len))  
                                         return strdup(cmdList[i].cmd_name);  
                         }  
   
                         return NULL;  
                 }  
   
                 if (!start)  
                         matches = rl_completion_matches(text, cmdCompGet);  
                 else  
                         for (i = 0; cmdList[i].cmd_name; i++) {  
                                 if (!cmdList[i].cmd_comp)  
                                         continue;  
                                 if (!strncmp(rl_line_buffer, cmdList[i].cmd_name, strlen(cmdList[i].cmd_name)))  
                                         matches = rl_completion_matches(text, cmdList[i].cmd_comp);  
                         }  
   
                 return matches;  
         }  
   
   
         */  
   
         /* --- main body of CLI --- */          /* --- main body of CLI --- */
           cliInitLine(buffer);
   
         if (cli_loadHistory(buffer, csHistFile) == RETCODE_ERR)          if (cli_loadHistory(buffer, csHistFile) == RETCODE_ERR)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 1332  cliLoop(linebuffer_t * __restrict buffer, const char * Line 1418  cliLoop(linebuffer_t * __restrict buffer, const char *
                                 cli_Printf(buffer, "\nCommand '%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(buffer, i, items);                                if (cmd->cmd_func) {
                                         cli_Printf(buffer, "\n");
                                         ret = cmd->cmd_func(buffer, i, items);
                                 } else {
                                         clrscrEOL(buffer);
                                         printfCR(buffer, 1);
                                 }
                 }                  }
   
                 cli_freeLine(buffer);                  cli_freeLine(buffer);
Removed from v.1.2.2.7  
changed lines
  Added in v.1.2.2.21

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