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