libbb/lineedit.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Termios command line History and Editing.
   4  *
   5  * Copyright (c) 1986-2003 may safely be consumed by a BSD or GPL license.
   6  * Written by:   Vladimir Oleynik <dzo@simtreas.ru>
   7  *
   8  * Used ideas:
   9  *      Adam Rogoyski    <rogoyski@cs.utexas.edu>
  10  *      Dave Cinege      <dcinege@psychosis.com>
  11  *      Jakub Jelinek (c) 1995
  12  *      Erik Andersen    <andersen@codepoet.org> (Majorly adjusted for busybox)
  13  *
  14  * This code is 'as is' with no warranty.
  15  */
  16
  17 /*
  18  * Usage and known bugs:
  19  * Terminal key codes are not extensive, more needs to be added.
  20  * This version was created on Debian GNU/Linux 2.x.
  21  * Delete, Backspace, Home, End, and the arrow keys were tested
  22  * to work in an Xterm and console. Ctrl-A also works as Home.
  23  * Ctrl-E also works as End.
  24  *
  25  * The following readline-like commands are not implemented:
  26  * ESC-b -- Move back one word
  27  * ESC-f -- Move forward one word
  28  * ESC-d -- Delete forward one word
  29  * CTL-t -- Transpose two characters
  30  *
  31  * lineedit does not know that the terminal escape sequences do not
  32  * take up space on the screen. The redisplay code assumes, unless
  33  * told otherwise, that each character in the prompt is a printable
  34  * character that takes up one character position on the screen.
  35  * You need to tell lineedit that some sequences of characters
  36  * in the prompt take up no screen space. Compatibly with readline,
  37  * use the \[ escape to begin a sequence of non-printing characters,
  38  * and the \] escape to signal the end of such a sequence. Example:
  39  *
  40  * PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] '
  41  */
  42 #include "libbb.h"
  43 #include "unicode.h"
  44
  45 #ifdef TEST
  46 # define ENABLE_FEATURE_EDITING 0
  47 # define ENABLE_FEATURE_TAB_COMPLETION 0
  48 # define ENABLE_FEATURE_USERNAME_COMPLETION 0
  49 #endif
  50
  51
  52 /* Entire file (except TESTing part) sits inside this #if */
  53 #if ENABLE_FEATURE_EDITING
  54
  55
  56 #define ENABLE_USERNAME_OR_HOMEDIR \
  57         (ENABLE_FEATURE_USERNAME_COMPLETION || ENABLE_FEATURE_EDITING_FANCY_PROMPT)
  58 #define IF_USERNAME_OR_HOMEDIR(...)
  59 #if ENABLE_USERNAME_OR_HOMEDIR
  60 # undef IF_USERNAME_OR_HOMEDIR
  61 # define IF_USERNAME_OR_HOMEDIR(...) __VA_ARGS__
  62 #endif
  63
  64
  65 #undef CHAR_T
  66 #if ENABLE_UNICODE_SUPPORT
  67 # define BB_NUL ((wchar_t)0)
  68 # define CHAR_T wchar_t
  69 static bool BB_isspace(CHAR_T c) { return ((unsigned)c < 256 && isspace(c)); }
  70 # if ENABLE_FEATURE_EDITING_VI
  71 static bool BB_isalnum(CHAR_T c) { return ((unsigned)c < 256 && isalnum(c)); }
  72 # endif
  73 static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); }
  74 # undef isspace
  75 # undef isalnum
  76 # undef ispunct
  77 # undef isprint
  78 # define isspace isspace_must_not_be_used
  79 # define isalnum isalnum_must_not_be_used
  80 # define ispunct ispunct_must_not_be_used
  81 # define isprint isprint_must_not_be_used
  82 #else
  83 # define BB_NUL '\0'
  84 # define CHAR_T char
  85 # define BB_isspace(c) isspace(c)
  86 # define BB_isalnum(c) isalnum(c)
  87 # define BB_ispunct(c) ispunct(c)
  88 #endif
  89 #if ENABLE_UNICODE_PRESERVE_BROKEN
  90 # define unicode_mark_raw_byte(wc)   ((wc) | 0x20000000)
  91 # define unicode_is_raw_byte(wc)     ((wc) & 0x20000000)
  92 #else
  93 # define unicode_is_raw_byte(wc)     0
  94 #endif
  95
  96
  97 #define SEQ_CLEAR_TILL_END_OF_SCREEN "\033[J"
  98 //#define SEQ_CLEAR_TILL_END_OF_LINE   "\033[K"
  99
 100
 101 enum {
 102         /* We use int16_t for positions, need to limit line len */
 103         MAX_LINELEN = CONFIG_FEATURE_EDITING_MAX_LEN < 0x7ff0
 104                       ? CONFIG_FEATURE_EDITING_MAX_LEN
 105                       : 0x7ff0
 106 };
 107
 108 #if ENABLE_USERNAME_OR_HOMEDIR
 109 static const char null_str[] ALIGN1 = "";
 110 #endif
 111
 112 /* We try to minimize both static and stack usage. */
 113 struct lineedit_statics {
 114         line_input_t *state;
 115
 116         volatile unsigned cmdedit_termw; /* = 80; */ /* actual terminal width */
 117         sighandler_t previous_SIGWINCH_handler;
 118
 119         unsigned cmdedit_x;        /* real x (col) terminal position */
 120         unsigned cmdedit_y;        /* pseudoreal y (row) terminal position */
 121         unsigned cmdedit_prmt_len; /* length of prompt (without colors etc) */
 122
 123         unsigned cursor;
 124         int command_len; /* must be signed */
 125         /* signed maxsize: we want x in "if (x > S.maxsize)"
 126          * to _not_ be promoted to unsigned */
 127         int maxsize;
 128         CHAR_T *command_ps;
 129
 130         const char *cmdedit_prompt;
 131 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
 132         int num_ok_lines; /* = 1; */
 133 #endif
 134
 135 #if ENABLE_USERNAME_OR_HOMEDIR
 136         char *user_buf;
 137         char *home_pwd_buf; /* = (char*)null_str; */
 138 #endif
 139
 140 #if ENABLE_FEATURE_TAB_COMPLETION
 141         char **matches;
 142         unsigned num_matches;
 143 #endif
 144
 145 #if ENABLE_FEATURE_EDITING_VI
 146 # define DELBUFSIZ 128
 147         CHAR_T *delptr;
 148         smallint newdelflag;     /* whether delbuf should be reused yet */
 149         CHAR_T delbuf[DELBUFSIZ];  /* a place to store deleted characters */
 150 #endif
 151 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
 152         smallint unknown_width;
 153         smallint sent_ESC_br6n;
 154 #endif
 155
 156         /* Formerly these were big buffers on stack: */
 157 #if ENABLE_FEATURE_TAB_COMPLETION
 158         char exe_n_cwd_tab_completion__dirbuf[MAX_LINELEN];
 159         char input_tab__matchBuf[MAX_LINELEN];
 160         int16_t find_match__int_buf[MAX_LINELEN + 1]; /* need to have 9 bits at least */
 161         int16_t find_match__pos_buf[MAX_LINELEN + 1];
 162 #endif
 163 };
 164
 165 /* See lineedit_ptr_hack.c */
 166 extern struct lineedit_statics *const lineedit_ptr_to_statics;
 167
 168 #define S (*lineedit_ptr_to_statics)
 169 #define state            (S.state           )
 170 #define cmdedit_termw    (S.cmdedit_termw   )
 171 #define previous_SIGWINCH_handler (S.previous_SIGWINCH_handler)
 172 #define cmdedit_x        (S.cmdedit_x       )
 173 #define cmdedit_y        (S.cmdedit_y       )
 174 #define cmdedit_prmt_len (S.cmdedit_prmt_len)
 175 #define cursor           (S.cursor          )
 176 #define command_len      (S.command_len     )
 177 #define command_ps       (S.command_ps      )
 178 #define cmdedit_prompt   (S.cmdedit_prompt  )
 179 #define num_ok_lines     (S.num_ok_lines    )
 180 #define user_buf         (S.user_buf        )
 181 #define home_pwd_buf     (S.home_pwd_buf    )
 182 #define matches          (S.matches         )
 183 #define num_matches      (S.num_matches     )
 184 #define delptr           (S.delptr          )
 185 #define newdelflag       (S.newdelflag      )
 186 #define delbuf           (S.delbuf          )
 187
 188 #define INIT_S() do { \
 189         (*(struct lineedit_statics**)&lineedit_ptr_to_statics) = xzalloc(sizeof(S)); \
 190         barrier(); \
 191         cmdedit_termw = 80; \
 192         IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines = 1;) \
 193         IF_USERNAME_OR_HOMEDIR(home_pwd_buf = (char*)null_str;) \
 194 } while (0)
 195 static void deinit_S(void)
 196 {
 197 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
 198         /* This one is allocated only if FANCY_PROMPT is on
 199          * (otherwise it points to verbatim prompt (NOT malloced) */
 200         free((char*)cmdedit_prompt);
 201 #endif
 202 #if ENABLE_USERNAME_OR_HOMEDIR
 203         free(user_buf);
 204         if (home_pwd_buf != null_str)
 205                 free(home_pwd_buf);
 206 #endif
 207         free(lineedit_ptr_to_statics);
 208 }
 209 #define DEINIT_S() deinit_S()
 210
 211
 212 #if ENABLE_UNICODE_SUPPORT
 213 static size_t load_string(const char *src, int maxsize)
 214 {
 215         ssize_t len = mbstowcs(command_ps, src, maxsize - 1);
 216         if (len < 0)
 217                 len = 0;
 218         command_ps[len] = 0;
 219         return len;
 220 }
 221 static unsigned save_string(char *dst, unsigned maxsize)
 222 {
 223 # if !ENABLE_UNICODE_PRESERVE_BROKEN
 224         ssize_t len = wcstombs(dst, command_ps, maxsize - 1);
 225         if (len < 0)
 226                 len = 0;
 227         dst[len] = '\0';
 228         return len;
 229 # else
 230         unsigned dstpos = 0;
 231         unsigned srcpos = 0;
 232
 233         maxsize--;
 234         while (dstpos < maxsize) {
 235                 wchar_t wc;
 236                 int n = srcpos;
 237                 while ((wc = command_ps[srcpos]) != 0
 238                     && !unicode_is_raw_byte(wc)
 239                 ) {
 240                         srcpos++;
 241                 }
 242                 command_ps[srcpos] = 0;
 243                 n = wcstombs(dst + dstpos, command_ps + n, maxsize - dstpos);
 244                 if (n < 0) /* should not happen */
 245                         break;
 246                 dstpos += n;
 247                 if (wc == 0) /* usually is */
 248                         break;
 249                 /* We do have invalid byte here! */
 250                 command_ps[srcpos] = wc; /* restore it */
 251                 srcpos++;
 252                 if (dstpos == maxsize)
 253                         break;
 254                 dst[dstpos++] = (char) wc;
 255         }
 256         dst[dstpos] = '\0';
 257         return dstpos;
 258 # endif
 259 }
 260 /* I thought just fputwc(c, stdout) would work. But no... */
 261 static void BB_PUTCHAR(wchar_t c)
 262 {
 263         char buf[MB_CUR_MAX + 1];
 264         mbstate_t mbst = { 0 };
 265         ssize_t len;
 266
 267         len = wcrtomb(buf, c, &mbst);
 268         if (len > 0) {
 269                 buf[len] = '\0';
 270                 fputs(buf, stdout);
 271         }
 272 }
 273 # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS
 274 static wchar_t adjust_width_and_validate_wc(unsigned *width_adj, wchar_t wc)
 275 # else
 276 static wchar_t adjust_width_and_validate_wc(wchar_t wc)
 277 #  define adjust_width_and_validate_wc(width_adj, wc) \
 278         ((*(width_adj))++, adjust_width_and_validate_wc(wc))
 279 # endif
 280 {
 281         int w = 1;
 282
 283         if (unicode_status == UNICODE_ON) {
 284                 if (wc > CONFIG_LAST_SUPPORTED_WCHAR) {
 285                         /* note: also true for unicode_is_raw_byte(wc) */
 286                         goto subst;
 287                 }
 288                 w = wcwidth(wc);
 289                 if ((ENABLE_UNICODE_COMBINING_WCHARS && w < 0)
 290                  || (!ENABLE_UNICODE_COMBINING_WCHARS && w <= 0)
 291                  || (!ENABLE_UNICODE_WIDE_WCHARS && w > 1)
 292                 ) {
 293  subst:
 294                         w = 1;
 295                         wc = CONFIG_SUBST_WCHAR;
 296                 }
 297         }
 298
 299 # if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS
 300         *width_adj += w;
 301 #endif
 302         return wc;
 303 }
 304 #else /* !UNICODE */
 305 static size_t load_string(const char *src, int maxsize)
 306 {
 307         safe_strncpy(command_ps, src, maxsize);
 308         return strlen(command_ps);
 309 }
 310 # if ENABLE_FEATURE_TAB_COMPLETION
 311 static void save_string(char *dst, unsigned maxsize)
 312 {
 313         safe_strncpy(dst, command_ps, maxsize);
 314 }
 315 # endif
 316 # define BB_PUTCHAR(c) bb_putchar(c)
 317 /* Should never be called: */
 318 int adjust_width_and_validate_wc(unsigned *width_adj, int wc);
 319 #endif
 320
 321
 322 /* Put 'command_ps[cursor]', cursor++.
 323  * Advance cursor on screen. If we reached right margin, scroll text up
 324  * and remove terminal margin effect by printing 'next_char' */
 325 #define HACK_FOR_WRONG_WIDTH 1
 326 static void put_cur_glyph_and_inc_cursor(void)
 327 {
 328         CHAR_T c = command_ps[cursor];
 329         unsigned width = 0;
 330         int ofs_to_right;
 331
 332         if (c == BB_NUL) {
 333                 /* erase character after end of input string */
 334                 c = ' ';
 335         } else {
 336                 /* advance cursor only if we aren't at the end yet */
 337                 cursor++;
 338                 if (unicode_status == UNICODE_ON) {
 339                         IF_UNICODE_WIDE_WCHARS(width = cmdedit_x;)
 340                         c = adjust_width_and_validate_wc(&cmdedit_x, c);
 341                         IF_UNICODE_WIDE_WCHARS(width = cmdedit_x - width;)
 342                 } else {
 343                         cmdedit_x++;
 344                 }
 345         }
 346
 347         ofs_to_right = cmdedit_x - cmdedit_termw;
 348         if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right <= 0) {
 349                 /* c fits on this line */
 350                 BB_PUTCHAR(c);
 351         }
 352
 353         if (ofs_to_right >= 0) {
 354                 /* we go to the next line */
 355 #if HACK_FOR_WRONG_WIDTH
 356                 /* This works better if our idea of term width is wrong
 357                  * and it is actually wider (often happens on serial lines).
 358                  * Printing CR,LF *forces* cursor to next line.
 359                  * OTOH if terminal width is correct AND terminal does NOT
 360                  * have automargin (IOW: it is moving cursor to next line
 361                  * by itself (which is wrong for VT-10x terminals)),
 362                  * this will break things: there will be one extra empty line */
 363                 puts("\r"); /* + implicit '\n' */
 364 #else
 365                 /* VT-10x terminals don't wrap cursor to next line when last char
 366                  * on the line is printed - cursor stays "over" this char.
 367                  * Need to print _next_ char too (first one to appear on next line)
 368                  * to make cursor move down to next line.
 369                  */
 370                 /* Works ok only if cmdedit_termw is correct. */
 371                 c = command_ps[cursor];
 372                 if (c == BB_NUL)
 373                         c = ' ';
 374                 BB_PUTCHAR(c);
 375                 bb_putchar('\b');
 376 #endif
 377                 cmdedit_y++;
 378                 if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right == 0) {
 379                         width = 0;
 380                 } else { /* ofs_to_right > 0 */
 381                         /* wide char c didn't fit on prev line */
 382                         BB_PUTCHAR(c);
 383                 }
 384                 cmdedit_x = width;
 385         }
 386 }
 387
 388 /* Move to end of line (by printing all chars till the end) */
 389 static void put_till_end_and_adv_cursor(void)
 390 {
 391         while (cursor < command_len)
 392                 put_cur_glyph_and_inc_cursor();
 393 }
 394
 395 /* Go to the next line */
 396 static void goto_new_line(void)
 397 {
 398         put_till_end_and_adv_cursor();
 399         if (cmdedit_x != 0)
 400                 bb_putchar('\n');
 401 }
 402
 403 static void beep(void)
 404 {
 405         bb_putchar('\007');
 406 }
 407
 408 static void put_prompt(void)
 409 {
 410         unsigned w;
 411
 412         fputs(cmdedit_prompt, stdout);
 413         fflush_all();
 414         cursor = 0;
 415         w = cmdedit_termw; /* read volatile var once */
 416         cmdedit_y = cmdedit_prmt_len / w; /* new quasireal y */
 417         cmdedit_x = cmdedit_prmt_len % w;
 418 }
 419
 420 /* Move back one character */
 421 /* (optimized for slow terminals) */
 422 static void input_backward(unsigned num)
 423 {
 424         if (num > cursor)
 425                 num = cursor;
 426         if (num == 0)
 427                 return;
 428         cursor -= num;
 429
 430         if ((ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS)
 431          && unicode_status == UNICODE_ON
 432         ) {
 433                 /* correct NUM to be equal to _screen_ width */
 434                 int n = num;
 435                 num = 0;
 436                 while (--n >= 0)
 437                         adjust_width_and_validate_wc(&num, command_ps[cursor + n]);
 438                 if (num == 0)
 439                         return;
 440         }
 441
 442         if (cmdedit_x >= num) {
 443                 cmdedit_x -= num;
 444                 if (num <= 4) {
 445                         /* This is longer by 5 bytes on x86.
 446                          * Also gets miscompiled for ARM users
 447                          * (busybox.net/bugs/view.php?id=2274).
 448                          * printf(("\b\b\b\b" + 4) - num);
 449                          * return;
 450                          */
 451                         do {
 452                                 bb_putchar('\b');
 453                         } while (--num);
 454                         return;
 455                 }
 456                 printf("\033[%uD", num);
 457                 return;
 458         }
 459
 460         /* Need to go one or more lines up */
 461         if (ENABLE_UNICODE_WIDE_WCHARS) {
 462                 /* With wide chars, it is hard to "backtrack"
 463                  * and reliably figure out where to put cursor.
 464                  * Example (<> is a wide char; # is an ordinary char, _ cursor):
 465                  * |prompt: <><> |
 466                  * |<><><><><><> |
 467                  * |_            |
 468                  * and user presses left arrow. num = 1, cmdedit_x = 0,
 469                  * We need to go up one line, and then - how do we know that
 470                  * we need to go *10* positions to the right? Because
 471                  * |prompt: <>#<>|
 472                  * |<><><>#<><><>|
 473                  * |_            |
 474                  * in this situation we need to go *11* positions to the right.
 475                  *
 476                  * A simpler thing to do is to redraw everything from the start
 477                  * up to new cursor position (which is already known):
 478                  */
 479                 unsigned sv_cursor;
 480                 /* go to 1st column; go up to first line */
 481                 printf("\r" "\033[%uA", cmdedit_y);
 482                 cmdedit_y = 0;
 483                 sv_cursor = cursor;
 484                 put_prompt(); /* sets cursor to 0 */
 485                 while (cursor < sv_cursor)
 486                         put_cur_glyph_and_inc_cursor();
 487         } else {
 488                 int lines_up;
 489                 unsigned width;
 490                 /* num = chars to go back from the beginning of current line: */
 491                 num -= cmdedit_x;
 492                 width = cmdedit_termw; /* read volatile var once */
 493                 /* num=1...w: one line up, w+1...2w: two, etc: */
 494                 lines_up = 1 + (num - 1) / width;
 495                 cmdedit_x = (width * cmdedit_y - num) % width;
 496                 cmdedit_y -= lines_up;
 497                 /* go to 1st column; go up */
 498                 printf("\r" "\033[%uA", lines_up);
 499                 /* go to correct column.
 500                  * xterm, konsole, Linux VT interpret 0 as 1 below! wow.
 501                  * need to *make sure* we skip it if cmdedit_x == 0 */
 502                 if (cmdedit_x)
 503                         printf("\033[%uC", cmdedit_x);
 504         }
 505 }
 506
 507 /* draw prompt, editor line, and clear tail */
 508 static void redraw(int y, int back_cursor)
 509 {
 510         if (y > 0) /* up y lines */
 511                 printf("\033[%uA", y);
 512         bb_putchar('\r');
 513         put_prompt();
 514         put_till_end_and_adv_cursor();
 515         printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
 516         input_backward(back_cursor);
 517 }
 518
 519 /* Delete the char in front of the cursor, optionally saving it
 520  * for later putback */
 521 #if !ENABLE_FEATURE_EDITING_VI
 522 static void input_delete(void)
 523 #define input_delete(save) input_delete()
 524 #else
 525 static void input_delete(int save)
 526 #endif
 527 {
 528         int j = cursor;
 529
 530         if (j == (int)command_len)
 531                 return;
 532
 533 #if ENABLE_FEATURE_EDITING_VI
 534         if (save) {
 535                 if (newdelflag) {
 536                         delptr = delbuf;
 537                         newdelflag = 0;
 538                 }
 539                 if ((delptr - delbuf) < DELBUFSIZ)
 540                         *delptr++ = command_ps[j];
 541         }
 542 #endif
 543
 544         memmove(command_ps + j, command_ps + j + 1,
 545                         /* (command_len + 1 [because of NUL]) - (j + 1)
 546                          * simplified into (command_len - j) */
 547                         (command_len - j) * sizeof(command_ps[0]));
 548         command_len--;
 549         put_till_end_and_adv_cursor();
 550         /* Last char is still visible, erase it (and more) */
 551         printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
 552         input_backward(cursor - j);     /* back to old pos cursor */
 553 }
 554
 555 #if ENABLE_FEATURE_EDITING_VI
 556 static void put(void)
 557 {
 558         int ocursor;
 559         int j = delptr - delbuf;
 560
 561         if (j == 0)
 562                 return;
 563         ocursor = cursor;
 564         /* open hole and then fill it */
 565         memmove(command_ps + cursor + j, command_ps + cursor,
 566                         (command_len - cursor + 1) * sizeof(command_ps[0]));
 567         memcpy(command_ps + cursor, delbuf, j * sizeof(command_ps[0]));
 568         command_len += j;
 569         put_till_end_and_adv_cursor();
 570         input_backward(cursor - ocursor - j + 1); /* at end of new text */
 571 }
 572 #endif
 573
 574 /* Delete the char in back of the cursor */
 575 static void input_backspace(void)
 576 {
 577         if (cursor > 0) {
 578                 input_backward(1);
 579                 input_delete(0);
 580         }
 581 }
 582
 583 /* Move forward one character */
 584 static void input_forward(void)
 585 {
 586         if (cursor < command_len)
 587                 put_cur_glyph_and_inc_cursor();
 588 }
 589
 590 #if ENABLE_FEATURE_TAB_COMPLETION
 591
 592 static void free_tab_completion_data(void)
 593 {
 594         if (matches) {
 595                 while (num_matches)
 596                         free(matches[--num_matches]);
 597                 free(matches);
 598                 matches = NULL;
 599         }
 600 }
 601
 602 static void add_match(char *matched)
 603 {
 604         matches = xrealloc_vector(matches, 4, num_matches);
 605         matches[num_matches] = matched;
 606         num_matches++;
 607 }
 608
 609 #if ENABLE_FEATURE_USERNAME_COMPLETION
 610 static void username_tab_completion(char *ud, char *with_shash_flg)
 611 {
 612         struct passwd *entry;
 613         int userlen;
 614
 615         ud++;                           /* ~user/... to user/... */
 616         userlen = strlen(ud);
 617
 618         if (with_shash_flg) {           /* "~/..." or "~user/..." */
 619                 char *sav_ud = ud - 1;
 620                 char *home = NULL;
 621
 622                 if (*ud == '/') {       /* "~/..."     */
 623                         home = home_pwd_buf;
 624                 } else {
 625                         /* "~user/..." */
 626                         char *temp;
 627                         temp = strchr(ud, '/');
 628                         *temp = '\0';           /* ~user\0 */
 629                         entry = getpwnam(ud);
 630                         *temp = '/';            /* restore ~user/... */
 631                         ud = temp;
 632                         if (entry)
 633                                 home = entry->pw_dir;
 634                 }
 635                 if (home) {
 636                         if ((userlen + strlen(home) + 1) < MAX_LINELEN) {
 637                                 /* /home/user/... */
 638                                 sprintf(sav_ud, "%s%s", home, ud);
 639                         }
 640                 }
 641         } else {
 642                 /* "~[^/]*" */
 643                 /* Using _r function to avoid pulling in static buffers */
 644                 char line_buff[256];
 645                 struct passwd pwd;
 646                 struct passwd *result;
 647
 648                 setpwent();
 649                 while (!getpwent_r(&pwd, line_buff, sizeof(line_buff), &result)) {
 650                         /* Null usernames should result in all users as possible completions. */
 651                         if (/*!userlen || */ strncmp(ud, pwd.pw_name, userlen) == 0) {
 652                                 add_match(xasprintf("~%s/", pwd.pw_name));
 653                         }
 654                 }
 655                 endpwent();
 656         }
 657 }
 658 #endif  /* FEATURE_COMMAND_USERNAME_COMPLETION */
 659
 660 enum {
 661         FIND_EXE_ONLY = 0,
 662         FIND_DIR_ONLY = 1,
 663         FIND_FILE_ONLY = 2,
 664 };
 665
 666 static int path_parse(char ***p, int flags)
 667 {
 668         int npth;
 669         const char *pth;
 670         char *tmp;
 671         char **res;
 672
 673         /* if not setenv PATH variable, to search cur dir "." */
 674         if (flags != FIND_EXE_ONLY)
 675                 return 1;
 676
 677         if (state->flags & WITH_PATH_LOOKUP)
 678                 pth = state->path_lookup;
 679         else
 680                 pth = getenv("PATH");
 681         /* PATH=<empty> or PATH=:<empty> */
 682         if (!pth || !pth[0] || LONE_CHAR(pth, ':'))
 683                 return 1;
 684
 685         tmp = (char*)pth;
 686         npth = 1; /* path component count */
 687         while (1) {
 688                 tmp = strchr(tmp, ':');
 689                 if (!tmp)
 690                         break;
 691                 if (*++tmp == '\0')
 692                         break;  /* :<empty> */
 693                 npth++;
 694         }
 695
 696         res = xmalloc(npth * sizeof(char*));
 697         res[0] = tmp = xstrdup(pth);
 698         npth = 1;
 699         while (1) {
 700                 tmp = strchr(tmp, ':');
 701                 if (!tmp)
 702                         break;
 703                 *tmp++ = '\0'; /* ':' -> '\0' */
 704                 if (*tmp == '\0')
 705                         break; /* :<empty> */
 706                 res[npth++] = tmp;
 707         }
 708         *p = res;
 709         return npth;
 710 }
 711
 712 static void exe_n_cwd_tab_completion(char *command, int type)
 713 {
 714         DIR *dir;
 715         struct dirent *next;
 716         struct stat st;
 717         char *path1[1];
 718         char **paths = path1;
 719         int npaths;
 720         int i;
 721         char *found;
 722         char *pfind = strrchr(command, '/');
 723 /*      char dirbuf[MAX_LINELEN]; */
 724 #define dirbuf (S.exe_n_cwd_tab_completion__dirbuf)
 725
 726         npaths = 1;
 727         path1[0] = (char*)".";
 728
 729         if (pfind == NULL) {
 730                 /* no dir, if flags==EXE_ONLY - get paths, else "." */
 731                 npaths = path_parse(&paths, type);
 732                 pfind = command;
 733         } else {
 734                 /* dirbuf = ".../.../.../" */
 735                 safe_strncpy(dirbuf, command, (pfind - command) + 2);
 736 #if ENABLE_FEATURE_USERNAME_COMPLETION
 737                 if (dirbuf[0] == '~')   /* ~/... or ~user/... */
 738                         username_tab_completion(dirbuf, dirbuf);
 739 #endif
 740                 paths[0] = dirbuf;
 741                 /* point to 'l' in "..../last_component" */
 742                 pfind++;
 743         }
 744
 745         for (i = 0; i < npaths; i++) {
 746                 dir = opendir(paths[i]);
 747                 if (!dir)
 748                         continue; /* don't print an error */
 749
 750                 while ((next = readdir(dir)) != NULL) {
 751                         int len1;
 752                         const char *str_found = next->d_name;
 753
 754                         /* matched? */
 755                         if (strncmp(str_found, pfind, strlen(pfind)))
 756                                 continue;
 757                         /* not see .name without .match */
 758                         if (*str_found == '.' && *pfind == '\0') {
 759                                 if (NOT_LONE_CHAR(paths[i], '/') || str_found[1])
 760                                         continue;
 761                                 str_found = ""; /* only "/" */
 762                         }
 763                         found = concat_path_file(paths[i], str_found);
 764                         /* hmm, remove in progress? */
 765                         /* NB: stat() first so that we see is it a directory;
 766                          * but if that fails, use lstat() so that
 767                          * we still match dangling links */
 768                         if (stat(found, &st) && lstat(found, &st))
 769                                 goto cont;
 770                         /* find with dirs? */
 771                         if (paths[i] != dirbuf)
 772                                 strcpy(found, next->d_name); /* only name */
 773
 774                         len1 = strlen(found);
 775                         found = xrealloc(found, len1 + 2);
 776                         found[len1] = '\0';
 777                         found[len1+1] = '\0';
 778
 779                         if (S_ISDIR(st.st_mode)) {
 780                                 /* name is a directory */
 781                                 if (found[len1-1] != '/') {
 782                                         found[len1] = '/';
 783                                 }
 784                         } else {
 785                                 /* not put found file if search only dirs for cd */
 786                                 if (type == FIND_DIR_ONLY)
 787                                         goto cont;
 788                         }
 789                         /* Add it to the list */
 790                         add_match(found);
 791                         continue;
 792  cont:
 793                         free(found);
 794                 }
 795                 closedir(dir);
 796         }
 797         if (paths != path1) {
 798                 free(paths[0]); /* allocated memory is only in first member */
 799                 free(paths);
 800         }
 801 #undef dirbuf
 802 }
 803
 804 /* QUOT is used on elements of int_buf[], which are bytes,
 805  * not Unicode chars. Therefore it works correctly even in Unicode mode.
 806  */
 807 #define QUOT (UCHAR_MAX+1)
 808
 809 #define int_buf (S.find_match__int_buf)
 810 #define pos_buf (S.find_match__pos_buf)
 811 /* is must be <= in */
 812 static void collapse_pos(int is, int in)
 813 {
 814         memmove(int_buf+is, int_buf+in, (MAX_LINELEN+1-in)*sizeof(int_buf[0]));
 815         memmove(pos_buf+is, pos_buf+in, (MAX_LINELEN+1-in)*sizeof(pos_buf[0]));
 816 }
 817 static NOINLINE int find_match(char *matchBuf, int *len_with_quotes)
 818 {
 819         int i, j;
 820         int command_mode;
 821         int c, c2;
 822 /*      Were local, but it uses too much stack */
 823 /*      int16_t int_buf[MAX_LINELEN + 1]; */
 824 /*      int16_t pos_buf[MAX_LINELEN + 1]; */
 825
 826         /* set to integer dimension characters and own positions */
 827         for (i = 0;; i++) {
 828                 int_buf[i] = (unsigned char)matchBuf[i];
 829                 if (int_buf[i] == 0) {
 830                         pos_buf[i] = -1; /* end-fo-line indicator */
 831                         break;
 832                 }
 833                 pos_buf[i] = i;
 834         }
 835
 836         /* mask \+symbol and convert '\t' to ' ' */
 837         for (i = j = 0; matchBuf[i]; i++, j++) {
 838                 if (matchBuf[i] == '\\') {
 839                         collapse_pos(j, j + 1);
 840                         int_buf[j] |= QUOT;
 841                         i++;
 842                 }
 843         }
 844         /* mask "symbols" or 'symbols' */
 845         c2 = 0;
 846         for (i = 0; int_buf[i]; i++) {
 847                 c = int_buf[i];
 848                 if (c == '\'' || c == '"') {
 849                         if (c2 == 0)
 850                                 c2 = c;
 851                         else {
 852                                 if (c == c2)
 853                                         c2 = 0;
 854                                 else
 855                                         int_buf[i] |= QUOT;
 856                         }
 857                 } else if (c2 != 0 && c != '$')
 858                         int_buf[i] |= QUOT;
 859         }
 860
 861         /* skip commands with arguments if line has commands delimiters */
 862         /* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */
 863         for (i = 0; int_buf[i]; i++) {
 864                 c = int_buf[i];
 865                 c2 = int_buf[i + 1];
 866                 j = i ? int_buf[i - 1] : -1;
 867                 command_mode = 0;
 868                 if (c == ';' || c == '&' || c == '|') {
 869                         command_mode = 1 + (c == c2);
 870                         if (c == '&') {
 871                                 if (j == '>' || j == '<')
 872                                         command_mode = 0;
 873                         } else if (c == '|' && j == '>')
 874                                 command_mode = 0;
 875                 }
 876                 if (command_mode) {
 877                         collapse_pos(0, i + command_mode);
 878                         i = -1;  /* hack incremet */
 879                 }
 880         }
 881         /* collapse `command...` */
 882         for (i = 0; int_buf[i]; i++) {
 883                 if (int_buf[i] == '`') {
 884                         for (j = i + 1; int_buf[j]; j++)
 885                                 if (int_buf[j] == '`') {
 886                                         collapse_pos(i, j + 1);
 887                                         j = 0;
 888                                         break;
 889                                 }
 890                         if (j) {
 891                                 /* not found closing ` - command mode, collapse all previous */
 892                                 collapse_pos(0, i + 1);
 893                                 break;
 894                         } else
 895                                 i--;  /* hack incremet */
 896                 }
 897         }
 898
 899         /* collapse (command...(command...)...) or {command...{command...}...} */
 900         c = 0;  /* "recursive" level */
 901         c2 = 0;
 902         for (i = 0; int_buf[i]; i++) {
 903                 if (int_buf[i] == '(' || int_buf[i] == '{') {
 904                         if (int_buf[i] == '(')
 905                                 c++;
 906                         else
 907                                 c2++;
 908                         collapse_pos(0, i + 1);
 909                         i = -1;  /* hack incremet */
 910                 }
 911         }
 912         for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++) {
 913                 if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) {
 914                         if (int_buf[i] == ')')
 915                                 c--;
 916                         else
 917                                 c2--;
 918                         collapse_pos(0, i + 1);
 919                         i = -1;  /* hack incremet */
 920                 }
 921         }
 922
 923         /* skip first not quote space */
 924         for (i = 0; int_buf[i]; i++)
 925                 if (int_buf[i] != ' ')
 926                         break;
 927         if (i)
 928                 collapse_pos(0, i);
 929
 930         /* set find mode for completion */
 931         command_mode = FIND_EXE_ONLY;
 932         for (i = 0; int_buf[i]; i++) {
 933                 if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') {
 934                         if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY
 935                          && matchBuf[pos_buf[0]] == 'c'
 936                          && matchBuf[pos_buf[1]] == 'd'
 937                         ) {
 938                                 command_mode = FIND_DIR_ONLY;
 939                         } else {
 940                                 command_mode = FIND_FILE_ONLY;
 941                                 break;
 942                         }
 943                 }
 944         }
 945         for (i = 0; int_buf[i]; i++)
 946                 /* "strlen" */;
 947         /* find last word */
 948         for (--i; i >= 0; i--) {
 949                 c = int_buf[i];
 950                 if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') {
 951                         collapse_pos(0, i + 1);
 952                         break;
 953                 }
 954         }
 955         /* skip first not quoted '\'' or '"' */
 956         for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++)
 957                 /*skip*/;
 958         /* collapse quote or unquote // or /~ */
 959         while ((int_buf[i] & ~QUOT) == '/'
 960          && ((int_buf[i+1] & ~QUOT) == '/' || (int_buf[i+1] & ~QUOT) == '~')
 961         ) {
 962                 i++;
 963         }
 964
 965         /* set only match and destroy quotes */
 966         j = 0;
 967         for (c = 0; pos_buf[i] >= 0; i++) {
 968                 matchBuf[c++] = matchBuf[pos_buf[i]];
 969                 j = pos_buf[i] + 1;
 970         }
 971         matchBuf[c] = '\0';
 972         /* old length matchBuf with quotes symbols */
 973         *len_with_quotes = j ? j - pos_buf[0] : 0;
 974
 975         return command_mode;
 976 }
 977 #undef int_buf
 978 #undef pos_buf
 979
 980 /*
 981  * display by column (original idea from ls applet,
 982  * very optimized by me :)
 983  */
 984 static void showfiles(void)
 985 {
 986         int ncols, row;
 987         int column_width = 0;
 988         int nfiles = num_matches;
 989         int nrows = nfiles;
 990         int l;
 991
 992         /* find the longest file name - use that as the column width */
 993         for (row = 0; row < nrows; row++) {
 994                 l = unicode_strwidth(matches[row]);
 995                 if (column_width < l)
 996                         column_width = l;
 997         }
 998         column_width += 2;              /* min space for columns */
 999         ncols = cmdedit_termw / column_width;
1000
1001         if (ncols > 1) {
1002                 nrows /= ncols;
1003                 if (nfiles % ncols)
1004                         nrows++;        /* round up fractionals */
1005         } else {
1006                 ncols = 1;
1007         }
1008         for (row = 0; row < nrows; row++) {
1009                 int n = row;
1010                 int nc;
1011
1012                 for (nc = 1; nc < ncols && n+nrows < nfiles; n += nrows, nc++) {
1013                         printf("%s%-*s", matches[n],
1014                                 (int)(column_width - unicode_strwidth(matches[n])), ""
1015                         );
1016                 }
1017                 if (ENABLE_UNICODE_SUPPORT)
1018                         puts(printable_string(NULL, matches[n]));
1019                 else
1020                         puts(matches[n]);
1021         }
1022 }
1023
1024 static char *add_quote_for_spec_chars(char *found)
1025 {
1026         int l = 0;
1027         char *s = xzalloc((strlen(found) + 1) * 2);
1028
1029         while (*found) {
1030                 if (strchr(" `\"#$%^&*()=+{}[]:;'|\\<>", *found))
1031                         s[l++] = '\\';
1032                 s[l++] = *found++;
1033         }
1034         /* s[l] = '\0'; - already is */
1035         return s;
1036 }
1037
1038 /* Do TAB completion */
1039 static void input_tab(smallint *lastWasTab)
1040 {
1041         if (!(state->flags & TAB_COMPLETION))
1042                 return;
1043
1044         if (!*lastWasTab) {
1045                 char *tmp, *tmp1;
1046                 size_t len_found;
1047 /*              char matchBuf[MAX_LINELEN]; */
1048 #define matchBuf (S.input_tab__matchBuf)
1049                 int find_type;
1050                 int recalc_pos;
1051 #if ENABLE_UNICODE_SUPPORT
1052                 /* cursor pos in command converted to multibyte form */
1053                 int cursor_mb;
1054 #endif
1055
1056                 *lastWasTab = TRUE;             /* flop trigger */
1057
1058                 /* Make a local copy of the string --
1059                  * up to the position of the cursor */
1060                 save_string(matchBuf, cursor + 1);
1061 #if ENABLE_UNICODE_SUPPORT
1062                 cursor_mb = strlen(matchBuf);
1063 #endif
1064                 tmp = matchBuf;
1065
1066                 find_type = find_match(matchBuf, &recalc_pos);
1067
1068                 /* Free up any memory already allocated */
1069                 free_tab_completion_data();
1070
1071 #if ENABLE_FEATURE_USERNAME_COMPLETION
1072                 /* If the word starts with `~' and there is no slash in the word,
1073                  * then try completing this word as a username. */
1074                 if (state->flags & USERNAME_COMPLETION)
1075                         if (matchBuf[0] == '~' && strchr(matchBuf, '/') == NULL)
1076                                 username_tab_completion(matchBuf, NULL);
1077 #endif
1078                 /* Try to match any executable in our path and everything
1079                  * in the current working directory */
1080                 if (!matches)
1081                         exe_n_cwd_tab_completion(matchBuf, find_type);
1082                 /* Sort, then remove any duplicates found */
1083                 if (matches) {
1084                         unsigned i;
1085                         int n = 0;
1086                         qsort_string_vector(matches, num_matches);
1087                         for (i = 0; i < num_matches - 1; ++i) {
1088                                 if (matches[i] && matches[i+1]) { /* paranoia */
1089                                         if (strcmp(matches[i], matches[i+1]) == 0) {
1090                                                 free(matches[i]);
1091                                                 matches[i] = NULL; /* paranoia */
1092                                         } else {
1093                                                 matches[n++] = matches[i];
1094                                         }
1095                                 }
1096                         }
1097                         matches[n] = matches[i];
1098                         num_matches = n + 1;
1099                 }
1100                 /* Did we find exactly one match? */
1101                 if (!matches || num_matches > 1) { /* no */
1102                         beep();
1103                         if (!matches)
1104                                 return;         /* not found */
1105                         /* find minimal match */
1106                         tmp1 = xstrdup(matches[0]);
1107                         for (tmp = tmp1; *tmp; tmp++) {
1108                                 for (len_found = 1; len_found < num_matches; len_found++) {
1109                                         if (matches[len_found][tmp - tmp1] != *tmp) {
1110                                                 *tmp = '\0';
1111                                                 break;
1112                                         }
1113                                 }
1114                         }
1115                         if (*tmp1 == '\0') {        /* have unique */
1116                                 free(tmp1);
1117                                 return;
1118                         }
1119                         tmp = add_quote_for_spec_chars(tmp1);
1120                         free(tmp1);
1121                 } else {                        /* one match */
1122                         tmp = add_quote_for_spec_chars(matches[0]);
1123                         /* for next completion current found */
1124                         *lastWasTab = FALSE;
1125
1126                         len_found = strlen(tmp);
1127                         if (tmp[len_found-1] != '/') {
1128                                 tmp[len_found] = ' ';
1129                                 tmp[len_found+1] = '\0';
1130                         }
1131                 }
1132
1133                 len_found = strlen(tmp);
1134 #if !ENABLE_UNICODE_SUPPORT
1135                 /* have space to place the match? */
1136                 /* The result consists of three parts with these lengths: */
1137                 /* (cursor - recalc_pos) + len_found + (command_len - cursor) */
1138                 /* it simplifies into: */
1139                 if ((int)(len_found + command_len - recalc_pos) < S.maxsize) {
1140                         /* save tail */
1141                         strcpy(matchBuf, command_ps + cursor);
1142                         /* add match and tail */
1143                         sprintf(&command_ps[cursor - recalc_pos], "%s%s", tmp, matchBuf);
1144                         command_len = strlen(command_ps);
1145                         /* new pos */
1146                         recalc_pos = cursor - recalc_pos + len_found;
1147                         /* write out the matched command */
1148                         redraw(cmdedit_y, command_len - recalc_pos);
1149                 }
1150 #else
1151                 {
1152                         char command[MAX_LINELEN];
1153                         int len = save_string(command, sizeof(command));
1154                         /* have space to place the match? */
1155                         /* (cursor_mb - recalc_pos) + len_found + (len - cursor_mb) */
1156                         if ((int)(len_found + len - recalc_pos) < MAX_LINELEN) {
1157                                 /* save tail */
1158                                 strcpy(matchBuf, command + cursor_mb);
1159                                 /* where do we want to have cursor after all? */
1160                                 strcpy(&command[cursor_mb - recalc_pos], tmp);
1161                                 len = load_string(command, S.maxsize);
1162                                 /* add match and tail */
1163                                 sprintf(&command[cursor_mb - recalc_pos], "%s%s", tmp, matchBuf);
1164                                 command_len = load_string(command, S.maxsize);
1165                                 /* write out the matched command */
1166                                 redraw(cmdedit_y, command_len - len);
1167                         }
1168                 }
1169 #endif
1170                 free(tmp);
1171 #undef matchBuf
1172         } else {
1173                 /* Ok -- the last char was a TAB.  Since they
1174                  * just hit TAB again, print a list of all the
1175                  * available choices... */
1176                 if (matches && num_matches > 0) {
1177                         /* changed by goto_new_line() */
1178                         int sav_cursor = cursor;
1179
1180                         /* Go to the next line */
1181                         goto_new_line();
1182                         showfiles();
1183                         redraw(0, command_len - sav_cursor);
1184                 }
1185         }
1186 }
1187
1188 #endif  /* FEATURE_COMMAND_TAB_COMPLETION */
1189
1190
1191 line_input_t* FAST_FUNC new_line_input_t(int flags)
1192 {
1193         line_input_t *n = xzalloc(sizeof(*n));
1194         n->flags = flags;
1195         return n;
1196 }
1197
1198
1199 #if MAX_HISTORY > 0
1200
1201 static void save_command_ps_at_cur_history(void)
1202 {
1203         if (command_ps[0] != BB_NUL) {
1204                 int cur = state->cur_history;
1205                 free(state->history[cur]);
1206
1207 # if ENABLE_UNICODE_SUPPORT
1208                 {
1209                         char tbuf[MAX_LINELEN];
1210                         save_string(tbuf, sizeof(tbuf));
1211                         state->history[cur] = xstrdup(tbuf);
1212                 }
1213 # else
1214                 state->history[cur] = xstrdup(command_ps);
1215 # endif
1216         }
1217 }
1218
1219 /* state->flags is already checked to be nonzero */
1220 static int get_previous_history(void)
1221 {
1222         if ((state->flags & DO_HISTORY) && state->cur_history) {
1223                 save_command_ps_at_cur_history();
1224                 state->cur_history--;
1225                 return 1;
1226         }
1227         beep();
1228         return 0;
1229 }
1230
1231 static int get_next_history(void)
1232 {
1233         if (state->flags & DO_HISTORY) {
1234                 if (state->cur_history < state->cnt_history) {
1235                         save_command_ps_at_cur_history(); /* save the current history line */
1236                         return ++state->cur_history;
1237                 }
1238         }
1239         beep();
1240         return 0;
1241 }
1242
1243 # if ENABLE_FEATURE_EDITING_SAVEHISTORY
1244 /* We try to ensure that concurrent additions to the history
1245  * do not overwrite each other.
1246  * Otherwise shell users get unhappy.
1247  *
1248  * History file is trimmed lazily, when it grows several times longer
1249  * than configured MAX_HISTORY lines.
1250  */
1251
1252 static void free_line_input_t(line_input_t *n)
1253 {
1254         int i = n->cnt_history;
1255         while (i > 0)
1256                 free(n->history[--i]);
1257         free(n);
1258 }
1259
1260 /* state->flags is already checked to be nonzero */
1261 static void load_history(line_input_t *st_parm)
1262 {
1263         char *temp_h[MAX_HISTORY];
1264         char *line;
1265         FILE *fp;
1266         unsigned idx, i, line_len;
1267
1268         /* NB: do not trash old history if file can't be opened */
1269
1270         fp = fopen_for_read(st_parm->hist_file);
1271         if (fp) {
1272                 /* clean up old history */
1273                 for (idx = st_parm->cnt_history; idx > 0;) {
1274                         idx--;
1275                         free(st_parm->history[idx]);
1276                         st_parm->history[idx] = NULL;
1277                 }
1278
1279                 /* fill temp_h[], retaining only last MAX_HISTORY lines */
1280                 memset(temp_h, 0, sizeof(temp_h));
1281                 st_parm->cnt_history_in_file = idx = 0;
1282                 while ((line = xmalloc_fgetline(fp)) != NULL) {
1283                         if (line[0] == '\0') {
1284                                 free(line);
1285                                 continue;
1286                         }
1287                         free(temp_h[idx]);
1288                         temp_h[idx] = line;
1289                         st_parm->cnt_history_in_file++;
1290                         idx++;
1291                         if (idx == MAX_HISTORY)
1292                                 idx = 0;
1293                 }
1294                 fclose(fp);
1295
1296                 /* find first non-NULL temp_h[], if any */
1297                 if (st_parm->cnt_history_in_file) {
1298                         while (temp_h[idx] == NULL) {
1299                                 idx++;
1300                                 if (idx == MAX_HISTORY)
1301                                         idx = 0;
1302                         }
1303                 }
1304
1305                 /* copy temp_h[] to st_parm->history[] */
1306                 for (i = 0; i < MAX_HISTORY;) {
1307                         line = temp_h[idx];
1308                         if (!line)
1309                                 break;
1310                         idx++;
1311                         if (idx == MAX_HISTORY)
1312                                 idx = 0;
1313                         line_len = strlen(line);
1314                         if (line_len >= MAX_LINELEN)
1315                                 line[MAX_LINELEN-1] = '\0';
1316                         st_parm->history[i++] = line;
1317                 }
1318                 st_parm->cnt_history = i;
1319         }
1320 }
1321
1322 /* state->flags is already checked to be nonzero */
1323 static void save_history(char *str)
1324 {
1325         int fd;
1326         int len, len2;
1327
1328         fd = open(state->hist_file, O_WRONLY | O_CREAT | O_APPEND, 0666);
1329         if (fd < 0)
1330                 return;
1331         xlseek(fd, 0, SEEK_END); /* paranoia */
1332         len = strlen(str);
1333         str[len] = '\n'; /* we (try to) do atomic write */
1334         len2 = full_write(fd, str, len + 1);
1335         str[len] = '\0';
1336         close(fd);
1337         if (len2 != len + 1)
1338                 return; /* "wtf?" */
1339
1340         /* did we write so much that history file needs trimming? */
1341         state->cnt_history_in_file++;
1342         if (state->cnt_history_in_file > MAX_HISTORY * 4) {
1343                 FILE *fp;
1344                 char *new_name;
1345                 line_input_t *st_temp;
1346                 int i;
1347
1348                 /* we may have concurrently written entries from others.
1349                  * load them */
1350                 st_temp = new_line_input_t(state->flags);
1351                 st_temp->hist_file = state->hist_file;
1352                 load_history(st_temp);
1353
1354                 /* write out temp file and replace hist_file atomically */
1355                 new_name = xasprintf("%s.%u.new", state->hist_file, (int) getpid());
1356                 fp = fopen_for_write(new_name);
1357                 if (fp) {
1358                         for (i = 0; i < st_temp->cnt_history; i++)
1359                                 fprintf(fp, "%s\n", st_temp->history[i]);
1360                         fclose(fp);
1361                         if (rename(new_name, state->hist_file) == 0)
1362                                 state->cnt_history_in_file = st_temp->cnt_history;
1363                 }
1364                 free(new_name);
1365                 free_line_input_t(st_temp);
1366         }
1367 }
1368 # else
1369 #  define load_history(a) ((void)0)
1370 #  define save_history(a) ((void)0)
1371 # endif /* FEATURE_COMMAND_SAVEHISTORY */
1372
1373 static void remember_in_history(char *str)
1374 {
1375         int i;
1376
1377         if (!(state->flags & DO_HISTORY))
1378                 return;
1379         if (str[0] == '\0')
1380                 return;
1381         i = state->cnt_history;
1382         /* Don't save dupes */
1383         if (i && strcmp(state->history[i-1], str) == 0)
1384                 return;
1385
1386         free(state->history[MAX_HISTORY]); /* redundant, paranoia */
1387         state->history[MAX_HISTORY] = NULL; /* redundant, paranoia */
1388
1389         /* If history[] is full, remove the oldest command */
1390         /* we need to keep history[MAX_HISTORY] empty, hence >=, not > */
1391         if (i >= MAX_HISTORY) {
1392                 free(state->history[0]);
1393                 for (i = 0; i < MAX_HISTORY-1; i++)
1394                         state->history[i] = state->history[i+1];
1395                 /* i == MAX_HISTORY-1 */
1396         }
1397         /* i <= MAX_HISTORY-1 */
1398         state->history[i++] = xstrdup(str);
1399         /* i <= MAX_HISTORY */
1400         state->cur_history = i;
1401         state->cnt_history = i;
1402 # if MAX_HISTORY > 0 && ENABLE_FEATURE_EDITING_SAVEHISTORY
1403         if ((state->flags & SAVE_HISTORY) && state->hist_file)
1404                 save_history(str);
1405 # endif
1406         IF_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines++;)
1407 }
1408
1409 #else /* MAX_HISTORY == 0 */
1410 # define remember_in_history(a) ((void)0)
1411 #endif /* MAX_HISTORY */
1412
1413
1414 #if ENABLE_FEATURE_EDITING_VI
1415 /*
1416  * vi mode implemented 2005 by Paul Fox <pgf@foxharp.boston.ma.us>
1417  */
1418 static void
1419 vi_Word_motion(int eat)
1420 {
1421         CHAR_T *command = command_ps;
1422
1423         while (cursor < command_len && !BB_isspace(command[cursor]))
1424                 input_forward();
1425         if (eat) while (cursor < command_len && BB_isspace(command[cursor]))
1426                 input_forward();
1427 }
1428
1429 static void
1430 vi_word_motion(int eat)
1431 {
1432         CHAR_T *command = command_ps;
1433
1434         if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
1435                 while (cursor < command_len
1436                  && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_')
1437                 ) {
1438                         input_forward();
1439                 }
1440         } else if (BB_ispunct(command[cursor])) {
1441                 while (cursor < command_len && BB_ispunct(command[cursor+1]))
1442                         input_forward();
1443         }
1444
1445         if (cursor < command_len)
1446                 input_forward();
1447
1448         if (eat) {
1449                 while (cursor < command_len && BB_isspace(command[cursor]))
1450                         input_forward();
1451         }
1452 }
1453
1454 static void
1455 vi_End_motion(void)
1456 {
1457         CHAR_T *command = command_ps;
1458
1459         input_forward();
1460         while (cursor < command_len && BB_isspace(command[cursor]))
1461                 input_forward();
1462         while (cursor < command_len-1 && !BB_isspace(command[cursor+1]))
1463                 input_forward();
1464 }
1465
1466 static void
1467 vi_end_motion(void)
1468 {
1469         CHAR_T *command = command_ps;
1470
1471         if (cursor >= command_len-1)
1472                 return;
1473         input_forward();
1474         while (cursor < command_len-1 && BB_isspace(command[cursor]))
1475                 input_forward();
1476         if (cursor >= command_len-1)
1477                 return;
1478         if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
1479                 while (cursor < command_len-1
1480                  && (BB_isalnum(command[cursor+1]) || command[cursor+1] == '_')
1481                 ) {
1482                         input_forward();
1483                 }
1484         } else if (BB_ispunct(command[cursor])) {
1485                 while (cursor < command_len-1 && BB_ispunct(command[cursor+1]))
1486                         input_forward();
1487         }
1488 }
1489
1490 static void
1491 vi_Back_motion(void)
1492 {
1493         CHAR_T *command = command_ps;
1494
1495         while (cursor > 0 && BB_isspace(command[cursor-1]))
1496                 input_backward(1);
1497         while (cursor > 0 && !BB_isspace(command[cursor-1]))
1498                 input_backward(1);
1499 }
1500
1501 static void
1502 vi_back_motion(void)
1503 {
1504         CHAR_T *command = command_ps;
1505
1506         if (cursor <= 0)
1507                 return;
1508         input_backward(1);
1509         while (cursor > 0 && BB_isspace(command[cursor]))
1510                 input_backward(1);
1511         if (cursor <= 0)
1512                 return;
1513         if (BB_isalnum(command[cursor]) || command[cursor] == '_') {
1514                 while (cursor > 0
1515                  && (BB_isalnum(command[cursor-1]) || command[cursor-1] == '_')
1516                 ) {
1517                         input_backward(1);
1518                 }
1519         } else if (BB_ispunct(command[cursor])) {
1520                 while (cursor > 0 && BB_ispunct(command[cursor-1]))
1521                         input_backward(1);
1522         }
1523 }
1524 #endif
1525
1526 /* Modelled after bash 4.0 behavior of Ctrl-<arrow> */
1527 static void ctrl_left(void)
1528 {
1529         CHAR_T *command = command_ps;
1530
1531         while (1) {
1532                 CHAR_T c;
1533
1534                 input_backward(1);
1535                 if (cursor == 0)
1536                         break;
1537                 c = command[cursor];
1538                 if (c != ' ' && !BB_ispunct(c)) {
1539                         /* we reached a "word" delimited by spaces/punct.
1540                          * go to its beginning */
1541                         while (1) {
1542                                 c = command[cursor - 1];
1543                                 if (c == ' ' || BB_ispunct(c))
1544                                         break;
1545                                 input_backward(1);
1546                                 if (cursor == 0)
1547                                         break;
1548                         }
1549                         break;
1550                 }
1551         }
1552 }
1553 static void ctrl_right(void)
1554 {
1555         CHAR_T *command = command_ps;
1556
1557         while (1) {
1558                 CHAR_T c;
1559
1560                 c = command[cursor];
1561                 if (c == BB_NUL)
1562                         break;
1563                 if (c != ' ' && !BB_ispunct(c)) {
1564                         /* we reached a "word" delimited by spaces/punct.
1565                          * go to its end + 1 */
1566                         while (1) {
1567                                 input_forward();
1568                                 c = command[cursor];
1569                                 if (c == BB_NUL || c == ' ' || BB_ispunct(c))
1570                                         break;
1571                         }
1572                         break;
1573                 }
1574                 input_forward();
1575         }
1576 }
1577
1578
1579 /*
1580  * read_line_input and its helpers
1581  */
1582
1583 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
1584 static void ask_terminal(void)
1585 {
1586         /* Ask terminal where is the cursor now.
1587          * lineedit_read_key handles response and corrects
1588          * our idea of current cursor position.
1589          * Testcase: run "echo -n long_line_long_line_long_line",
1590          * then type in a long, wrapping command and try to
1591          * delete it using backspace key.
1592          * Note: we print it _after_ prompt, because
1593          * prompt may contain CR. Example: PS1='\[\r\n\]\w '
1594          */
1595         /* Problem: if there is buffered input on stdin,
1596          * the response will be delivered later,
1597          * possibly to an unsuspecting application.
1598          * Testcase: "sleep 1; busybox ash" + press and hold [Enter].
1599          * Result:
1600          * ~/srcdevel/bbox/fix/busybox.t4 #
1601          * ~/srcdevel/bbox/fix/busybox.t4 #
1602          * ^[[59;34~/srcdevel/bbox/fix/busybox.t4 #  <-- garbage
1603          * ~/srcdevel/bbox/fix/busybox.t4 #
1604          *
1605          * Checking for input with poll only makes the race narrower,
1606          * I still can trigger it. Strace:
1607          *
1608          * write(1, "~/srcdevel/bbox/fix/busybox.t4 # ", 33) = 33
1609          * poll([{fd=0, events=POLLIN}], 1, 0) = 0 (Timeout)  <-- no input exists
1610          * write(1, "\33[6n", 4) = 4  <-- send the ESC sequence, quick!
1611          * poll([{fd=0, events=POLLIN}], 1, 4294967295) = 1 ([{fd=0, revents=POLLIN}])
1612          * read(0, "\n", 1)      = 1  <-- oh crap, user's input got in first
1613          */
1614         if (S.unknown_width) { /* only if window size is not known */
1615                 struct pollfd pfd;
1616
1617                 pfd.fd = STDIN_FILENO;
1618                 pfd.events = POLLIN;
1619                 if (safe_poll(&pfd, 1, 0) == 0) {
1620                         S.sent_ESC_br6n = 1;
1621                         fputs("\033" "[6n", stdout);
1622                         fflush_all(); /* make terminal see it ASAP! */
1623                 }
1624         }
1625 }
1626 #else
1627 #define ask_terminal() ((void)0)
1628 #endif
1629
1630 #if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
1631 static void parse_and_put_prompt(const char *prmt_ptr)
1632 {
1633         cmdedit_prompt = prmt_ptr;
1634         cmdedit_prmt_len = strlen(prmt_ptr);
1635         put_prompt();
1636 }
1637 #else
1638 static void parse_and_put_prompt(const char *prmt_ptr)
1639 {
1640         int prmt_len = 0;
1641         size_t cur_prmt_len = 0;
1642         char flg_not_length = '[';
1643         char *prmt_mem_ptr = xzalloc(1);
1644         char *cwd_buf = xrealloc_getcwd_or_warn(NULL);
1645         char cbuf[2];
1646         char c;
1647         char *pbuf;
1648
1649         cmdedit_prmt_len = 0;
1650
1651         if (!cwd_buf) {
1652                 cwd_buf = (char *)bb_msg_unknown;
1653         }
1654
1655         cbuf[1] = '\0'; /* never changes */
1656
1657         while (*prmt_ptr) {
1658                 char *free_me = NULL;
1659
1660                 pbuf = cbuf;
1661                 c = *prmt_ptr++;
1662                 if (c == '\\') {
1663                         const char *cp = prmt_ptr;
1664                         int l;
1665
1666                         c = bb_process_escape_sequence(&prmt_ptr);
1667                         if (prmt_ptr == cp) {
1668                                 if (*cp == '\0')
1669                                         break;
1670                                 c = *prmt_ptr++;
1671
1672                                 switch (c) {
1673 # if ENABLE_USERNAME_OR_HOMEDIR
1674                                 case 'u':
1675                                         pbuf = user_buf ? user_buf : (char*)"";
1676                                         break;
1677 # endif
1678                                 case 'h':
1679                                         pbuf = free_me = safe_gethostname();
1680                                         *strchrnul(pbuf, '.') = '\0';
1681                                         break;
1682                                 case '$':
1683                                         c = (geteuid() == 0 ? '#' : '$');
1684                                         break;
1685 # if ENABLE_USERNAME_OR_HOMEDIR
1686                                 case 'w':
1687                                         /* /home/user[/something] -> ~[/something] */
1688                                         pbuf = cwd_buf;
1689                                         l = strlen(home_pwd_buf);
1690                                         if (l != 0
1691                                          && strncmp(home_pwd_buf, cwd_buf, l) == 0
1692                                          && (cwd_buf[l]=='/' || cwd_buf[l]=='\0')
1693                                          && strlen(cwd_buf + l) < PATH_MAX
1694                                         ) {
1695                                                 pbuf = free_me = xasprintf("~%s", cwd_buf + l);
1696                                         }
1697                                         break;
1698 # endif
1699                                 case 'W':
1700                                         pbuf = cwd_buf;
1701                                         cp = strrchr(pbuf, '/');
1702                                         if (cp != NULL && cp != pbuf)
1703                                                 pbuf += (cp-pbuf) + 1;
1704                                         break;
1705                                 case '!':
1706                                         pbuf = free_me = xasprintf("%d", num_ok_lines);
1707                                         break;
1708                                 case 'e': case 'E':     /* \e \E = \033 */
1709                                         c = '\033';
1710                                         break;
1711                                 case 'x': case 'X': {
1712                                         char buf2[4];
1713                                         for (l = 0; l < 3;) {
1714                                                 unsigned h;
1715                                                 buf2[l++] = *prmt_ptr;
1716                                                 buf2[l] = '\0';
1717                                                 h = strtoul(buf2, &pbuf, 16);
1718                                                 if (h > UCHAR_MAX || (pbuf - buf2) < l) {
1719                                                         buf2[--l] = '\0';
1720                                                         break;
1721                                                 }
1722                                                 prmt_ptr++;
1723                                         }
1724                                         c = (char)strtoul(buf2, NULL, 16);
1725                                         if (c == 0)
1726                                                 c = '?';
1727                                         pbuf = cbuf;
1728                                         break;
1729                                 }
1730                                 case '[': case ']':
1731                                         if (c == flg_not_length) {
1732                                                 flg_not_length = (flg_not_length == '[' ? ']' : '[');
1733                                                 continue;
1734                                         }
1735                                         break;
1736                                 } /* switch */
1737                         } /* if */
1738                 } /* if */
1739                 cbuf[0] = c;
1740                 cur_prmt_len = strlen(pbuf);
1741                 prmt_len += cur_prmt_len;
1742                 if (flg_not_length != ']')
1743                         cmdedit_prmt_len += cur_prmt_len;
1744                 prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
1745                 free(free_me);
1746         } /* while */
1747
1748         if (cwd_buf != (char *)bb_msg_unknown)
1749                 free(cwd_buf);
1750         cmdedit_prompt = prmt_mem_ptr;
1751         put_prompt();
1752 }
1753 #endif
1754
1755 static void cmdedit_setwidth(unsigned w, int redraw_flg)
1756 {
1757         cmdedit_termw = w;
1758         if (redraw_flg) {
1759                 /* new y for current cursor */
1760                 int new_y = (cursor + cmdedit_prmt_len) / w;
1761                 /* redraw */
1762                 redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), command_len - cursor);
1763                 fflush_all();
1764         }
1765 }
1766
1767 static void win_changed(int nsig)
1768 {
1769         int sv_errno = errno;
1770         unsigned width;
1771         IF_FEATURE_EDITING_ASK_TERMINAL(S.unknown_width =) get_terminal_width_height(0, &width, NULL);
1772         cmdedit_setwidth(width, nsig /* - just a yes/no flag */);
1773         if (nsig == SIGWINCH)
1774                 signal(SIGWINCH, win_changed); /* rearm ourself */
1775         errno = sv_errno;
1776 }
1777
1778 static int lineedit_read_key(char *read_key_buffer)
1779 {
1780         int64_t ic;
1781         int timeout = -1;
1782 #if ENABLE_UNICODE_SUPPORT
1783         char unicode_buf[MB_CUR_MAX + 1];
1784         int unicode_idx = 0;
1785 #endif
1786
1787         while (1) {
1788                 /* Wait for input. TIMEOUT = -1 makes read_key wait even
1789                  * on nonblocking stdin, TIMEOUT = 50 makes sure we won't
1790                  * insist on full MB_CUR_MAX buffer to declare input like
1791                  * "\xff\n",pause,"ls\n" invalid and thus won't lose "ls".
1792                  *
1793                  * Note: read_key sets errno to 0 on success.
1794                  */
1795                 ic = read_key(STDIN_FILENO, read_key_buffer, timeout);
1796                 if (errno) {
1797 #if ENABLE_UNICODE_SUPPORT
1798                         if (errno == EAGAIN && unicode_idx != 0)
1799                                 goto pushback;
1800 #endif
1801                         break;
1802                 }
1803
1804 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
1805                 if ((int32_t)ic == KEYCODE_CURSOR_POS
1806                  && S.sent_ESC_br6n
1807                 ) {
1808                         S.sent_ESC_br6n = 0;
1809                         if (cursor == 0) { /* otherwise it may be bogus */
1810                                 int col = ((ic >> 32) & 0x7fff) - 1;
1811                                 if (col > cmdedit_prmt_len) {
1812                                         cmdedit_x += (col - cmdedit_prmt_len);
1813                                         while (cmdedit_x >= cmdedit_termw) {
1814                                                 cmdedit_x -= cmdedit_termw;
1815                                                 cmdedit_y++;
1816                                         }
1817                                 }
1818                         }
1819                         continue;
1820                 }
1821 #endif
1822
1823 #if ENABLE_UNICODE_SUPPORT
1824                 if (unicode_status == UNICODE_ON) {
1825                         wchar_t wc;
1826
1827                         if ((int32_t)ic < 0) /* KEYCODE_xxx */
1828                                 break;
1829                         // TODO: imagine sequence like: 0xff,<left-arrow>: we are currently losing 0xff...
1830
1831                         unicode_buf[unicode_idx++] = ic;
1832                         unicode_buf[unicode_idx] = '\0';
1833                         if (mbstowcs(&wc, unicode_buf, 1) != 1) {
1834                                 /* Not (yet?) a valid unicode char */
1835                                 if (unicode_idx < MB_CUR_MAX) {
1836                                         timeout = 50;
1837                                         continue;
1838                                 }
1839  pushback:
1840                                 /* Invalid sequence. Save all "bad bytes" except first */
1841                                 read_key_ungets(read_key_buffer, unicode_buf + 1, unicode_idx - 1);
1842 # if !ENABLE_UNICODE_PRESERVE_BROKEN
1843                                 ic = CONFIG_SUBST_WCHAR;
1844 # else
1845                                 ic = unicode_mark_raw_byte(unicode_buf[0]);
1846 # endif
1847                         } else {
1848                                 /* Valid unicode char, return its code */
1849                                 ic = wc;
1850                         }
1851                 }
1852 #endif
1853                 break;
1854         }
1855
1856         return ic;
1857 }
1858
1859 #if ENABLE_UNICODE_BIDI_SUPPORT
1860 static int isrtl_str(void)
1861 {
1862         int idx = cursor;
1863
1864         while (idx < command_len && unicode_bidi_is_neutral_wchar(command_ps[idx]))
1865                 idx++;
1866         return unicode_bidi_isrtl(command_ps[idx]);
1867 }
1868 #else
1869 # define isrtl_str() 0
1870 #endif
1871
1872 /* leave out the "vi-mode"-only case labels if vi editing isn't
1873  * configured. */
1874 #define vi_case(caselabel) IF_FEATURE_EDITING_VI(case caselabel)
1875
1876 /* convert uppercase ascii to equivalent control char, for readability */
1877 #undef CTRL
1878 #define CTRL(a) ((a) & ~0x40)
1879
1880 /* maxsize must be >= 2.
1881  * Returns:
1882  * -1 on read errors or EOF, or on bare Ctrl-D,
1883  * 0  on ctrl-C (the line entered is still returned in 'command'),
1884  * >0 length of input string, including terminating '\n'
1885  */
1886 int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, line_input_t *st)
1887 {
1888         int len;
1889 #if ENABLE_FEATURE_TAB_COMPLETION
1890         smallint lastWasTab = FALSE;
1891 #endif
1892         smallint break_out = 0;
1893 #if ENABLE_FEATURE_EDITING_VI
1894         smallint vi_cmdmode = 0;
1895 #endif
1896         struct termios initial_settings;
1897         struct termios new_settings;
1898         char read_key_buffer[KEYCODE_BUFFER_SIZE];
1899
1900         INIT_S();
1901
1902         if (tcgetattr(STDIN_FILENO, &initial_settings) < 0
1903          || !(initial_settings.c_lflag & ECHO)
1904         ) {
1905                 /* Happens when e.g. stty -echo was run before */
1906                 parse_and_put_prompt(prompt);
1907                 /* fflush_all(); - done by parse_and_put_prompt */
1908                 if (fgets(command, maxsize, stdin) == NULL)
1909                         len = -1; /* EOF or error */
1910                 else
1911                         len = strlen(command);
1912                 DEINIT_S();
1913                 return len;
1914         }
1915
1916         init_unicode();
1917
1918 // FIXME: audit & improve this
1919         if (maxsize > MAX_LINELEN)
1920                 maxsize = MAX_LINELEN;
1921         S.maxsize = maxsize;
1922
1923         /* With null flags, no other fields are ever used */
1924         state = st ? st : (line_input_t*) &const_int_0;
1925 #if MAX_HISTORY > 0
1926 # if ENABLE_FEATURE_EDITING_SAVEHISTORY
1927         if ((state->flags & SAVE_HISTORY) && state->hist_file)
1928                 if (state->cnt_history == 0)
1929                         load_history(state);
1930 # endif
1931         if (state->flags & DO_HISTORY)
1932                 state->cur_history = state->cnt_history;
1933 #endif
1934
1935         /* prepare before init handlers */
1936         cmdedit_y = 0;  /* quasireal y, not true if line > xt*yt */
1937         command_len = 0;
1938 #if ENABLE_UNICODE_SUPPORT
1939         command_ps = xzalloc(maxsize * sizeof(command_ps[0]));
1940 #else
1941         command_ps = command;
1942         command[0] = '\0';
1943 #endif
1944 #define command command_must_not_be_used
1945
1946         new_settings = initial_settings;
1947         new_settings.c_lflag &= ~ICANON;        /* unbuffered input */
1948         /* Turn off echoing and CTRL-C, so we can trap it */
1949         new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
1950         /* Hmm, in linux c_cc[] is not parsed if ICANON is off */
1951         new_settings.c_cc[VMIN] = 1;
1952         new_settings.c_cc[VTIME] = 0;
1953         /* Turn off CTRL-C, so we can trap it */
1954 #ifndef _POSIX_VDISABLE
1955 # define _POSIX_VDISABLE '\0'
1956 #endif
1957         new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
1958         tcsetattr_stdin_TCSANOW(&new_settings);
1959
1960         /* Now initialize things */
1961         previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
1962         win_changed(0); /* do initial resizing */
1963 #if ENABLE_USERNAME_OR_HOMEDIR
1964         {
1965                 struct passwd *entry;
1966
1967                 entry = getpwuid(geteuid());
1968                 if (entry) {
1969                         user_buf = xstrdup(entry->pw_name);
1970                         home_pwd_buf = xstrdup(entry->pw_dir);
1971                 }
1972         }
1973 #endif
1974
1975 #if 0
1976         for (i = 0; i <= MAX_HISTORY; i++)
1977                 bb_error_msg("history[%d]:'%s'", i, state->history[i]);
1978         bb_error_msg("cur_history:%d cnt_history:%d", state->cur_history, state->cnt_history);
1979 #endif
1980
1981         /* Print out the command prompt, optionally ask where cursor is */
1982         parse_and_put_prompt(prompt);
1983         ask_terminal();
1984
1985         read_key_buffer[0] = 0;
1986         while (1) {
1987                 /*
1988                  * The emacs and vi modes share much of the code in the big
1989                  * command loop.  Commands entered when in vi's command mode
1990                  * (aka "escape mode") get an extra bit added to distinguish
1991                  * them - this keeps them from being self-inserted. This
1992                  * clutters the big switch a bit, but keeps all the code
1993                  * in one place.
1994                  */
1995                 enum {
1996                         VI_CMDMODE_BIT = 0x40000000,
1997                         /* 0x80000000 bit flags KEYCODE_xxx */
1998                 };
1999                 int32_t ic, ic_raw;
2000
2001                 fflush_all();
2002                 ic = ic_raw = lineedit_read_key(read_key_buffer);
2003
2004 #if ENABLE_FEATURE_EDITING_VI
2005                 newdelflag = 1;
2006                 if (vi_cmdmode) {
2007                         /* btw, since KEYCODE_xxx are all < 0, this doesn't
2008                          * change ic if it contains one of them: */
2009                         ic |= VI_CMDMODE_BIT;
2010                 }
2011 #endif
2012
2013                 switch (ic) {
2014                 case '\n':
2015                 case '\r':
2016                 vi_case('\n'|VI_CMDMODE_BIT:)
2017                 vi_case('\r'|VI_CMDMODE_BIT:)
2018                         /* Enter */
2019                         goto_new_line();
2020                         break_out = 1;
2021                         break;
2022                 case CTRL('A'):
2023                 vi_case('0'|VI_CMDMODE_BIT:)
2024                         /* Control-a -- Beginning of line */
2025                         input_backward(cursor);
2026                         break;
2027                 case CTRL('B'):
2028                 vi_case('h'|VI_CMDMODE_BIT:)
2029                 vi_case('\b'|VI_CMDMODE_BIT:) /* ^H */
2030                 vi_case('\x7f'|VI_CMDMODE_BIT:) /* DEL */
2031                         input_backward(1); /* Move back one character */
2032                         break;
2033                 case CTRL('E'):
2034                 vi_case('$'|VI_CMDMODE_BIT:)
2035                         /* Control-e -- End of line */
2036                         put_till_end_and_adv_cursor();
2037                         break;
2038                 case CTRL('F'):
2039                 vi_case('l'|VI_CMDMODE_BIT:)
2040                 vi_case(' '|VI_CMDMODE_BIT:)
2041                         input_forward(); /* Move forward one character */
2042                         break;
2043                 case '\b':   /* ^H */
2044                 case '\x7f': /* DEL */
2045                         if (!isrtl_str())
2046                                 input_backspace();
2047                         else
2048                                 input_delete(0);
2049                         break;
2050                 case KEYCODE_DELETE:
2051                         if (!isrtl_str())
2052                                 input_delete(0);
2053                         else
2054                                 input_backspace();
2055                         break;
2056 #if ENABLE_FEATURE_TAB_COMPLETION
2057                 case '\t':
2058                         input_tab(&lastWasTab);
2059                         break;
2060 #endif
2061                 case CTRL('K'):
2062                         /* Control-k -- clear to end of line */
2063                         command_ps[cursor] = BB_NUL;
2064                         command_len = cursor;
2065                         printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
2066                         break;
2067                 case CTRL('L'):
2068                 vi_case(CTRL('L')|VI_CMDMODE_BIT:)
2069                         /* Control-l -- clear screen */
2070                         printf("\033[H"); /* cursor to top,left */
2071                         redraw(0, command_len - cursor);
2072                         break;
2073 #if MAX_HISTORY > 0
2074                 case CTRL('N'):
2075                 vi_case(CTRL('N')|VI_CMDMODE_BIT:)
2076                 vi_case('j'|VI_CMDMODE_BIT:)
2077                         /* Control-n -- Get next command in history */
2078                         if (get_next_history())
2079                                 goto rewrite_line;
2080                         break;
2081                 case CTRL('P'):
2082                 vi_case(CTRL('P')|VI_CMDMODE_BIT:)
2083                 vi_case('k'|VI_CMDMODE_BIT:)
2084                         /* Control-p -- Get previous command from history */
2085                         if (get_previous_history())
2086                                 goto rewrite_line;
2087                         break;
2088 #endif
2089                 case CTRL('U'):
2090                 vi_case(CTRL('U')|VI_CMDMODE_BIT:)
2091                         /* Control-U -- Clear line before cursor */
2092                         if (cursor) {
2093                                 command_len -= cursor;
2094                                 memmove(command_ps, command_ps + cursor,
2095                                         (command_len + 1) * sizeof(command_ps[0]));
2096                                 redraw(cmdedit_y, command_len);
2097                         }
2098                         break;
2099                 case CTRL('W'):
2100                 vi_case(CTRL('W')|VI_CMDMODE_BIT:)
2101                         /* Control-W -- Remove the last word */
2102                         while (cursor > 0 && BB_isspace(command_ps[cursor-1]))
2103                                 input_backspace();
2104                         while (cursor > 0 && !BB_isspace(command_ps[cursor-1]))
2105                                 input_backspace();
2106                         break;
2107
2108 #if ENABLE_FEATURE_EDITING_VI
2109                 case 'i'|VI_CMDMODE_BIT:
2110                         vi_cmdmode = 0;
2111                         break;
2112                 case 'I'|VI_CMDMODE_BIT:
2113                         input_backward(cursor);
2114                         vi_cmdmode = 0;
2115                         break;
2116                 case 'a'|VI_CMDMODE_BIT:
2117                         input_forward();
2118                         vi_cmdmode = 0;
2119                         break;
2120                 case 'A'|VI_CMDMODE_BIT:
2121                         put_till_end_and_adv_cursor();
2122                         vi_cmdmode = 0;
2123                         break;
2124                 case 'x'|VI_CMDMODE_BIT:
2125                         input_delete(1);
2126                         break;
2127                 case 'X'|VI_CMDMODE_BIT:
2128                         if (cursor > 0) {
2129                                 input_backward(1);
2130                                 input_delete(1);
2131                         }
2132                         break;
2133                 case 'W'|VI_CMDMODE_BIT:
2134                         vi_Word_motion(1);
2135                         break;
2136                 case 'w'|VI_CMDMODE_BIT:
2137                         vi_word_motion(1);
2138                         break;
2139                 case 'E'|VI_CMDMODE_BIT:
2140                         vi_End_motion();
2141                         break;
2142                 case 'e'|VI_CMDMODE_BIT:
2143                         vi_end_motion();
2144                         break;
2145                 case 'B'|VI_CMDMODE_BIT:
2146                         vi_Back_motion();
2147                         break;
2148                 case 'b'|VI_CMDMODE_BIT:
2149                         vi_back_motion();
2150                         break;
2151                 case 'C'|VI_CMDMODE_BIT:
2152                         vi_cmdmode = 0;
2153                         /* fall through */
2154                 case 'D'|VI_CMDMODE_BIT:
2155                         goto clear_to_eol;
2156
2157                 case 'c'|VI_CMDMODE_BIT:
2158                         vi_cmdmode = 0;
2159                         /* fall through */
2160                 case 'd'|VI_CMDMODE_BIT: {
2161                         int nc, sc;
2162
2163                         ic = lineedit_read_key(read_key_buffer);
2164                         if (errno) /* error */
2165                                 goto prepare_to_die;
2166                         if (ic == ic_raw) { /* "cc", "dd" */
2167                                 input_backward(cursor);
2168                                 goto clear_to_eol;
2169                                 break;
2170                         }
2171
2172                         sc = cursor;
2173                         switch (ic) {
2174                         case 'w':
2175                         case 'W':
2176                         case 'e':
2177                         case 'E':
2178                                 switch (ic) {
2179                                 case 'w':   /* "dw", "cw" */
2180                                         vi_word_motion(vi_cmdmode);
2181                                         break;
2182                                 case 'W':   /* 'dW', 'cW' */
2183                                         vi_Word_motion(vi_cmdmode);
2184                                         break;
2185                                 case 'e':   /* 'de', 'ce' */
2186                                         vi_end_motion();
2187                                         input_forward();
2188                                         break;
2189                                 case 'E':   /* 'dE', 'cE' */
2190                                         vi_End_motion();
2191                                         input_forward();
2192                                         break;
2193                                 }
2194                                 nc = cursor;
2195                                 input_backward(cursor - sc);
2196                                 while (nc-- > cursor)
2197                                         input_delete(1);
2198                                 break;
2199                         case 'b':  /* "db", "cb" */
2200                         case 'B':  /* implemented as B */
2201                                 if (ic == 'b')
2202                                         vi_back_motion();
2203                                 else
2204                                         vi_Back_motion();
2205                                 while (sc-- > cursor)
2206                                         input_delete(1);
2207                                 break;
2208                         case ' ':  /* "d ", "c " */
2209                                 input_delete(1);
2210                                 break;
2211                         case '$':  /* "d$", "c$" */
2212  clear_to_eol:
2213                                 while (cursor < command_len)
2214                                         input_delete(1);
2215                                 break;
2216                         }
2217                         break;
2218                 }
2219                 case 'p'|VI_CMDMODE_BIT:
2220                         input_forward();
2221                         /* fallthrough */
2222                 case 'P'|VI_CMDMODE_BIT:
2223                         put();
2224                         break;
2225                 case 'r'|VI_CMDMODE_BIT:
2226 //FIXME: unicode case?
2227                         ic = lineedit_read_key(read_key_buffer);
2228                         if (errno) /* error */
2229                                 goto prepare_to_die;
2230                         if (ic < ' ' || ic > 255) {
2231                                 beep();
2232                         } else {
2233                                 command_ps[cursor] = ic;
2234                                 bb_putchar(ic);
2235                                 bb_putchar('\b');
2236                         }
2237                         break;
2238                 case '\x1b': /* ESC */
2239                         if (state->flags & VI_MODE) {
2240                                 /* insert mode --> command mode */
2241                                 vi_cmdmode = 1;
2242                                 input_backward(1);
2243                         }
2244                         break;
2245 #endif /* FEATURE_COMMAND_EDITING_VI */
2246
2247 #if MAX_HISTORY > 0
2248                 case KEYCODE_UP:
2249                         if (get_previous_history())
2250                                 goto rewrite_line;
2251                         beep();
2252                         break;
2253                 case KEYCODE_DOWN:
2254                         if (!get_next_history())
2255                                 break;
2256  rewrite_line:
2257                         /* Rewrite the line with the selected history item */
2258                         /* change command */
2259                         command_len = load_string(state->history[state->cur_history] ?
2260                                         state->history[state->cur_history] : "", maxsize);
2261                         /* redraw and go to eol (bol, in vi) */
2262                         redraw(cmdedit_y, (state->flags & VI_MODE) ? 9999 : 0);
2263                         break;
2264 #endif
2265                 case KEYCODE_RIGHT:
2266                         input_forward();
2267                         break;
2268                 case KEYCODE_LEFT:
2269                         input_backward(1);
2270                         break;
2271                 case KEYCODE_CTRL_LEFT:
2272                         ctrl_left();
2273                         break;
2274                 case KEYCODE_CTRL_RIGHT:
2275                         ctrl_right();
2276                         break;
2277                 case KEYCODE_HOME:
2278                         input_backward(cursor);
2279                         break;
2280                 case KEYCODE_END:
2281                         put_till_end_and_adv_cursor();
2282                         break;
2283
2284                 default:
2285                         if (initial_settings.c_cc[VINTR] != 0
2286                          && ic_raw == initial_settings.c_cc[VINTR]
2287                         ) {
2288                                 /* Ctrl-C (usually) - stop gathering input */
2289                                 goto_new_line();
2290                                 command_len = 0;
2291                                 break_out = -1; /* "do not append '\n'" */
2292                                 break;
2293                         }
2294                         if (initial_settings.c_cc[VEOF] != 0
2295                          && ic_raw == initial_settings.c_cc[VEOF]
2296                         ) {
2297                                 /* Ctrl-D (usually) - delete one character,
2298                                  * or exit if len=0 and no chars to delete */
2299                                 if (command_len == 0) {
2300                                         errno = 0;
2301 #if ENABLE_FEATURE_EDITING_VI
2302  prepare_to_die:
2303 #endif
2304                                         break_out = command_len = -1;
2305                                         break;
2306                                 }
2307                                 input_delete(0);
2308                                 break;
2309                         }
2310 //                      /* Control-V -- force insert of next char */
2311 //                      if (c == CTRL('V')) {
2312 //                              if (safe_read(STDIN_FILENO, &c, 1) < 1)
2313 //                                      goto prepare_to_die;
2314 //                              if (c == 0) {
2315 //                                      beep();
2316 //                                      break;
2317 //                              }
2318 //                      }
2319                         if (ic < ' '
2320                          || (!ENABLE_UNICODE_SUPPORT && ic >= 256)
2321                          || (ENABLE_UNICODE_SUPPORT && ic >= VI_CMDMODE_BIT)
2322                         ) {
2323                                 /* If VI_CMDMODE_BIT is set, ic is >= 256
2324                                  * and vi mode ignores unexpected chars.
2325                                  * Otherwise, we are here if ic is a
2326                                  * control char or an unhandled ESC sequence,
2327                                  * which is also ignored.
2328                                  */
2329                                 break;
2330                         }
2331                         if ((int)command_len >= (maxsize - 2)) {
2332                                 /* Not enough space for the char and EOL */
2333                                 break;
2334                         }
2335
2336                         command_len++;
2337                         if (cursor == (command_len - 1)) {
2338                                 /* We are at the end, append */
2339                                 command_ps[cursor] = ic;
2340                                 command_ps[cursor + 1] = BB_NUL;
2341                                 put_cur_glyph_and_inc_cursor();
2342                                 if (unicode_bidi_isrtl(ic))
2343                                         input_backward(1);
2344                         } else {
2345                                 /* In the middle, insert */
2346                                 int sc = cursor;
2347
2348                                 memmove(command_ps + sc + 1, command_ps + sc,
2349                                         (command_len - sc) * sizeof(command_ps[0]));
2350                                 command_ps[sc] = ic;
2351                                 /* is right-to-left char, or neutral one (e.g. comma) was just added to rtl text? */
2352                                 if (!isrtl_str())
2353                                         sc++; /* no */
2354                                 put_till_end_and_adv_cursor();
2355                                 /* to prev x pos + 1 */
2356                                 input_backward(cursor - sc);
2357                         }
2358                         break;
2359                 } /* switch (ic) */
2360
2361                 if (break_out)
2362                         break;
2363
2364 #if ENABLE_FEATURE_TAB_COMPLETION
2365                 if (ic_raw != '\t')
2366                         lastWasTab = FALSE;
2367 #endif
2368         } /* while (1) */
2369
2370 #if ENABLE_FEATURE_EDITING_ASK_TERMINAL
2371         if (S.sent_ESC_br6n) {
2372                 /* "sleep 1; busybox ash" + hold [Enter] to trigger.
2373                  * We sent "ESC [ 6 n", but got '\n' first, and
2374                  * KEYCODE_CURSOR_POS response is now buffered from terminal.
2375                  * It's bad already and not much can be done with it
2376                  * (it _will_ be visible for the next process to read stdin),
2377                  * but without this delay it even shows up on the screen
2378                  * as garbage because we restore echo settings with tcsetattr
2379                  * before it comes in. UGLY!
2380                  */
2381                 usleep(20*1000);
2382         }
2383 #endif
2384
2385 /* End of bug-catching "command_must_not_be_used" trick */
2386 #undef command
2387
2388 #if ENABLE_UNICODE_SUPPORT
2389         command[0] = '\0';
2390         if (command_len > 0)
2391                 command_len = save_string(command, maxsize - 1);
2392         free(command_ps);
2393 #endif
2394
2395         if (command_len > 0)
2396                 remember_in_history(command);
2397
2398         if (break_out > 0) {
2399                 command[command_len++] = '\n';
2400                 command[command_len] = '\0';
2401         }
2402
2403 #if ENABLE_FEATURE_TAB_COMPLETION
2404         free_tab_completion_data();
2405 #endif
2406
2407         /* restore initial_settings */
2408         tcsetattr_stdin_TCSANOW(&initial_settings);
2409         /* restore SIGWINCH handler */
2410         signal(SIGWINCH, previous_SIGWINCH_handler);
2411         fflush_all();
2412
2413         len = command_len;
2414         DEINIT_S();
2415
2416         return len; /* can't return command_len, DEINIT_S() destroys it */
2417 }
2418
2419 #else  /* !FEATURE_EDITING */
2420
2421 #undef read_line_input
2422 int FAST_FUNC read_line_input(const char* prompt, char* command, int maxsize)
2423 {
2424         fputs(prompt, stdout);
2425         fflush_all();
2426         fgets(command, maxsize, stdin);
2427         return strlen(command);
2428 }
2429
2430 #endif  /* !FEATURE_EDITING */
2431
2432
2433 /*
2434  * Testing
2435  */
2436
2437 #ifdef TEST
2438
2439 #include <locale.h>
2440
2441 const char *applet_name = "debug stuff usage";
2442
2443 int main(int argc, char **argv)
2444 {
2445         char buff[MAX_LINELEN];
2446         char *prompt =
2447 #if ENABLE_FEATURE_EDITING_FANCY_PROMPT
2448                 "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:"
2449                 "\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] "
2450                 "\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
2451 #else
2452                 "% ";
2453 #endif
2454
2455         while (1) {
2456                 int l;
2457                 l = read_line_input(prompt, buff);
2458                 if (l <= 0 || buff[l-1] != '\n')
2459                         break;
2460                 buff[l-1] = 0;
2461                 printf("*** read_line_input() returned line =%s=\n", buff);
2462         }
2463         printf("*** read_line_input() detect ^D\n");
2464         return 0;
2465 }
2466
2467 #endif  /* TEST */