[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.15 and 1.21.2.2

version 1.15, 2016/08/18 09:27:37 version 1.21.2.2, 2025/12/21 23:21:40
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004 - 2016Copyright 2004 - 2025
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 87  static inline void Line 87  static inline void
 clrscrEOL(linebuffer_t * __restrict buf)  clrscrEOL(linebuffer_t * __restrict buf)
 {  {
         register int i;          register int i;
           int ign __attribute__((unused));
   
         if (buf && buf->line_prompt) {          if (buf && buf->line_prompt) {
                write(buf->line_out, K_CR, 1);                ign = write(buf->line_out, K_CR, 1);
   
                 for (i = 0; i < buf->line_len; i++)                  for (i = 0; i < buf->line_len; i++)
                        write(buf->line_out, K_SPACE, 1);                        ign = write(buf->line_out, K_SPACE, 1);
         }          }
 }  }
   
 static inline void  static inline void
 printfEOL(linebuffer_t * __restrict buf, int len, int prompt)  printfEOL(linebuffer_t * __restrict buf, int len, int prompt)
 {  {
           int ign __attribute__((unused));
   
         if (buf) {          if (buf) {
                 if (prompt && buf->line_prompt) {                  if (prompt && buf->line_prompt) {
                        write(buf->line_out, K_CR, 1);                        ign = write(buf->line_out, K_CR, 1);
                        write(buf->line_out, buf->line_prompt, buf->line_bol);                        ign = write(buf->line_out, buf->line_prompt, buf->line_bol);
                 }                  }
   
                write(buf->line_out, buf->line_buf, len == -1 ?                 ign = write(buf->line_out, buf->line_buf, len == -1 ? 
                                 buf->line_eol - buf->line_bol : len);                                  buf->line_eol - buf->line_bol : len);
         }          }
 }  }
Line 113  printfEOL(linebuffer_t * __restrict buf, int len, int  Line 116  printfEOL(linebuffer_t * __restrict buf, int len, int 
 static inline void  static inline void
 printfCR(linebuffer_t * __restrict buf, int prompt)  printfCR(linebuffer_t * __restrict buf, int prompt)
 {  {
           int ign __attribute__((unused));
   
         if (buf && prompt && buf->line_prompt) {          if (buf && prompt && buf->line_prompt) {
                write(buf->line_out, K_CR, 1);                ign = write(buf->line_out, K_CR, 1);
                write(buf->line_out, buf->line_prompt, buf->line_bol);                ign = write(buf->line_out, buf->line_prompt, buf->line_bol);
         }          }
 }  }
   
 static inline void  static inline void
 printfNL(linebuffer_t * __restrict buf, int prompt)  printfNL(linebuffer_t * __restrict buf, int prompt)
 {  {
           int ign __attribute__((unused));
   
         if (buf) {          if (buf) {
                write(buf->line_out, K_ENTER, 1);                ign = write(buf->line_out, K_ENTER, 1);
   
                 if (prompt)                  if (prompt)
                         if (prompt && buf->line_prompt)                          if (prompt && buf->line_prompt)
                                write(buf->line_out, buf->line_prompt, buf->line_bol);                                ign = write(buf->line_out, buf->line_prompt, buf->line_bol);
         }          }
 }  }
   
Line 138  bufCHAR(int idx, void * __restrict cli_buffer) Line 145  bufCHAR(int idx, void * __restrict cli_buffer)
 {  {
         linebuffer_t *buf = cli_buffer;          linebuffer_t *buf = cli_buffer;
         int pos;          int pos;
           int ign __attribute__((unused));
   
         if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)          if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 155  bufCHAR(int idx, void * __restrict cli_buffer) Line 163  bufCHAR(int idx, void * __restrict cli_buffer)
         buf->line_buf[buf->line_len - 1] = 0;          buf->line_buf[buf->line_len - 1] = 0;
   
         if (buf->line_prompt)          if (buf->line_prompt)
                write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);                ign = 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) {
                write(buf->line_out, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len,                 ign = write(buf->line_out, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len, 
                                 buf->line_len - buf->line_eol);                                  buf->line_len - buf->line_eol);
                 printfEOL(buf, -1, 1);                  printfEOL(buf, -1, 1);
         }          }
Line 178  bufEOL(int idx, void * __restrict cli_buffer) Line 186  bufEOL(int idx, void * __restrict cli_buffer)
 static int  static int
 bufEOF(int idx, void * __restrict cli_buffer)  bufEOF(int idx, void * __restrict cli_buffer)
 {  {
           int ret;
   
         /*          /*
         if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)          if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
         */          */
   
        return RETCODE_EOF;        printfNL(cli_buffer, 0);
         ret = cli_Cmd_End(cli_buffer, idx, NULL);
         printfCR(cli_buffer, (ret != RETCODE_EOF));
 
         return ret;
 }  }
   
 static int  static int
Line 404  bufComp(int idx, void * __restrict cli_buffer) Line 418  bufComp(int idx, void * __restrict cli_buffer)
         register int i, j;          register int i, j;
         struct tagCommand *cmd, *c;          struct tagCommand *cmd, *c;
         int pos, ret = RETCODE_OK;          int pos, ret = RETCODE_OK;
           int ign __attribute__((unused));
   
         if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)          if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 416  bufComp(int idx, void * __restrict cli_buffer) Line 431  bufComp(int idx, void * __restrict cli_buffer)
                 str_Trim(s);                  str_Trim(s);
         }          }
   
        i = j = 0;        j = 0;
         c = NULL;          c = NULL;
         memset(szLine, 0, STRSIZ);          memset(szLine, 0, STRSIZ);
         if (*s) {          if (*s) {
Line 466  bufComp(int idx, void * __restrict cli_buffer) Line 481  bufComp(int idx, void * __restrict cli_buffer)
         /* completion show actions ... */          /* completion show actions ... */
         if (j > 1 && c) {          if (j > 1 && c) {
                 printfNL(buf, 0);                  printfNL(buf, 0);
                write(buf->line_out, szLine, strlen(szLine));                ign = write(buf->line_out, szLine, strlen(szLine));
                 printfNL(buf, 1);                  printfNL(buf, 1);
                 printfEOL(buf, buf->line_len - 1, 1);                  printfEOL(buf, buf->line_len - 1, 1);
                 printfEOL(buf, -1, 1);                  printfEOL(buf, -1, 1);
Line 511  static int Line 526  static int
 bufEndNode(int idx, void * __restrict cli_buffer)  bufEndNode(int idx, void * __restrict cli_buffer)
 {  {
         linebuffer_t *buf = cli_buffer;          linebuffer_t *buf = cli_buffer;
           char szPrompt[STRSIZ + 16] = {[0 ... STRSIZ + 15] = 0};
   
         if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)          if (!cli_buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 518  bufEndNode(int idx, void * __restrict cli_buffer) Line 534  bufEndNode(int idx, void * __restrict cli_buffer)
         if (buf->line_level > 0) {          if (buf->line_level > 0) {
                 printfNL(cli_buffer, 0);                  printfNL(cli_buffer, 0);
                 buf->line_level--;                  buf->line_level--;
                   snprintf(szPrompt, sizeof szPrompt, "%s{%d}> ", buf->line_porigin, buf->line_level);
                   cli_setPrompt(buf, szPrompt);
                 cli_Printf(buf, "Enter to config level %d\n", buf->line_level);                  cli_Printf(buf, "Enter to config level %d\n", buf->line_level);
         }          }
   
Line 540  cli_Printf(linebuffer_t * __restrict cli_buffer, char  Line 558  cli_Printf(linebuffer_t * __restrict cli_buffer, char 
         FILE *f;          FILE *f;
   
         if (fmt) {          if (fmt) {
                f = fdopen(cli_buffer->line_out, "a");                f = fdopen(dup(cli_buffer->line_out), "a");
                 if (!f) {                  if (!f) {
                         LOGERR;                          LOGERR;
                         return;                          return;
Line 549  cli_Printf(linebuffer_t * __restrict cli_buffer, char  Line 567  cli_Printf(linebuffer_t * __restrict cli_buffer, char 
                 va_start(lst, fmt);                  va_start(lst, fmt);
                 vfprintf(f, fmt, lst);                  vfprintf(f, fmt, lst);
                 va_end(lst);                  va_end(lst);
   
                   fclose(f);
         } else          } else
                 cli_SetErr(EINVAL, "Invalid input parameters ...");                  cli_SetErr(EINVAL, "Invalid input parameters ...");
 }  }
Line 958  cliEnd(linebuffer_t * __restrict cli_buffer) Line 978  cliEnd(linebuffer_t * __restrict cli_buffer)
                 if (cli_buffer->line_buf)                  if (cli_buffer->line_buf)
                         e_free(cli_buffer->line_buf);                          e_free(cli_buffer->line_buf);
   
                   if (cli_buffer->line_inkeys)
                           e_free(cli_buffer->line_inkeys);
                   if (cli_buffer->line_input)
                           e_free(cli_buffer->line_input);
   
                 e_free(cli_buffer);                  e_free(cli_buffer);
                 cli_buffer = NULL;                  cli_buffer = NULL;
         } else          } else
Line 976  linebuffer_t * Line 1001  linebuffer_t *
 cliInit(int fin, int fout, const char *prompt)  cliInit(int fin, int fout, const char *prompt)
 {  {
         linebuffer_t *cli_buffer;          linebuffer_t *cli_buffer;
        bindkey_t *keys;        bindkey_t *keys, *inkeys;
         register int i;          register int i;
           char szPrompt[STRSIZ + 16] = {[0 ... STRSIZ + 15] = 0};
   
         /* init buffer */          /* init buffer */
         cli_buffer = e_malloc(sizeof(linebuffer_t));          cli_buffer = e_malloc(sizeof(linebuffer_t));
Line 994  cliInit(int fin, int fout, const char *prompt) Line 1020  cliInit(int fin, int fout, const char *prompt)
                 SLIST_INIT(&cli_buffer->line_cmds);                  SLIST_INIT(&cli_buffer->line_cmds);
   
                 if (prompt) {                  if (prompt) {
                        cli_buffer->line_prompt = e_strdup(prompt);                        strlcpy(cli_buffer->line_porigin, prompt, sizeof cli_buffer->line_porigin);
                         snprintf(szPrompt, sizeof szPrompt, "%s{%d}> ", cli_buffer->line_porigin, cli_buffer->line_level);
                         cli_buffer->line_prompt = e_strdup(szPrompt);
                         if (!cli_buffer->line_prompt) {                          if (!cli_buffer->line_prompt) {
                                 LOGERR;                                  LOGERR;
                                 e_free(cli_buffer);                                  e_free(cli_buffer);
Line 1026  cliInit(int fin, int fout, const char *prompt) Line 1054  cliInit(int fin, int fout, const char *prompt)
                 return NULL;                  return NULL;
         } else          } else
                 memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));                  memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));
           inkeys = e_calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
           if (!inkeys) {
                   LOGERR;
                   e_free(keys);
                   if (cli_buffer->line_prompt)
                           e_free(cli_buffer->line_prompt);
                   e_free(cli_buffer->line_buf);
                   e_free(cli_buffer);
                   return NULL;
           } else
                   memset(inkeys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));
   
         /* add helper functions */          /* add helper functions */
         cli_addCommand(cli_buffer, "exit", 1, cli_Cmd_Exit, "exit <cr>", "Exit from console");          cli_addCommand(cli_buffer, "exit", 1, cli_Cmd_Exit, "exit <cr>", "Exit from console");
Line 1042  cliInit(int fin, int fout, const char *prompt) Line 1081  cliInit(int fin, int fout, const char *prompt)
         /* fill key bindings */          /* fill key bindings */
         /* ascii chars & ctrl+chars */          /* ascii chars & ctrl+chars */
         for (i = 0; i < 256; i++) {          for (i = 0; i < 256; i++) {
                *keys[i].key_ch = (u_char) i;                *keys[i].key_ch = *inkeys[i].key_ch = (u_char) i;
                keys[i].key_len = 1;                keys[i].key_len = inkeys[i].key_len = 1;
   
                 if (!i || i == *K_CTRL_D)                  if (!i || i == *K_CTRL_D)
                         keys[i].key_func = bufEOF;                          keys[i].key_func = bufEOF;
Line 1070  cliInit(int fin, int fout, const char *prompt) Line 1109  cliInit(int fin, int fout, const char *prompt)
         }          }
         /* alt+chars */          /* alt+chars */
         for (i = 256; i < 512; i++) {          for (i = 256; i < 512; i++) {
                keys[i].key_ch[0] = 0x1b;                keys[i].key_ch[0] = inkeys[i].key_ch[0] = 0x1b;
                keys[i].key_ch[1] = (u_char) i - 256;                keys[i].key_ch[1] = inkeys[i].key_ch[1] = (u_char) i - 256;
                keys[i].key_len = 2;                keys[i].key_len = inkeys[i].key_len = 2;
         }          }
   
         /* 3 bytes */          /* 3 bytes */
        keys[i].key_len = sizeof K_F1 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F1 - 1;
         memcpy(keys[i].key_ch, K_F1, keys[i].key_len);          memcpy(keys[i].key_ch, K_F1, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F1, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F2 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F2 - 1;
         memcpy(keys[i].key_ch, K_F2, keys[i].key_len);          memcpy(keys[i].key_ch, K_F2, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F2, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F3 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F3 - 1;
         memcpy(keys[i].key_ch, K_F3, keys[i].key_len);          memcpy(keys[i].key_ch, K_F3, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F3, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F4 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F4 - 1;
         memcpy(keys[i].key_ch, K_F4, keys[i].key_len);          memcpy(keys[i].key_ch, K_F4, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F4, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F1 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F1 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F1, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F1, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F1, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F2 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F2 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F2, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F2, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F2, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F3 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F3 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F3, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F3, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F3, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F4 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F4 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F4, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F4, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F4, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F5 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F5 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F5, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F5, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F5, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F6 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F6 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F6, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F6, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F6, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F7 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F7 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F7, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F7, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F7, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F8 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F8 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F8, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F8, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F8, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F9 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F9 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F9, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F9, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F9, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F10 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F10 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F10, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F10, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F10, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F11 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F11 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F11, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F11, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F11, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_SH_F12 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_SH_F12 - 1;
         memcpy(keys[i].key_ch, K_CTRL_SH_F12, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_SH_F12, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_SH_F12, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F1 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F1 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F1, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F1, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F1, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F2 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F2 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F2, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F2, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F2, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F3 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F3 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F3, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F3, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F3, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F4 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F4 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F4, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F4, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F4, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F5 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F5 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F5, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F5, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F5, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F6 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F6 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F6, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F6, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F6, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F7 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F7 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F7, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F7, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F7, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F8 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F8 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F8, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F8, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F8, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F9 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F9 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F9, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F9, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F9, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F10 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F10 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F10, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F10, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F10, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F11 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F11 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F11, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F11, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F11, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_CTRL_F12 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_CTRL_F12 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F12, keys[i].key_len);          memcpy(keys[i].key_ch, K_CTRL_F12, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_CTRL_F12, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_HOME - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_HOME - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufBEGIN;                  keys[i].key_func = bufBEGIN;
         memcpy(keys[i].key_ch, K_HOME, keys[i].key_len);          memcpy(keys[i].key_ch, K_HOME, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_HOME, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_END - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_END - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufEND;                  keys[i].key_func = bufEND;
         memcpy(keys[i].key_ch, K_END, keys[i].key_len);          memcpy(keys[i].key_ch, K_END, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_END, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_UP - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_UP - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufUP;                  keys[i].key_func = bufUP;
         memcpy(keys[i].key_ch, K_UP, keys[i].key_len);          memcpy(keys[i].key_ch, K_UP, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_UP, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_DOWN - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_DOWN - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufDOWN;                  keys[i].key_func = bufDOWN;
         memcpy(keys[i].key_ch, K_DOWN, keys[i].key_len);          memcpy(keys[i].key_ch, K_DOWN, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_DOWN, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_RIGHT - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_RIGHT - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufRIGHT;                  keys[i].key_func = bufRIGHT;
         memcpy(keys[i].key_ch, K_RIGHT, keys[i].key_len);          memcpy(keys[i].key_ch, K_RIGHT, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_RIGHT, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_LEFT - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_LEFT - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufLEFT;                  keys[i].key_func = bufLEFT;
         memcpy(keys[i].key_ch, K_LEFT, keys[i].key_len);          memcpy(keys[i].key_ch, K_LEFT, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_LEFT, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_BTAB - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_BTAB - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufBTAB;                  keys[i].key_func = bufBTAB;
         memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);          memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_BTAB, inkeys[i].key_len);
         i++;          i++;
         /* 4 bytes */          /* 4 bytes */
        keys[i].key_len = sizeof K_INS - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_INS - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufMODE;                  keys[i].key_func = bufMODE;
         memcpy(keys[i].key_ch, K_INS, keys[i].key_len);          memcpy(keys[i].key_ch, K_INS, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_INS, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_DEL - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_DEL - 1;
         if (cli_buffer->line_prompt)          if (cli_buffer->line_prompt)
                 keys[i].key_func = bufDEL;                  keys[i].key_func = bufDEL;
         memcpy(keys[i].key_ch, K_DEL, keys[i].key_len);          memcpy(keys[i].key_ch, K_DEL, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_DEL, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_PGUP - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_PGUP - 1;
         memcpy(keys[i].key_ch, K_PGUP, keys[i].key_len);          memcpy(keys[i].key_ch, K_PGUP, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_PGUP, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_PGDN - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_PGDN - 1;
         memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);          memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_PGDN, inkeys[i].key_len);
         i++;          i++;
         /* 5 bytes */          /* 5 bytes */
        keys[i].key_len = sizeof K_F5 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F5 - 1;
         memcpy(keys[i].key_ch, K_F5, keys[i].key_len);          memcpy(keys[i].key_ch, K_F5, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F5, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F6 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F6 - 1;
         memcpy(keys[i].key_ch, K_F6, keys[i].key_len);          memcpy(keys[i].key_ch, K_F6, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F6, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F7 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F7 - 1;
         memcpy(keys[i].key_ch, K_F7, keys[i].key_len);          memcpy(keys[i].key_ch, K_F7, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F7, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F8 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F8 - 1;
         memcpy(keys[i].key_ch, K_F8, keys[i].key_len);          memcpy(keys[i].key_ch, K_F8, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F8, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F9 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F9 - 1;
         memcpy(keys[i].key_ch, K_F9, keys[i].key_len);          memcpy(keys[i].key_ch, K_F9, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F9, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F10 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F10 - 1;
         memcpy(keys[i].key_ch, K_F10, keys[i].key_len);          memcpy(keys[i].key_ch, K_F10, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F10, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F11 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F11 - 1;
         memcpy(keys[i].key_ch, K_F11, keys[i].key_len);          memcpy(keys[i].key_ch, K_F11, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F11, inkeys[i].key_len);
         i++;          i++;
        keys[i].key_len = sizeof K_F12 - 1;        keys[i].key_len = inkeys[i].key_len = sizeof K_F12 - 1;
         memcpy(keys[i].key_ch, K_F12, keys[i].key_len);          memcpy(keys[i].key_ch, K_F12, keys[i].key_len);
           memcpy(inkeys[i].key_ch, K_F12, inkeys[i].key_len);
         i++;          i++;
   
         cli_buffer->line_keys = keys;          cli_buffer->line_keys = keys;
           cli_buffer->line_inkeys = inkeys;
         return cli_buffer;          return cli_buffer;
 }  }
   
 /*  /*
 * cliInitLine() - Init CLI input line terminal * cliSetLine() - Set CLI input line terminal
  *   *
  * @cli_buffer = CLI buffer   * @cli_buffer = CLI buffer
 * return: none * @old = Old terminal settings
  * return: -1 error or 0 ok
 */  */
 int  int
cliInitLine(linebuffer_t * __restrict cli_buffer)cliSetLine(linebuffer_t * __restrict cli_buffer, struct termios * __restrict old)
 {  {
         struct termios t;          struct termios t;
   
         memset(&t, 0, sizeof t);          memset(&t, 0, sizeof t);
         tcgetattr(cli_buffer->line_in, &t);          tcgetattr(cli_buffer->line_in, &t);
           if (old)
                   memcpy(old, &t, sizeof(struct termios));
         t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO |           t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | 
                         ECHOCTL | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT);                          ECHOCTL | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT);
         t.c_iflag |= IGNBRK;          t.c_iflag |= IGNBRK;
Line 1264  cliInitLine(linebuffer_t * __restrict cli_buffer) Line 1354  cliInitLine(linebuffer_t * __restrict cli_buffer)
 }  }
   
 /*  /*
    * cliResetLine() - Reset CLI input line terminal
    *
    * @cli_buffer = CLI buffer
    * @old = Original terminal settings
    * return: -1 error or 0 ok
   */
   int
   cliResetLine(linebuffer_t * __restrict cli_buffer, struct termios * __restrict orig)
   {
           return tcsetattr(cli_buffer->line_in, TCSANOW, orig);
   }
   
   /*
    * cliEcho() - Switch echo on or off
    *
    * @cli_buffer = CLI buffer
    * @on = On or off for echo on input handler
    * return: -1 error or 0 ok
   */
   int
   cliEcho(linebuffer_t * __restrict cli_buffer, int on)
   {
           struct termios t;
   
           if (tcgetattr(cli_buffer->line_in, &t) == -1) {
                   cli_SetErr(errno, "tcgetattr(%d) - %s", cli_buffer->line_in, strerror(errno));
                   return -1;
           }
   
           if (on)
                   t.c_lflag |= (ECHO);
           else
                   t.c_lflag &= ~(ECHO);
   
           return tcsetattr(cli_buffer->line_in, TCSANOW, &t);
   }
   
   /*
  * cliReadLine() - Read line from opened CLI session   * cliReadLine() - Read line from opened CLI session
  *   *
  * @cli_buffer = CLI buffer   * @cli_buffer = CLI buffer
Line 1460  cliNetLoop(linebuffer_t * __restrict cli_buffer, const Line 1588  cliNetLoop(linebuffer_t * __restrict cli_buffer, const
 }  }
   
 /*  /*
    * cliRun() - CLI run command line
    *
    * @cli_buffer = CLI buffer
    * @psInput = Input command line
    * @prompt = Display prompt after command
    * return: RETCODE_ERR error, RETCODE_OK ok
   */
   int
   cliRun(linebuffer_t * __restrict cli_buffer, char *psInput, int prompt)
   {
           char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
           int ret = RETCODE_OK;
           struct tagCommand *cmd;
   
           if (!psInput)
                   return RETCODE_ERR;
           else
                   line = psInput;
   
           // clear whitespaces
           for (s = line; isspace((int) *s); s++);
           if (*s) {
                   for (t = s + strlen(s) - 1; t > s && isspace((int) *t); t--);
                   *++t = 0;
           }
   
           if (*s) {
                   memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS);
                   for (app = items; app < items + MAX_PROMPT_ITEMS - 1 && 
                                   (*app = strsep(&s, " \t")); *app ? app++ : app);
   
                   // exec_cmd ...
                   SLIST_FOREACH(cmd, &cli_buffer->line_cmds, cmd_next) {
                           if (!(cmd->cmd_level & (1 << cli_buffer->line_level)))
                                   continue;
                           if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))
                                   break;
                   }
   
                   if (!cmd) {
                           cli_Printf(cli_buffer, "%sCommand '%s' not found!\n", 
                                           cli_buffer->line_prompt ? "\n" : "", items[0]);
                           ret = RETCODE_ERR;
                   } else
                           if (cmd->cmd_func) {
                                   if (prompt && cli_buffer->line_prompt)
                                           cli_Printf(cli_buffer, "\n");
                                   ret = cmd->cmd_func(cli_buffer, 
                                                   cli_buffer->line_level, items);
                           } else if (prompt) {
                                   clrscrEOL(cli_buffer);
                                   printfCR(cli_buffer, 1);
                           }
           }
   
           return ret;
   }
   
   /*
  * cliLoop() - CLI main loop   * cliLoop() - CLI main loop
  *   *
  * @cli_buffer = CLI buffer   * @cli_buffer = CLI buffer
Line 1470  cliNetLoop(linebuffer_t * __restrict cli_buffer, const Line 1657  cliNetLoop(linebuffer_t * __restrict cli_buffer, const
 int  int
 cliLoop(linebuffer_t * __restrict cli_buffer, const char *csHistFile, int timeout)  cliLoop(linebuffer_t * __restrict cli_buffer, const char *csHistFile, int timeout)
 {  {
        char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];        char *line;
        register int i; 
         int ret = RETCODE_OK;          int ret = RETCODE_OK;
        struct tagCommand *cmd;        struct termios t;
   
         /* --- main body of CLI --- */          /* --- main body of CLI --- */
        cliInitLine(cli_buffer);        cliSetLine(cli_buffer, &t);
   
         if (cli_loadHistory(cli_buffer, csHistFile) == RETCODE_ERR)          if (cli_loadHistory(cli_buffer, csHistFile) == RETCODE_ERR)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 1488  cliLoop(linebuffer_t * __restrict cli_buffer, const ch Line 1674  cliLoop(linebuffer_t * __restrict cli_buffer, const ch
                         break;                          break;
                 } else                  } else
                         cli_addHistory(cli_buffer, NULL);                          cli_addHistory(cli_buffer, NULL);
                 // clear whitespaces  
                 for (s = line; isspace((int) *s); s++);  
                 if (*s) {  
                         for (t = s + strlen(s) - 1; t > s && isspace((int) *t); t--);  
                         *++t = 0;  
                 }  
   
                if (*s) {                ret = cliRun(cli_buffer, line, 42);
                        memset(items, 0, sizeof(char*) * MAX_PROMPT_ITEMS); 
                        for (app = items; app < items + MAX_PROMPT_ITEMS - 1 &&  
                                        (*app = strsep(&s, " \t")); *app ? app++ : app); 
   
                         // exec_cmd ...  
                         i = 0;  
                         SLIST_FOREACH(cmd, &cli_buffer->line_cmds, cmd_next) {  
                                 if (!(cmd->cmd_level & (1 << cli_buffer->line_level)))  
                                         continue;  
                                 if (*items[0] && !strncmp(cmd->cmd_name, items[0], strlen(items[0])))  
                                         break;  
                                 else  
                                         i++;  
                         }  
   
                         if (!cmd) {  
                                 cli_Printf(cli_buffer, "%sCommand '%s' not found!\n",   
                                                 cli_buffer->line_prompt ? "\n" : "", items[0]);  
                                 ret = -1;  
                         } else  
                                 if (cmd->cmd_func) {  
                                         if (cli_buffer->line_prompt)  
                                                 cli_Printf(cli_buffer, "\n");  
                                         ret = cmd->cmd_func(cli_buffer,   
                                                         cli_buffer->line_level, items);  
                                 } else {  
                                         clrscrEOL(cli_buffer);  
                                         printfCR(cli_buffer, 1);  
                                 }  
                 }  
   
                 cli_freeLine(cli_buffer);                  cli_freeLine(cli_buffer);
                 cli_resetHistory(cli_buffer);                  cli_resetHistory(cli_buffer);
                 e_free(line);                  e_free(line);
        } while (cli_buffer->line_kill || ret < 1);        } while (!cli_buffer->line_kill);
   
         cli_saveHistory(cli_buffer, csHistFile, HISTORY_LINES);          cli_saveHistory(cli_buffer, csHistFile, HISTORY_LINES);
   
           /* --- restore tty --- */
           cliResetLine(cli_buffer, &t);
   
         return ret;          return ret;
 }  }
Removed from v.1.15  
changed lines
  Added in v.1.21.2.2

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