cmdedit.c

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