shell/cmdedit.c

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