shell/cmdedit.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Termios command line History and Editting.
   4  *
   5  * Copyright (c) 1986-2001 may safely be consumed by a BSD or GPL license.
   6  * Written by:   Vladimir Oleynik <vodz@usa.net>
   7  *
   8  * Used ideas:
   9  *      Adam Rogoyski    <rogoyski@cs.utexas.edu>
  10  *      Dave Cinege      <dcinege@psychosis.com>
  11  *      Jakub Jelinek (c) 1995
  12  *      Erik Andersen    <andersee@debian.org> (Majorly adjusted for busybox)
  13  *
  14  * This code is 'as is' with no warranty.
  15  *
  16  *
  17  */
  18
  19 /*
  20    Usage and Known bugs:
  21    Terminal key codes are not extensive, and more will probably
  22    need to be added. This version was created on Debian GNU/Linux 2.x.
  23    Delete, Backspace, Home, End, and the arrow keys were tested
  24    to work in an Xterm and console. Ctrl-A also works as Home.
  25    Ctrl-E also works as End.
  26
  27    Small bugs (simple effect):
  28    - not true viewing if terminal size (x*y symbols) less
  29      size (prompt + editor`s line + 2 symbols)
  30    - not true viewing if length prompt less terminal width
  31  */
  32
  33
  34 #include <stdio.h>
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <sys/ioctl.h>
  40 #include <ctype.h>
  41 #include <signal.h>
  42 #include <limits.h>
  43
  44 #include "busybox.h"
  45
  46 #ifdef BB_LOCALE_SUPPORT
  47 #define Isprint(c) isprint((c))
  48 #else
  49 #define Isprint(c) ( (c) >= ' ' && (c) != ((unsigned char)'\233') )
  50 #endif
  51
  52 #ifndef TEST
  53
  54 #define D(x)
  55
  56 #else
  57
  58 #define BB_FEATURE_COMMAND_EDITING
  59 #define BB_FEATURE_COMMAND_TAB_COMPLETION
  60 #define BB_FEATURE_COMMAND_USERNAME_COMPLETION
  61 #define BB_FEATURE_NONPRINTABLE_INVERSE_PUT
  62 #define BB_FEATURE_CLEAN_UP
  63
  64 #define D(x)  x
  65
  66 #endif                                                  /* TEST */
  67
  68 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
  69 #include <dirent.h>
  70 #include <sys/stat.h>
  71 #endif
  72
  73 #ifdef BB_FEATURE_COMMAND_EDITING
  74
  75 #ifndef BB_FEATURE_COMMAND_TAB_COMPLETION
  76 #undef  BB_FEATURE_COMMAND_USERNAME_COMPLETION
  77 #endif
  78
  79 #if defined(BB_FEATURE_COMMAND_USERNAME_COMPLETION) || defined(BB_FEATURE_SH_FANCY_PROMPT)
  80 #define BB_FEATURE_GETUSERNAME_AND_HOMEDIR
  81 #endif
  82
  83 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
  84 #       ifndef TEST
  85 #               include "pwd_grp/pwd.h"
  86 #       else
  87 #               include <pwd.h>
  88 #       endif  /* TEST */
  89 #endif                                                  /* advanced FEATURES */
  90
  91
  92
  93 struct history {
  94         char *s;
  95         struct history *p;
  96         struct history *n;
  97 };
  98
  99 /* Maximum length of the linked list for the command line history */
 100 static const int MAX_HISTORY = 15;
 101
 102 /* First element in command line list */
 103 static struct history *his_front = NULL;
 104
 105 /* Last element in command line list */
 106 static struct history *his_end = NULL;
 107
 108
 109 #include <termios.h>
 110 #define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp)
 111 #define getTermSettings(fd,argp) tcgetattr(fd, argp);
 112
 113 /* Current termio and the previous termio before starting sh */
 114 static struct termios initial_settings, new_settings;
 115
 116
 117 static
 118 volatile int cmdedit_termw = 80;        /* actual terminal width */
 119 static int history_counter = 0; /* Number of commands in history list */
 120 static
 121 volatile int handlers_sets = 0; /* Set next bites: */
 122
 123 enum {
 124         SET_ATEXIT = 1,         /* when atexit() has been called
 125                                    and get euid,uid,gid to fast compare */
 126         SET_TERM_HANDLERS = 2,  /* set many terminates signal handlers */
 127         SET_WCHG_HANDLERS = 4,  /* winchg signal handler */
 128         SET_RESET_TERM = 8,     /* if the terminal needs to be reset upon exit */
 129 };
 130
 131
 132 static int cmdedit_x;           /* real x terminal position */
 133 static int cmdedit_y;           /* pseudoreal y terminal position */
 134 static int cmdedit_prmt_len;    /* lenght prompt without colores string */
 135
 136 static int cursor;              /* required global for signal handler */
 137 static int len;                 /* --- "" - - "" - -"- --""-- --""--- */
 138 static char *command_ps;        /* --- "" - - "" - -"- --""-- --""--- */
 139 static
 140 #ifndef BB_FEATURE_SH_FANCY_PROMPT
 141         const
 142 #endif
 143 char *cmdedit_prompt;           /* --- "" - - "" - -"- --""-- --""--- */
 144
 145 /* Link into lash to reset context to 0 on ^C and such */
 146 extern unsigned int shell_context;
 147
 148
 149 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
 150 static char *user_buf = "";
 151 static char *home_pwd_buf = "";
 152 static int my_euid;
 153 #endif
 154
 155 #ifdef BB_FEATURE_SH_FANCY_PROMPT
 156 static char *hostname_buf = "";
 157 static int num_ok_lines = 1;
 158 #endif
 159
 160
 161 #ifdef  BB_FEATURE_COMMAND_TAB_COMPLETION
 162
 163 #ifndef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
 164 static int my_euid;
 165 #endif
 166
 167 static int my_uid;
 168 static int my_gid;
 169
 170 #endif  /* BB_FEATURE_COMMAND_TAB_COMPLETION */
 171
 172
 173 static void cmdedit_setwidth(int w, int redraw_flg);
 174
 175 static void win_changed(int nsig)
 176 {
 177         struct winsize win = { 0, 0, 0, 0 };
 178         static __sighandler_t previous_SIGWINCH_handler;        /* for reset */
 179
 180         /*   emulate      || signal call */
 181         if (nsig == -SIGWINCH || nsig == SIGWINCH) {
 182                 ioctl(0, TIOCGWINSZ, &win);
 183                 if (win.ws_col > 0) {
 184                         cmdedit_setwidth(win.ws_col, nsig == SIGWINCH);
 185                 }
 186         }
 187         /* Unix not all standart in recall signal */
 188
 189         if (nsig == -SIGWINCH)          /* save previous handler   */
 190                 previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
 191         else if (nsig == SIGWINCH)      /* signaled called handler */
 192                 signal(SIGWINCH, win_changed);  /* set for next call       */
 193         else                                            /* nsig == 0 */
 194                 /* set previous handler    */
 195                 signal(SIGWINCH, previous_SIGWINCH_handler);    /* reset    */
 196 }
 197
 198 static void cmdedit_reset_term(void)
 199 {
 200         if ((handlers_sets & SET_RESET_TERM) != 0) {
 201 /* sparc and other have broken termios support: use old termio handling. */
 202                 setTermSettings(fileno(stdin), (void *) &initial_settings);
 203                 handlers_sets &= ~SET_RESET_TERM;
 204         }
 205         if ((handlers_sets & SET_WCHG_HANDLERS) != 0) {
 206                 /* reset SIGWINCH handler to previous (default) */
 207                 win_changed(0);
 208                 handlers_sets &= ~SET_WCHG_HANDLERS;
 209         }
 210         fflush(stdout);
 211 #ifdef BB_FEATURE_CLEAN_UP
 212         if (his_front) {
 213                 struct history *n;
 214
 215                 while (his_front != his_end) {
 216                         n = his_front->n;
 217                         free(his_front->s);
 218                         free(his_front);
 219                         his_front = n;
 220                 }
 221         }
 222 #endif
 223 }
 224
 225
 226 /* special for recount position for scroll and remove terminal margin effect */
 227 static void cmdedit_set_out_char(int next_char)
 228 {
 229
 230         int c = (int)((unsigned char) command_ps[cursor]);
 231
 232         if (c == 0)
 233                 c = ' ';        /* destroy end char? */
 234 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
 235         if (!Isprint(c)) {      /* Inverse put non-printable characters */
 236                 if (c >= 128)
 237                         c -= 128;
 238                 if (c < ' ')
 239                         c += '@';
 240                 if (c == 127)
 241                         c = '?';
 242                 printf("\033[7m%c\033[0m", c);
 243         } else
 244 #endif
 245                 putchar(c);
 246         if (++cmdedit_x >= cmdedit_termw) {
 247                 /* terminal is scrolled down */
 248                 cmdedit_y++;
 249                 cmdedit_x = 0;
 250
 251                 if (!next_char)
 252                         next_char = ' ';
 253                 /* destroy "(auto)margin" */
 254                 putchar(next_char);
 255                 putchar('\b');
 256         }
 257         cursor++;
 258 }
 259
 260 /* Move to end line. Bonus: rewrite line from cursor */
 261 static void input_end(void)
 262 {
 263         while (cursor < len)
 264                 cmdedit_set_out_char(0);
 265 }
 266
 267 /* Go to the next line */
 268 static void goto_new_line(void)
 269 {
 270         input_end();
 271         if (cmdedit_x)
 272                 putchar('\n');
 273 }
 274
 275
 276 static inline void out1str(const char *s)
 277 {
 278         fputs(s, stdout);
 279 }
 280 static inline void beep(void)
 281 {
 282         putchar('\007');
 283 }
 284
 285 /* Move back one charactor */
 286 /* special for slow terminal */
 287 static void input_backward(int num)
 288 {
 289         if (num > cursor)
 290                 num = cursor;
 291         cursor -= num;          /* new cursor (in command, not terminal) */
 292
 293         if (cmdedit_x >= num) {         /* no to up line */
 294                 cmdedit_x -= num;
 295                 if (num < 4)
 296                         while (num-- > 0)
 297                                 putchar('\b');
 298
 299                 else
 300                         printf("\033[%dD", num);
 301         } else {
 302                 int count_y;
 303
 304                 if (cmdedit_x) {
 305                         putchar('\r');          /* back to first terminal pos.  */
 306                         num -= cmdedit_x;       /* set previous backward        */
 307                 }
 308                 count_y = 1 + num / cmdedit_termw;
 309                 printf("\033[%dA", count_y);
 310                 cmdedit_y -= count_y;
 311                 /*  require  forward  after  uping   */
 312                 cmdedit_x = cmdedit_termw * count_y - num;
 313                 printf("\033[%dC", cmdedit_x);  /* set term cursor   */
 314         }
 315 }
 316
 317 static void put_prompt(void)
 318 {
 319         out1str(cmdedit_prompt);
 320         cmdedit_x = cmdedit_prmt_len;   /* count real x terminal position */
 321         cursor = 0;
 322 }
 323
 324 #ifndef BB_FEATURE_SH_FANCY_PROMPT
 325 static void parse_prompt(const char *prmt_ptr)
 326 {
 327         cmdedit_prompt = prmt_ptr;
 328         cmdedit_prmt_len = strlen(prmt_ptr);
 329         put_prompt();
 330 }
 331 #else
 332 static void parse_prompt(const char *prmt_ptr)
 333 {
 334         int prmt_len = 0;
 335         int sub_len = 0;
 336         char  flg_not_length = '[';
 337         char *prmt_mem_ptr = xcalloc(1, 1);
 338         char *pwd_buf = xgetcwd(0);
 339         char  buf2[PATH_MAX + 1];
 340         char  buf[2];
 341         char  c;
 342         char *pbuf;
 343
 344         if (!pwd_buf) {
 345                 pwd_buf=(char *)unknown;
 346         }
 347
 348         while (*prmt_ptr) {
 349                 pbuf    = buf;
 350                 pbuf[1] = 0;
 351                 c = *prmt_ptr++;
 352                 if (c == '\\') {
 353                         const char *cp = prmt_ptr;
 354                         int l;
 355
 356                         c = process_escape_sequence(&prmt_ptr);
 357                         if(prmt_ptr==cp) {
 358                           if (*cp == 0)
 359                                 break;
 360                           c = *prmt_ptr++;
 361                           switch (c) {
 362 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
 363                           case 'u':
 364                                 pbuf = user_buf;
 365                                 break;
 366 #endif
 367                           case 'h':
 368                                 pbuf = hostname_buf;
 369                                 if (*pbuf == 0) {
 370                                         pbuf = xcalloc(256, 1);
 371                                         if (gethostname(pbuf, 255) < 0) {
 372                                                 strcpy(pbuf, "?");
 373                                         } else {
 374                                                 char *s = strchr(pbuf, '.');
 375
 376                                                 if (s)
 377                                                         *s = 0;
 378                                         }
 379                                         hostname_buf = pbuf;
 380                                 }
 381                                 break;
 382                           case '$':
 383                                 c = my_euid == 0 ? '#' : '$';
 384                                 break;
 385 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
 386                           case 'w':
 387                                 pbuf = pwd_buf;
 388                                 l = strlen(home_pwd_buf);
 389                                 if (home_pwd_buf[0] != 0 &&
 390                                     strncmp(home_pwd_buf, pbuf, l) == 0 &&
 391                                     (pbuf[l]=='/' || pbuf[l]=='\0') &&
 392                                     strlen(pwd_buf+l)<PATH_MAX) {
 393                                         pbuf = buf2;
 394                                         *pbuf = '~';
 395                                         strcpy(pbuf+1, pwd_buf+l);
 396                                         }
 397                                 break;
 398 #endif
 399                           case 'W':
 400                                 pbuf = pwd_buf;
 401                                 cp = strrchr(pbuf,'/');
 402                                 if ( (cp != NULL) && (cp != pbuf) )
 403                                         pbuf += (cp-pbuf)+1;
 404                                 break;
 405                           case '!':
 406                                 snprintf(pbuf = buf2, sizeof(buf2), "%d", num_ok_lines);
 407                                 break;
 408                           case 'e': case 'E':     /* \e \E = \033 */
 409                                 c = '\033';
 410                                 break;
 411                           case 'x': case 'X':
 412                                 for (l = 0; l < 3;) {
 413                                         int h;
 414                                         buf2[l++] = *prmt_ptr;
 415                                         buf2[l] = 0;
 416                                         h = strtol(buf2, &pbuf, 16);
 417                                         if (h > UCHAR_MAX || (pbuf - buf2) < l) {
 418                                                 l--;
 419                                                 break;
 420                                         }
 421                                         prmt_ptr++;
 422                                 }
 423                                 buf2[l] = 0;
 424                                 c = (char)strtol(buf2, 0, 16);
 425                                 if(c==0)
 426                                         c = '?';
 427                                 pbuf = buf;
 428                                 break;
 429                           case '[': case ']':
 430                                 if (c == flg_not_length) {
 431                                         flg_not_length = flg_not_length == '[' ? ']' : '[';
 432                                         continue;
 433                                 }
 434                                 break;
 435                           }
 436                         }
 437                 }
 438                 if(pbuf == buf)
 439                         *pbuf = c;
 440                 prmt_len += strlen(pbuf);
 441                 prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
 442                 if (flg_not_length == ']')
 443                         sub_len++;
 444         }
 445         if(pwd_buf!=(char *)unknown)
 446                 free(pwd_buf);
 447         cmdedit_prompt = prmt_mem_ptr;
 448         cmdedit_prmt_len = prmt_len - sub_len;
 449         put_prompt();
 450 }
 451 #endif
 452
 453
 454 /* draw promt, editor line, and clear tail */
 455 static void redraw(int y, int back_cursor)
 456 {
 457         if (y > 0)                              /* up to start y */
 458                 printf("\033[%dA", y);
 459         cmdedit_y = 0;                          /* new quasireal y */
 460         putchar('\r');
 461         put_prompt();
 462         input_end();                            /* rewrite */
 463         printf("\033[J");                       /* destroy tail after cursor */
 464         input_backward(back_cursor);
 465 }
 466
 467 /* Delete the char in front of the cursor */
 468 static void input_delete(void)
 469 {
 470         int j = cursor;
 471
 472         if (j == len)
 473                 return;
 474
 475         strcpy(command_ps + j, command_ps + j + 1);
 476         len--;
 477         input_end();                    /* rewtite new line */
 478         cmdedit_set_out_char(0);        /* destroy end char */
 479         input_backward(cursor - j);     /* back to old pos cursor */
 480 }
 481
 482 /* Delete the char in back of the cursor */
 483 static void input_backspace(void)
 484 {
 485         if (cursor > 0) {
 486                 input_backward(1);
 487                 input_delete();
 488         }
 489 }
 490
 491
 492 /* Move forward one charactor */
 493 static void input_forward(void)
 494 {
 495         if (cursor < len)
 496                 cmdedit_set_out_char(command_ps[cursor + 1]);
 497 }
 498
 499
 500 static void clean_up_and_die(int sig)
 501 {
 502         goto_new_line();
 503         if (sig != SIGINT)
 504                 exit(EXIT_SUCCESS);     /* cmdedit_reset_term() called in atexit */
 505         cmdedit_reset_term();
 506 }
 507
 508 static void cmdedit_setwidth(int w, int redraw_flg)
 509 {
 510         cmdedit_termw = cmdedit_prmt_len + 2;
 511         if (w <= cmdedit_termw) {
 512                 cmdedit_termw = cmdedit_termw % w;
 513         }
 514         if (w > cmdedit_termw) {
 515                 cmdedit_termw = w;
 516
 517                 if (redraw_flg) {
 518                         /* new y for current cursor */
 519                         int new_y = (cursor + cmdedit_prmt_len) / w;
 520
 521                         /* redraw */
 522                         redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), len - cursor);
 523                         fflush(stdout);
 524                 }
 525         }
 526 }
 527
 528 extern void cmdedit_init(void)
 529 {
 530         cmdedit_prmt_len = 0;
 531         if ((handlers_sets & SET_WCHG_HANDLERS) == 0) {
 532                 /* emulate usage handler to set handler and call yours work */
 533                 win_changed(-SIGWINCH);
 534                 handlers_sets |= SET_WCHG_HANDLERS;
 535         }
 536
 537         if ((handlers_sets & SET_ATEXIT) == 0) {
 538 #ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
 539                 struct passwd *entry;
 540
 541                 my_euid = geteuid();
 542                 entry = getpwuid(my_euid);
 543                 if (entry) {
 544                         user_buf = xstrdup(entry->pw_name);
 545                         home_pwd_buf = xstrdup(entry->pw_dir);
 546                 }
 547 #endif
 548
 549 #ifdef  BB_FEATURE_COMMAND_TAB_COMPLETION
 550
 551 #ifndef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
 552                 my_euid = geteuid();
 553 #endif
 554                 my_uid = getuid();
 555                 my_gid = getgid();
 556 #endif  /* BB_FEATURE_COMMAND_TAB_COMPLETION */
 557                 handlers_sets |= SET_ATEXIT;
 558                 atexit(cmdedit_reset_term);     /* be sure to do this only once */
 559         }
 560
 561         if ((handlers_sets & SET_TERM_HANDLERS) == 0) {
 562                 signal(SIGKILL, clean_up_and_die);
 563                 signal(SIGINT, clean_up_and_die);
 564                 signal(SIGQUIT, clean_up_and_die);
 565                 signal(SIGTERM, clean_up_and_die);
 566                 handlers_sets |= SET_TERM_HANDLERS;
 567         }
 568 }
 569
 570 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
 571
 572 static int is_execute(const struct stat *st)
 573 {
 574         if ((!my_euid && (st->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) ||
 575                 (my_uid == st->st_uid && (st->st_mode & S_IXUSR)) ||
 576                 (my_gid == st->st_gid && (st->st_mode & S_IXGRP)) ||
 577                 (st->st_mode & S_IXOTH)) return TRUE;
 578         return FALSE;
 579 }
 580
 581 #ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
 582
 583 static char **username_tab_completion(char *ud, int *num_matches)
 584 {
 585         struct passwd *entry;
 586         int userlen;
 587         char *temp;
 588
 589
 590         ud++;                           /* ~user/... to user/... */
 591         userlen = strlen(ud);
 592
 593         if (num_matches == 0) {         /* "~/..." or "~user/..." */
 594                 char *sav_ud = ud - 1;
 595                 char *home = 0;
 596
 597                 if (*ud == '/') {       /* "~/..."     */
 598                         home = home_pwd_buf;
 599                 } else {
 600                         /* "~user/..." */
 601                         temp = strchr(ud, '/');
 602                         *temp = 0;              /* ~user\0 */
 603                         entry = getpwnam(ud);
 604                         *temp = '/';            /* restore ~user/... */
 605                         ud = temp;
 606                         if (entry)
 607                                 home = entry->pw_dir;
 608                 }
 609                 if (home) {
 610                         if ((userlen + strlen(home) + 1) < BUFSIZ) {
 611                                 char temp2[BUFSIZ];     /* argument size */
 612
 613                                 /* /home/user/... */
 614                                 sprintf(temp2, "%s%s", home, ud);
 615                                 strcpy(sav_ud, temp2);
 616                         }
 617                 }
 618                 return 0;       /* void, result save to argument :-) */
 619         } else {
 620                 /* "~[^/]*" */
 621                 char **matches = (char **) NULL;
 622                 int nm = 0;
 623
 624                 setpwent();
 625
 626                 while ((entry = getpwent()) != NULL) {
 627                         /* Null usernames should result in all users as possible completions. */
 628                         if ( /*!userlen || */ !strncmp(ud, entry->pw_name, userlen)) {
 629
 630                                 temp = xmalloc(3 + strlen(entry->pw_name));
 631                                 sprintf(temp, "~%s/", entry->pw_name);
 632                                 matches = xrealloc(matches, (nm + 1) * sizeof(char *));
 633
 634                                 matches[nm++] = temp;
 635                         }
 636                 }
 637
 638                 endpwent();
 639                 (*num_matches) = nm;
 640                 return (matches);
 641         }
 642 }
 643 #endif  /* BB_FEATURE_COMMAND_USERNAME_COMPLETION */
 644
 645 enum {
 646         FIND_EXE_ONLY = 0,
 647         FIND_DIR_ONLY = 1,
 648         FIND_FILE_ONLY = 2,
 649 };
 650
 651 static int path_parse(char ***p, int flags)
 652 {
 653         int npth;
 654         char *tmp;
 655         char *pth;
 656
 657         /* if not setenv PATH variable, to search cur dir "." */
 658         if (flags != FIND_EXE_ONLY || (pth = getenv("PATH")) == 0 ||
 659                 /* PATH=<empty> or PATH=:<empty> */
 660                 *pth == 0 || (*pth == ':' && *(pth + 1) == 0)) {
 661                 return 1;
 662         }
 663
 664         tmp = pth;
 665         npth = 0;
 666
 667         for (;;) {
 668                 npth++;                 /* count words is + 1 count ':' */
 669                 tmp = strchr(tmp, ':');
 670                 if (tmp) {
 671                         if (*++tmp == 0)
 672                                 break;  /* :<empty> */
 673                 } else
 674                         break;
 675         }
 676
 677         *p = xmalloc(npth * sizeof(char *));
 678
 679         tmp = pth;
 680         (*p)[0] = xstrdup(tmp);
 681         npth = 1;                       /* count words is + 1 count ':' */
 682
 683         for (;;) {
 684                 tmp = strchr(tmp, ':');
 685                 if (tmp) {
 686                         (*p)[0][(tmp - pth)] = 0;       /* ':' -> '\0' */
 687                         if (*++tmp == 0)
 688                                 break;                  /* :<empty> */
 689                 } else
 690                         break;
 691                 (*p)[npth++] = &(*p)[0][(tmp - pth)];   /* p[next]=p[0][&'\0'+1] */
 692         }
 693
 694         return npth;
 695 }
 696
 697 static char *add_quote_for_spec_chars(char *found)
 698 {
 699         int l = 0;
 700         char *s = xmalloc((strlen(found) + 1) * 2);
 701
 702         while (*found) {
 703                 if (strchr(" `\"#$%^&*()=+{}[]:;\'|\\<>", *found))
 704                         s[l++] = '\\';
 705                 s[l++] = *found++;
 706         }
 707         s[l] = 0;
 708         return s;
 709 }
 710
 711 static char **exe_n_cwd_tab_completion(char *command, int *num_matches,
 712                                         int type)
 713 {
 714
 715         char **matches = 0;
 716         DIR *dir;
 717         struct dirent *next;
 718         char dirbuf[BUFSIZ];
 719         int nm = *num_matches;
 720         struct stat st;
 721         char *path1[1];
 722         char **paths = path1;
 723         int npaths;
 724         int i;
 725         char *found;
 726         char *pfind = strrchr(command, '/');
 727
 728         path1[0] = ".";
 729
 730         if (pfind == NULL) {
 731                 /* no dir, if flags==EXE_ONLY - get paths, else "." */
 732                 npaths = path_parse(&paths, type);
 733                 pfind = command;
 734         } else {
 735                 /* with dir */
 736                 /* save for change */
 737                 strcpy(dirbuf, command);
 738                 /* set dir only */
 739                 dirbuf[(pfind - command) + 1] = 0;
 740 #ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
 741                 if (dirbuf[0] == '~')   /* ~/... or ~user/... */
 742                         username_tab_completion(dirbuf, 0);
 743 #endif
 744                 /* "strip" dirname in command */
 745                 pfind++;
 746
 747                 paths[0] = dirbuf;
 748                 npaths = 1;                             /* only 1 dir */
 749         }
 750
 751         for (i = 0; i < npaths; i++) {
 752
 753                 dir = opendir(paths[i]);
 754                 if (!dir)                       /* Don't print an error */
 755                         continue;
 756
 757                 while ((next = readdir(dir)) != NULL) {
 758                         char *str_found = next->d_name;
 759
 760                         /* matched ? */
 761                         if (strncmp(str_found, pfind, strlen(pfind)))
 762                                 continue;
 763                         /* not see .name without .match */
 764                         if (*str_found == '.' && *pfind == 0) {
 765                                 if (*paths[i] == '/' && paths[i][1] == 0
 766                                         && str_found[1] == 0) str_found = "";   /* only "/" */
 767                                 else
 768                                         continue;
 769                         }
 770                         found = concat_path_file(paths[i], str_found);
 771                         /* hmm, remover in progress? */
 772                         if (stat(found, &st) < 0)
 773                                 goto cont;
 774                         /* find with dirs ? */
 775                         if (paths[i] != dirbuf)
 776                                 strcpy(found, next->d_name);    /* only name */
 777                         if (S_ISDIR(st.st_mode)) {
 778                                 /* name is directory      */
 779                                 str_found = found;
 780                                 found = concat_path_file(found, "");
 781                                 free(str_found);
 782                                 str_found = add_quote_for_spec_chars(found);
 783                         } else {
 784                                 /* not put found file if search only dirs for cd */
 785                                 if (type == FIND_DIR_ONLY)
 786                                         goto cont;
 787                                 str_found = add_quote_for_spec_chars(found);
 788                                 if (type == FIND_FILE_ONLY ||
 789                                         (type == FIND_EXE_ONLY && is_execute(&st) == TRUE))
 790                                         strcat(str_found, " ");
 791                         }
 792                         /* Add it to the list */
 793                         matches = xrealloc(matches, (nm + 1) * sizeof(char *));
 794
 795                         matches[nm++] = str_found;
 796 cont:
 797                         free(found);
 798                 }
 799                 closedir(dir);
 800         }
 801         if (paths != path1) {
 802                 free(paths[0]);                 /* allocated memory only in first member */
 803                 free(paths);
 804         }
 805         *num_matches = nm;
 806         return (matches);
 807 }
 808
 809 static int match_compare(const void *a, const void *b)
 810 {
 811         return strcmp(*(char **) a, *(char **) b);
 812 }
 813
 814
 815
 816 #define QUOT    (UCHAR_MAX+1)
 817
 818 #define collapse_pos(is, in) { \
 819         memcpy(int_buf+is, int_buf+in, (BUFSIZ+1-is-in)*sizeof(int)); \
 820         memcpy(pos_buf+is, pos_buf+in, (BUFSIZ+1-is-in)*sizeof(int)); }
 821
 822 static int find_match(char *matchBuf, int *len_with_quotes)
 823 {
 824         int i, j;
 825         int command_mode;
 826         int c, c2;
 827         int int_buf[BUFSIZ + 1];
 828         int pos_buf[BUFSIZ + 1];
 829
 830         /* set to integer dimension characters and own positions */
 831         for (i = 0;; i++) {
 832                 int_buf[i] = (int) ((unsigned char) matchBuf[i]);
 833                 if (int_buf[i] == 0) {
 834                         pos_buf[i] = -1;        /* indicator end line */
 835                         break;
 836                 } else
 837                         pos_buf[i] = i;
 838         }
 839
 840         /* mask \+symbol and convert '\t' to ' ' */
 841         for (i = j = 0; matchBuf[i]; i++, j++)
 842                 if (matchBuf[i] == '\\') {
 843                         collapse_pos(j, j + 1);
 844                         int_buf[j] |= QUOT;
 845                         i++;
 846 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
 847                         if (matchBuf[i] == '\t')        /* algorithm equivalent */
 848                                 int_buf[j] = ' ' | QUOT;
 849 #endif
 850                 }
 851 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
 852                 else if (matchBuf[i] == '\t')
 853                         int_buf[j] = ' ';
 854 #endif
 855
 856         /* mask "symbols" or 'symbols' */
 857         c2 = 0;
 858         for (i = 0; int_buf[i]; i++) {
 859                 c = int_buf[i];
 860                 if (c == '\'' || c == '"') {
 861                         if (c2 == 0)
 862                                 c2 = c;
 863                         else {
 864                                 if (c == c2)
 865                                         c2 = 0;
 866                                 else
 867                                         int_buf[i] |= QUOT;
 868                         }
 869                 } else if (c2 != 0 && c != '$')
 870                         int_buf[i] |= QUOT;
 871         }
 872
 873         /* skip commands with arguments if line have commands delimiters */
 874         /* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */
 875         for (i = 0; int_buf[i]; i++) {
 876                 c = int_buf[i];
 877                 c2 = int_buf[i + 1];
 878                 j = i ? int_buf[i - 1] : -1;
 879                 command_mode = 0;
 880                 if (c == ';' || c == '&' || c == '|') {
 881                         command_mode = 1 + (c == c2);
 882                         if (c == '&') {
 883                                 if (j == '>' || j == '<')
 884                                         command_mode = 0;
 885                         } else if (c == '|' && j == '>')
 886                                 command_mode = 0;
 887                 }
 888                 if (command_mode) {
 889                         collapse_pos(0, i + command_mode);
 890                         i = -1;                         /* hack incremet */
 891                 }
 892         }
 893         /* collapse `command...` */
 894         for (i = 0; int_buf[i]; i++)
 895                 if (int_buf[i] == '`') {
 896                         for (j = i + 1; int_buf[j]; j++)
 897                                 if (int_buf[j] == '`') {
 898                                         collapse_pos(i, j + 1);
 899                                         j = 0;
 900                                         break;
 901                                 }
 902                         if (j) {
 903                                 /* not found close ` - command mode, collapse all previous */
 904                                 collapse_pos(0, i + 1);
 905                                 break;
 906                         } else
 907                                 i--;                    /* hack incremet */
 908                 }
 909
 910         /* collapse (command...(command...)...) or {command...{command...}...} */
 911         c = 0;                                          /* "recursive" level */
 912         c2 = 0;
 913         for (i = 0; int_buf[i]; i++)
 914                 if (int_buf[i] == '(' || int_buf[i] == '{') {
 915                         if (int_buf[i] == '(')
 916                                 c++;
 917                         else
 918                                 c2++;
 919                         collapse_pos(0, i + 1);
 920                         i = -1;                         /* hack incremet */
 921                 }
 922         for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++)
 923                 if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) {
 924                         if (int_buf[i] == ')')
 925                                 c--;
 926                         else
 927                                 c2--;
 928                         collapse_pos(0, i + 1);
 929                         i = -1;                         /* hack incremet */
 930                 }
 931
 932         /* skip first not quote space */
 933         for (i = 0; int_buf[i]; i++)
 934                 if (int_buf[i] != ' ')
 935                         break;
 936         if (i)
 937                 collapse_pos(0, i);
 938
 939         /* set find mode for completion */
 940         command_mode = FIND_EXE_ONLY;
 941         for (i = 0; int_buf[i]; i++)
 942                 if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') {
 943                         if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY
 944                                 && matchBuf[pos_buf[0]]=='c'
 945                                 && matchBuf[pos_buf[1]]=='d' )
 946                                 command_mode = FIND_DIR_ONLY;
 947                         else {
 948                                 command_mode = FIND_FILE_ONLY;
 949                                 break;
 950                         }
 951                 }
 952         /* "strlen" */
 953         for (i = 0; int_buf[i]; i++);
 954         /* find last word */
 955         for (--i; i >= 0; i--) {
 956                 c = int_buf[i];
 957                 if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') {
 958                         collapse_pos(0, i + 1);
 959                         break;
 960                 }
 961         }
 962         /* skip first not quoted '\'' or '"' */
 963         for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++);
 964         /* collapse quote or unquote // or /~ */
 965         while ((int_buf[i] & ~QUOT) == '/' &&
 966                         ((int_buf[i + 1] & ~QUOT) == '/'
 967                          || (int_buf[i + 1] & ~QUOT) == '~')) {
 968                 i++;
 969         }
 970
 971         /* set only match and destroy quotes */
 972         j = 0;
 973         for (c = 0; pos_buf[i] >= 0; i++) {
 974                 matchBuf[c++] = matchBuf[pos_buf[i]];
 975                 j = pos_buf[i] + 1;
 976         }
 977         matchBuf[c] = 0;
 978         /* old lenght matchBuf with quotes symbols */
 979         *len_with_quotes = j ? j - pos_buf[0] : 0;
 980
 981         return command_mode;
 982 }
 983
 984
 985 static void input_tab(int *lastWasTab)
 986 {
 987         /* Do TAB completion */
 988         static int num_matches;
 989         static char **matches;
 990
 991         if (lastWasTab == 0) {          /* free all memory */
 992                 if (matches) {
 993                         while (num_matches > 0)
 994                                 free(matches[--num_matches]);
 995                         free(matches);
 996                         matches = (char **) NULL;
 997                 }
 998                 return;
 999         }
1000         if (*lastWasTab == FALSE) {
1001
1002                 char *tmp;
1003                 int len_found;
1004                 char matchBuf[BUFSIZ];
1005                 int find_type;
1006                 int recalc_pos;
1007
1008                 *lastWasTab = TRUE;             /* flop trigger */
1009
1010                 /* Make a local copy of the string -- up
1011                  * to the position of the cursor */
1012                 tmp = strncpy(matchBuf, command_ps, cursor);
1013                 tmp[cursor] = 0;
1014
1015                 find_type = find_match(matchBuf, &recalc_pos);
1016
1017                 /* Free up any memory already allocated */
1018                 input_tab(0);
1019
1020 #ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
1021                 /* If the word starts with `~' and there is no slash in the word,
1022                  * then try completing this word as a username. */
1023
1024                 if (matchBuf[0] == '~' && strchr(matchBuf, '/') == 0)
1025                         matches = username_tab_completion(matchBuf, &num_matches);
1026 #endif
1027                 /* Try to match any executable in our path and everything
1028                  * in the current working directory that matches.  */
1029                 if (!matches)
1030                         matches =
1031                                 exe_n_cwd_tab_completion(matchBuf,
1032                                         &num_matches, find_type);
1033                 /* Remove duplicate found */
1034                 if(matches) {
1035                         int i, j;
1036                         /* bubble */
1037                         for(i=0; i<(num_matches-1); i++)
1038                                 for(j=i+1; j<num_matches; j++)
1039                                         if(matches[i]!=0 && matches[j]!=0 &&
1040                                                 strcmp(matches[i], matches[j])==0) {
1041                                                         free(matches[j]);
1042                                                         matches[j]=0;
1043                                         }
1044                         j=num_matches;
1045                         num_matches = 0;
1046                         for(i=0; i<j; i++)
1047                                 if(matches[i]) {
1048                                         if(!strcmp(matches[i], "./"))
1049                                                 matches[i][1]=0;
1050                                         else if(!strcmp(matches[i], "../"))
1051                                                 matches[i][2]=0;
1052                                         matches[num_matches++]=matches[i];
1053                                 }
1054                 }
1055                 /* Did we find exactly one match? */
1056                 if (!matches || num_matches > 1) {
1057                         char *tmp1;
1058
1059                         beep();
1060                         if (!matches)
1061                                 return;         /* not found */
1062                         /* sort */
1063                         qsort(matches, num_matches, sizeof(char *), match_compare);
1064
1065                         /* find minimal match */
1066                         tmp = xstrdup(matches[0]);
1067                         for (tmp1 = tmp; *tmp1; tmp1++)
1068                                 for (len_found = 1; len_found < num_matches; len_found++)
1069                                         if (matches[len_found][(tmp1 - tmp)] != *tmp1) {
1070                                                 *tmp1 = 0;
1071                                                 break;
1072                                         }
1073                         if (*tmp == 0) {        /* have unique */
1074                                 free(tmp);
1075                                 return;
1076                         }
1077                 } else {                        /* one match */
1078                         tmp = matches[0];
1079                         /* for next completion current found */
1080                         *lastWasTab = FALSE;
1081                 }
1082
1083                 len_found = strlen(tmp);
1084                 /* have space to placed match? */
1085                 if ((len_found - strlen(matchBuf) + len) < BUFSIZ) {
1086
1087                         /* before word for match   */
1088                         command_ps[cursor - recalc_pos] = 0;
1089                         /* save   tail line        */
1090                         strcpy(matchBuf, command_ps + cursor);
1091                         /* add    match            */
1092                         strcat(command_ps, tmp);
1093                         /* add    tail             */
1094                         strcat(command_ps, matchBuf);
1095                         /* back to begin word for match    */
1096                         input_backward(recalc_pos);
1097                         /* new pos                         */
1098                         recalc_pos = cursor + len_found;
1099                         /* new len                         */
1100                         len = strlen(command_ps);
1101                         /* write out the matched command   */
1102                         redraw(cmdedit_y, len - recalc_pos);
1103                 }
1104                 if (tmp != matches[0])
1105                         free(tmp);
1106         } else {
1107                 /* Ok -- the last char was a TAB.  Since they
1108                  * just hit TAB again, print a list of all the
1109                  * available choices... */
1110                 if (matches && num_matches > 0) {
1111                         int i, col, l;
1112                         int sav_cursor = cursor;        /* change goto_new_line() */
1113
1114                         /* Go to the next line */
1115                         goto_new_line();
1116                         for (i = 0, col = 0; i < num_matches; i++) {
1117                                 l = strlen(matches[i]);
1118                                 if (l < 14)
1119                                         l = 14;
1120                                 printf("%-14s  ", matches[i]);
1121                                 if ((l += 2) > 16)
1122                                         while (l % 16) {
1123                                                 putchar(' ');
1124                                                 l++;
1125                                         }
1126                                 col += l;
1127                                 col -= (col / cmdedit_termw) * cmdedit_termw;
1128                                 if (col > 60 && matches[i + 1] != NULL) {
1129                                         putchar('\n');
1130                                         col = 0;
1131                                 }
1132                         }
1133                         /* Go to the next line and rewrite */
1134                         putchar('\n');
1135                         redraw(0, len - sav_cursor);
1136                 }
1137         }
1138 }
1139 #endif  /* BB_FEATURE_COMMAND_TAB_COMPLETION */
1140
1141 static void get_previous_history(struct history **hp, struct history *p)
1142 {
1143         if ((*hp)->s)
1144                 free((*hp)->s);
1145         (*hp)->s = xstrdup(command_ps);
1146         *hp = p;
1147 }
1148
1149 static inline void get_next_history(struct history **hp)
1150 {
1151         get_previous_history(hp, (*hp)->n);
1152 }
1153
1154 enum {
1155         ESC = 27,
1156         DEL = 127,
1157 };
1158
1159
1160 /*
1161  * This function is used to grab a character buffer
1162  * from the input file descriptor and allows you to
1163  * a string with full command editing (sortof like
1164  * a mini readline).
1165  *
1166  * The following standard commands are not implemented:
1167  * ESC-b -- Move back one word
1168  * ESC-f -- Move forward one word
1169  * ESC-d -- Delete back one word
1170  * ESC-h -- Delete forward one word
1171  * CTL-t -- Transpose two characters
1172  *
1173  * Furthermore, the "vi" command editing keys are not implemented.
1174  *
1175  */
1176
1177 extern void cmdedit_read_input(char *prompt, char command[BUFSIZ])
1178 {
1179
1180         int break_out = 0;
1181         int lastWasTab = FALSE;
1182         unsigned char c = 0;
1183         struct history *hp = his_end;
1184
1185         /* prepare before init handlers */
1186         cmdedit_y = 0;  /* quasireal y, not true work if line > xt*yt */
1187         len = 0;
1188         command_ps = command;
1189
1190         if (new_settings.c_cc[VERASE] == 0) {     /* first call */
1191
1192                 getTermSettings(0, (void *) &initial_settings);
1193                 memcpy(&new_settings, &initial_settings, sizeof(struct termios));
1194                 new_settings.c_lflag &= ~ICANON;        /* unbuffered input */
1195                 /* Turn off echoing and CTRL-C, so we can trap it */
1196                 new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
1197 #ifndef linux
1198                 /* Hmm, in linux c_cc[] not parsed if set ~ICANON */
1199                 new_settings.c_cc[VMIN] = 1;
1200                 new_settings.c_cc[VTIME] = 0;
1201                 /* Turn off CTRL-C, so we can trap it */
1202 #       ifndef _POSIX_VDISABLE
1203 #               define _POSIX_VDISABLE '\0'
1204 #       endif
1205                 new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
1206 #endif
1207         }
1208
1209         command[0] = 0;
1210
1211         setTermSettings(0, (void *) &new_settings);
1212         handlers_sets |= SET_RESET_TERM;
1213
1214         /* Now initialize things */
1215         cmdedit_init();
1216         /* Print out the command prompt */
1217         parse_prompt(prompt);
1218
1219         while (1) {
1220
1221                 fflush(stdout);                 /* buffered out to fast */
1222
1223                 if (read(0, &c, 1) < 1)
1224                         /* if we can't read input then exit */
1225                         goto prepare_to_die;
1226
1227                 switch (c) {
1228                 case '\n':
1229                 case '\r':
1230                         /* Enter */
1231                         goto_new_line();
1232                         break_out = 1;
1233                         break;
1234                 case 1:
1235                         /* Control-a -- Beginning of line */
1236                         input_backward(cursor);
1237                         break;
1238                 case 2:
1239                         /* Control-b -- Move back one character */
1240                         input_backward(1);
1241                         break;
1242                 case 3:
1243                         /* Control-c -- stop gathering input */
1244
1245                         /* Link into lash to reset context to 0 on ^C and such */
1246                         shell_context = 0;
1247
1248                         /* Go to the next line */
1249                         goto_new_line();
1250                         command[0] = 0;
1251
1252                         return;
1253                 case 4:
1254                         /* Control-d -- Delete one character, or exit
1255                          * if the len=0 and no chars to delete */
1256                         if (len == 0) {
1257 prepare_to_die:
1258                                 printf("exit");
1259                                 clean_up_and_die(0);
1260                         } else {
1261                                 input_delete();
1262                         }
1263                         break;
1264                 case 5:
1265                         /* Control-e -- End of line */
1266                         input_end();
1267                         break;
1268                 case 6:
1269                         /* Control-f -- Move forward one character */
1270                         input_forward();
1271                         break;
1272                 case '\b':
1273                 case DEL:
1274                         /* Control-h and DEL */
1275                         input_backspace();
1276                         break;
1277                 case '\t':
1278 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
1279                         input_tab(&lastWasTab);
1280 #endif
1281                         break;
1282                 case 14:
1283                         /* Control-n -- Get next command in history */
1284                         if (hp && hp->n && hp->n->s) {
1285                                 get_next_history(&hp);
1286                                 goto rewrite_line;
1287                         } else {
1288                                 beep();
1289                         }
1290                         break;
1291                 case 16:
1292                         /* Control-p -- Get previous command from history */
1293                         if (hp && hp->p) {
1294                                 get_previous_history(&hp, hp->p);
1295                                 goto rewrite_line;
1296                         } else {
1297                                 beep();
1298                         }
1299                         break;
1300                 case 21:
1301                         /* Control-U -- Clear line before cursor */
1302                         if (cursor) {
1303                                 strcpy(command, command + cursor);
1304                                 redraw(cmdedit_y, len -= cursor);
1305                         }
1306                         break;
1307
1308                 case ESC:{
1309                         /* escape sequence follows */
1310                         if (read(0, &c, 1) < 1)
1311                                 return;
1312                         /* different vt100 emulations */
1313                         if (c == '[' || c == 'O') {
1314                                 if (read(0, &c, 1) < 1)
1315                                         return;
1316                         }
1317                         switch (c) {
1318 #ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
1319                         case '\t':                      /* Alt-Tab */
1320
1321                                 input_tab(&lastWasTab);
1322                                 break;
1323 #endif
1324                         case 'A':
1325                                 /* Up Arrow -- Get previous command from history */
1326                                 if (hp && hp->p) {
1327                                         get_previous_history(&hp, hp->p);
1328                                         goto rewrite_line;
1329                                 } else {
1330                                         beep();
1331                                 }
1332                                 break;
1333                         case 'B':
1334                                 /* Down Arrow -- Get next command in history */
1335                                 if (hp && hp->n && hp->n->s) {
1336                                         get_next_history(&hp);
1337                                         goto rewrite_line;
1338                                 } else {
1339                                         beep();
1340                                 }
1341                                 break;
1342
1343                                 /* Rewrite the line with the selected history item */
1344                           rewrite_line:
1345                                 /* change command */
1346                                 len = strlen(strcpy(command, hp->s));
1347                                 /* redraw and go to end line */
1348                                 redraw(cmdedit_y, 0);
1349                                 break;
1350                         case 'C':
1351                                 /* Right Arrow -- Move forward one character */
1352                                 input_forward();
1353                                 break;
1354                         case 'D':
1355                                 /* Left Arrow -- Move back one character */
1356                                 input_backward(1);
1357                                 break;
1358                         case '3':
1359                                 /* Delete */
1360                                 input_delete();
1361                                 break;
1362                         case '1':
1363                         case 'H':
1364                                 /* Home (Ctrl-A) */
1365                                 input_backward(cursor);
1366                                 break;
1367                         case '4':
1368                         case 'F':
1369                                 /* End (Ctrl-E) */
1370                                 input_end();
1371                                 break;
1372                         default:
1373                                 if (!(c >= '1' && c <= '9'))
1374                                         c = 0;
1375                                 beep();
1376                         }
1377                         if (c >= '1' && c <= '9')
1378                                 do
1379                                         if (read(0, &c, 1) < 1)
1380                                                 return;
1381                                 while (c != '~');
1382                         break;
1383                 }
1384
1385                 default:        /* If it's regular input, do the normal thing */
1386 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1387                         /* Control-V -- Add non-printable symbol */
1388                         if (c == 22) {
1389                                 if (read(0, &c, 1) < 1)
1390                                         return;
1391                                 if (c == 0) {
1392                                         beep();
1393                                         break;
1394                                 }
1395                         } else
1396 #endif
1397                         if (!Isprint(c))        /* Skip non-printable characters */
1398                                 break;
1399
1400                         if (len >= (BUFSIZ - 2))        /* Need to leave space for enter */
1401                                 break;
1402
1403                         len++;
1404
1405                         if (cursor == (len - 1)) {      /* Append if at the end of the line */
1406                                 *(command + cursor) = c;
1407                                 *(command + cursor + 1) = 0;
1408                                 cmdedit_set_out_char(0);
1409                         } else {                        /* Insert otherwise */
1410                                 int sc = cursor;
1411
1412                                 memmove(command + sc + 1, command + sc, len - sc);
1413                                 *(command + sc) = c;
1414                                 sc++;
1415                                 /* rewrite from cursor */
1416                                 input_end();
1417                                 /* to prev x pos + 1 */
1418                                 input_backward(cursor - sc);
1419                         }
1420
1421                         break;
1422                 }
1423                 if (break_out)                  /* Enter is the command terminator, no more input. */
1424                         break;
1425
1426                 if (c != '\t')
1427                         lastWasTab = FALSE;
1428         }
1429
1430         setTermSettings(0, (void *) &initial_settings);
1431         handlers_sets &= ~SET_RESET_TERM;
1432
1433         /* Handle command history log */
1434         if (len) {                                      /* no put empty line */
1435
1436                 struct history *h = his_end;
1437                 char *ss;
1438
1439                 ss = xstrdup(command);  /* duplicate */
1440
1441                 if (h == 0) {
1442                         /* No previous history -- this memory is never freed */
1443                         h = his_front = xmalloc(sizeof(struct history));
1444                         h->n = xmalloc(sizeof(struct history));
1445
1446                         h->p = NULL;
1447                         h->s = ss;
1448                         h->n->p = h;
1449                         h->n->n = NULL;
1450                         h->n->s = NULL;
1451                         his_end = h->n;
1452                         history_counter++;
1453                 } else {
1454                         /* Add a new history command -- this memory is never freed */
1455                         h->n = xmalloc(sizeof(struct history));
1456
1457                         h->n->p = h;
1458                         h->n->n = NULL;
1459                         h->n->s = NULL;
1460                         h->s = ss;
1461                         his_end = h->n;
1462
1463                         /* After max history, remove the oldest command */
1464                         if (history_counter >= MAX_HISTORY) {
1465
1466                                 struct history *p = his_front->n;
1467
1468                                 p->p = NULL;
1469                                 free(his_front->s);
1470                                 free(his_front);
1471                                 his_front = p;
1472                         } else {
1473                                 history_counter++;
1474                         }
1475                 }
1476 #if defined(BB_FEATURE_SH_FANCY_PROMPT)
1477                 num_ok_lines++;
1478 #endif
1479         }
1480         command[len++] = '\n';          /* set '\n' */
1481         command[len] = 0;
1482 #if defined(BB_FEATURE_CLEAN_UP) && defined(BB_FEATURE_COMMAND_TAB_COMPLETION)
1483         input_tab(0);                           /* strong free */
1484 #endif
1485 #if defined(BB_FEATURE_SH_FANCY_PROMPT)
1486         free(cmdedit_prompt);
1487 #endif
1488         return;
1489 }
1490
1491
1492 /* Undo the effects of cmdedit_init(). */
1493 extern void cmdedit_terminate(void)
1494 {
1495         cmdedit_reset_term();
1496         if ((handlers_sets & SET_TERM_HANDLERS) != 0) {
1497                 signal(SIGKILL, SIG_DFL);
1498                 signal(SIGINT, SIG_DFL);
1499                 signal(SIGQUIT, SIG_DFL);
1500                 signal(SIGTERM, SIG_DFL);
1501                 signal(SIGWINCH, SIG_DFL);
1502                 handlers_sets &= ~SET_TERM_HANDLERS;
1503         }
1504 }
1505
1506 #endif  /* BB_FEATURE_COMMAND_EDITING */
1507
1508
1509 #ifdef TEST
1510
1511 const char *applet_name = "debug stuff usage";
1512 const char *memory_exhausted = "Memory exhausted";
1513
1514 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1515 #include <locale.h>
1516 #endif
1517
1518 unsigned int shell_context;
1519
1520 int main(int argc, char **argv)
1521 {
1522         char buff[BUFSIZ];
1523         char *prompt =
1524 #if defined(BB_FEATURE_SH_FANCY_PROMPT)
1525                 "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:\
1526 \\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] \
1527 \\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
1528 #else
1529                 "% ";
1530 #endif
1531
1532 #ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1533         setlocale(LC_ALL, "");
1534 #endif
1535         shell_context = 1;
1536         do {
1537                 int l;
1538                 cmdedit_read_input(prompt, buff);
1539                 l = strlen(buff);
1540                 if(l > 0 && buff[l-1] == '\n')
1541                         buff[l-1] = 0;
1542                 printf("*** cmdedit_read_input() returned line =%s=\n", buff);
1543         } while (shell_context);
1544         printf("*** cmdedit_read_input() detect ^C\n");
1545         return 0;
1546 }
1547
1548 #endif  /* TEST */