userapps/opensource/busybox/shell/cmdedit.c

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