shell/cmdedit.c

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