[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

version 1.1, 2010/04/16 13:20:29 version 1.2, 2010/06/04 11:32:47
Line 24  cliCommands_t cli_stdCmds[] = { Line 24  cliCommands_t cli_stdCmds[] = {
 int cli_Errno;  int cli_Errno;
 char cli_Error[STRSIZ];  char cli_Error[STRSIZ];
   
   char cli_pending_special_char;
   
 #pragma GCC visibility pop  #pragma GCC visibility pop
   
   
   static void cli_Null_Prep_Term(int meta)
   {
   }
   
   #include <syslog.h>
   static int cli_Net_rl_GetCh(FILE *s)
   {
           int ch = rl_getc(s);
   
           if (!cli_pending_special_char && 0x1b == ch) {
                   cli_pending_special_char = ch;
                   return ch;
           }
           if (cli_pending_special_char && 0x5b == ch) {
                   cli_pending_special_char = ch;
                   return ch;
           }
           if (0x5b == cli_pending_special_char) {
                   cli_pending_special_char = 0;
                   return ch;
           }
   
           syslog(LOG_CRIT, "+++++ getc=%0x\n", ch);
           cli_pending_special_char = 0;
           fputc(ch, rl_outstream);
           fflush(rl_outstream);
           return ch;
   }
   
   #if 0
   static void cli_Line_Handler(char *line)
   {
           int len;
           static char cli_Buffer[BUFSIZ];
           static int cli_BufferLen, cli_BufferPos;
   
           if (!line) {    // EOF
                   fwrite("\x4", 1, 1, rl_outstream);      // ctrl+D
                   goto end;
           } else
                   len = strlen(line);
           if (BUFSIZ - 2 < len)
                   cli_BufferPos = cli_BufferLen = 0;
           else {
                   if (BUFSIZ - 2 < len + cli_BufferLen) {
                           if (BUFSIZ - 2 >= cli_BufferLen - cli_BufferPos + len) {
                                   cli_BufferLen -= cli_BufferPos;
                                   memmove(cli_Buffer, cli_Buffer + cli_BufferPos, cli_BufferLen);
                           } else
                                   cli_BufferLen = 0;
   
                           cli_BufferPos = 0;
                   }
   
                   memcpy(cli_Buffer + cli_BufferLen, line, len);
                   cli_BufferLen += len;
                   cli_Buffer[cli_BufferLen++] = '\r';
                   cli_Buffer[cli_BufferLen++] = '\n';
           }
   
           fwrite(cli_Buffer, 1, cli_BufferLen, rl_outstream);
           if (!cli_pending_special_char) {
                   fwrite("\r", 1, 1, rl_outstream);
                   if (*line)
                           add_history(line);
           }
   
           free(line);
   end:
           rl_callback_handler_remove();
           if (cli_pending_special_char) {
                   fwrite(&cli_pending_special_char, 1, 1, rl_outstream);
                   cli_pending_special_char = 0;
           }
           fflush(rl_outstream);
   }
   #endif
   
   
 // cli_GetErrno() Get error code of last operation  // cli_GetErrno() Get error code of last operation
 inline int cli_GetErrno()  inline int cli_GetErrno()
 {  {
Line 57  inline void cli_SetErr(int eno, char *estr, ...) Line 138  inline void cli_SetErr(int eno, char *estr, ...)
  * cli_Printf() Printf CLI features   * cli_Printf() Printf CLI features
  * @out = Output stream   * @out = Output stream
  * @csFormat = Printf format string   * @csFormat = Printf format string
 * return: none * return: -1 error, != -1 printed chars
 */  */
 inline int cli_Printf(FILE *out, const char *csFormat, ...)  inline int cli_Printf(FILE *out, const char *csFormat, ...)
 {  {
Line 89  inline void cliComp(cli_Completion_t *cmdComplete, cli Line 170  inline void cliComp(cli_Completion_t *cmdComplete, cli
 }  }
   
 /*  /*
    * cliTTY() Initialize I/O TTY CLI features
    * @term = terminal name
    * @inp = input handle
    * @out = output handle
    * @win = window size
    * return: -1 error, != -1 ok
   */
   inline int cliTTY(const char *term, FILE *inp, FILE *out, struct winsize *win)
   {
           if (term)
                   rl_terminal_name = term;
   
           if (inp)
                   rl_instream = inp;
           if (out)
                   rl_outstream = out;
   
           if (win)
                  if (ioctl(!rl_outstream ? STDOUT_FILENO : fileno(rl_outstream), TIOCSWINSZ, win) == -1) {
                          LOGERR;
                          return -1;
                  }
   
           return 0;
   }
   
   /*
    * cli_ReadHistory() Read CLI History from file
    * @csFile = history file name, if NULL default history name is ".aitcli.history"
    * return: -1 error; != -1 readed ok
   */
   inline int cli_ReadHistory(const char *csFile)
   {
           return read_history(!csFile ? ".aitcli.history" : csFile);
   }
   
   /*
    * cli_WriteHistory() Write CLI History to file
    * @csFile = history file name, if NULL default history name is ".aitcli.history"
    * @lineNum = save number of history entry lines, if -1 all lines saved without limit
    * return: -1 error; != -1 readed ok
   */
   inline int cli_WriteHistory(const char *csFile, int lineNum)
   {
           int ret;
           const char *psFile = !csFile ? ".aitcli.history" : csFile;
   
           ret = write_history(psFile);
           if (-1 != ret && -1 != lineNum)
                   history_truncate_file(psFile, lineNum);
   
           return ret;
   }
   
   /*
    * cliNetInit() Initialize Readline if CLI bind to socket
    * @csProg = program name
    * @pty = Master pty
    * @term = stdin termios
    * return: none
   */
   void cliNetInit(const char *csProg, int pty, struct termios *term)
   {
           struct termios t;
           int on = 1;
   
           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(cliCommands_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);
   
   //                      rl_prep_term_function = cli_Null_Prep_Term;
                           rl_getc_function = cli_Net_rl_GetCh;
   
                           cliNetInit(getprogname(), STDIN_FILENO, term);
                           ret = cliExec(cmdList, csPrompt) < 0 ? 1 : 0;
                           /* spawn Shell mode */
                           /*
                           execl("/bin/tcsh", "tcsh", NULL);
                           */
                           _exit(ret);
                   default:
                           rl_prep_term_function = cli_Null_Prep_Term;
   
                           cliNetInit(getprogname(), pty, term);
   
                           /* 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);
                           */
                           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 145  int cliExec(cliCommands_t *cmdList, FILE *out, const c Line 439  int cliExec(cliCommands_t *cmdList, FILE *out, const c
         }          }
   
         /* --- 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) 
Removed from v.1.1  
changed lines
  Added in v.1.2

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