Merge branch 'origin/master' (early part)

7 files changed, 380 insertions, 222 deletions

diff --git a/libbb/appletlib.c b/libbb/appletlib.c
index f287e4522..f6dc1f171 100644
--- a/libbb/appletlib.c
+++ b/libbb/appletlib.c
@@ -105,7 +105,9 @@ static const char *unpack_usage_messages(void)
 
 static void full_write2_str(const char *str)
 {
-        xwrite_str(STDERR_FILENO, str);
+        // This uses stdio:
+        //xwrite_str(STDERR_FILENO, str);
+        write(STDERR_FILENO, str, strlen(str));
 }
 
 void FAST_FUNC bb_show_usage(void)
@@ -593,6 +595,17 @@ static void check_suid(int applet_no)
 
 
 #if ENABLE_FEATURE_INSTALLER
+static const char usr_bin [] ALIGN1 = "/usr/bin/";
+static const char usr_sbin[] ALIGN1 = "/usr/sbin/";
+static const char *const install_dir[] = {
+        &usr_bin [8], /* "/" */
+        &usr_bin [4], /* "/bin/" */
+        &usr_sbin[4], /* "/sbin/" */
+        usr_bin,
+        usr_sbin
+};
+
+
 /* create (sym)links for each applet */
 static void install_links(const char *busybox, int use_symbolic_links,
                 char *custom_install_dir)
@@ -600,16 +613,6 @@ static void install_links(const char *busybox, int use_symbolic_links,
         /* directory table
          * this should be consistent w/ the enum,
          * busybox.h::bb_install_loc_t, or else... */
-        static const char usr_bin [] ALIGN1 = "/usr/bin";
-        static const char usr_sbin[] ALIGN1 = "/usr/sbin";
-        static const char *const install_dir[] = {
-                &usr_bin [8], /* "", equivalent to "/" for concat_path_file() */
-                &usr_bin [4], /* "/bin" */
-                &usr_sbin[4], /* "/sbin" */
-                usr_bin,
-                usr_sbin
-        };
-
         int (*lf)(const char *, const char *);
         char *fpc;
         unsigned i;
@@ -633,8 +636,8 @@ static void install_links(const char *busybox, int use_symbolic_links,
         }
 }
 #else
-#define install_links(x,y,z) ((void)0)
-#endif /* FEATURE_INSTALLER */
+# define install_links(x,y,z) ((void)0)
+#endif
 
 /* If we were called as "busybox..." */
 static int busybox_main(char **argv)
@@ -655,19 +658,20 @@ static int busybox_main(char **argv)
                 full_write2_str(bb_banner); /* reuse const string */
                 full_write2_str(" multi-call binary.\n"); /* reuse */
                 full_write2_str(
-                       "Copyright (C) 1998-2009 Erik Andersen, Rob Landley, Denys Vlasenko\n"
-                       "and others. Licensed under GPLv2.\n"
-                       "See source distribution for full notice.\n"
-                       "\n"
-                       "Usage: busybox [function] [arguments]...\n"
-                       "   or: function [arguments]...\n"
-                       "\n"
-                       "\tBusyBox is a multi-call binary that combines many common Unix\n"
-                       "\tutilities into a single executable.  Most people will create a\n"
-                       "\tlink to busybox for each function they wish to use and BusyBox\n"
-                       "\twill act like whatever it was invoked as.\n"
-                       "\n"
-                       "Currently defined functions:\n");
+                        "Copyright (C) 1998-2009 Erik Andersen, Rob Landley, Denys Vlasenko\n"
+                        "and others. Licensed under GPLv2.\n"
+                        "See source distribution for full notice.\n"
+                        "\n"
+                        "Usage: busybox [function] [arguments]...\n"
+                        "   or: function [arguments]...\n"
+                        "\n"
+                        "\tBusyBox is a multi-call binary that combines many common Unix\n"
+                        "\tutilities into a single executable.  Most people will create a\n"
+                        "\tlink to busybox for each function they wish to use and BusyBox\n"
+                        "\twill act like whatever it was invoked as.\n"
+                        "\n"
+                        "Currently defined functions:\n"
+                );
                 col = 0;
                 a = applet_names;
                 /* prevent last comma to be in the very last pos */
@@ -692,6 +696,23 @@ static int busybox_main(char **argv)
                 return 0;
         }
 
+        if (strncmp(argv[1], "--list", 6) == 0) {
+                unsigned i = 0;
+                const char *a = applet_names;
+                dup2(1, 2);
+                while (*a) {
+#if ENABLE_FEATURE_INSTALLER
+                        if (argv[1][6]) /* --list-path? */
+                                full_write2_str(install_dir[APPLET_INSTALL_LOC(i)] + 1);
+#endif
+                        full_write2_str(a);
+                        full_write2_str("\n");
+                        i++;
+                        a += strlen(a) + 1;
+                }
+                return 0;
+        }
+
         if (ENABLE_FEATURE_INSTALLER && strcmp(argv[1], "--install") == 0) {
                 int use_symbolic_links;
                 const char *busybox;
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 9a04c38bf..f7faf4639 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -42,14 +42,10 @@
 #include "libbb.h"
 #include "unicode.h"
 
-/* FIXME: obsolete CONFIG item? */
-#define ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT 0
-
 #ifdef TEST
 # define ENABLE_FEATURE_EDITING 0
 # define ENABLE_FEATURE_TAB_COMPLETION 0
 # define ENABLE_FEATURE_USERNAME_COMPLETION 0
-# define ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT 0
 #endif
 
 
@@ -66,9 +62,13 @@
 #endif
 
 
+#define SEQ_CLEAR_TILL_END_OF_SCREEN "\033[J"
+//#define SEQ_CLEAR_TILL_END_OF_LINE   "\033[K"
+
+
 #undef CHAR_T
 #if ENABLE_UNICODE_SUPPORT
-# define BB_NUL L'\0'
+# define BB_NUL ((wchar_t)0)
 # define CHAR_T wchar_t
 static bool BB_isspace(CHAR_T c) { return ((unsigned)c < 256 && isspace(c)); }
 # if ENABLE_FEATURE_EDITING_VI
@@ -92,6 +92,14 @@ static bool BB_ispunct(CHAR_T c) { return ((unsigned)c < 256 && ispunct(c)); }
 #endif
 
 
+# if ENABLE_UNICODE_PRESERVE_BROKEN
+#  define unicode_mark_raw_byte(wc)   ((wc) | 0x20000000)
+#  define unicode_is_raw_byte(wc)     ((wc) & 0x20000000)
+# else
+#  define unicode_is_raw_byte(wc)     0
+# endif
+
+
 enum {
         /* We use int16_t for positions, need to limit line len */
         MAX_LINELEN = CONFIG_FEATURE_EDITING_MAX_LEN < 0x7ff0
@@ -208,42 +216,107 @@ static size_t load_string(const char *src, int maxsize)
         ssize_t len = mbstowcs(command_ps, src, maxsize - 1);
         if (len < 0)
                 len = 0;
-        command_ps[len] = L'\0';
+        command_ps[len] = 0;
         return len;
 }
-static size_t save_string(char *dst, int maxsize)
+static unsigned save_string(char *dst, unsigned maxsize)
 {
+# if !ENABLE_UNICODE_PRESERVE_BROKEN
         ssize_t len = wcstombs(dst, command_ps, maxsize - 1);
         if (len < 0)
                 len = 0;
         dst[len] = '\0';
         return len;
+# else
+        unsigned dstpos = 0;
+        unsigned srcpos = 0;
+
+        maxsize--;
+        while (dstpos < maxsize) {
+                wchar_t wc;
+                int n = srcpos;
+                while ((wc = command_ps[srcpos]) != 0
+                    && !unicode_is_raw_byte(wc)
+                ) {
+                        srcpos++;
+                }
+                command_ps[srcpos] = 0;
+                n = wcstombs(dst + dstpos, command_ps + n, maxsize - dstpos);
+                if (n < 0) /* should not happen */
+                        break;
+                dstpos += n;
+                if (wc == 0) /* usually is */
+                        break;
+                /* We do have invalid byte here! */
+                command_ps[srcpos] = wc; /* restore it */
+                srcpos++;
+                if (dstpos == maxsize)
+                        break;
+                dst[dstpos++] = (char) wc;
+        }
+        dst[dstpos] = '\0';
+        return dstpos;
+# endif
 }
 /* I thought just fputwc(c, stdout) would work. But no... */
 static void BB_PUTCHAR(wchar_t c)
 {
         char buf[MB_CUR_MAX + 1];
         mbstate_t mbst = { 0 };
-        ssize_t len = wcrtomb(buf, c, &mbst);
+        ssize_t len;
 
+        len = wcrtomb(buf, c, &mbst);
         if (len > 0) {
                 buf[len] = '\0';
                 fputs(buf, stdout);
         }
 }
-#else
+# if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS
+static wchar_t adjust_width_and_validate_wc(unsigned *width_adj, wchar_t wc)
+# else
+static wchar_t adjust_width_and_validate_wc(wchar_t wc)
+#  define adjust_width_and_validate_wc(width_adj, wc) \
+        ((*(width_adj))++, adjust_width_and_validate_wc(wc))
+# endif
+{
+        int w = 1;
+
+        if (unicode_status == UNICODE_ON) {
+                if (wc > CONFIG_LAST_SUPPORTED_WCHAR) {
+                        /* note: also true for unicode_is_raw_byte(wc) */
+                        goto subst;
+                }
+                w = wcwidth(wc);
+                if ((ENABLE_UNICODE_COMBINING_WCHARS && w < 0)
+                 || (!ENABLE_UNICODE_COMBINING_WCHARS && w <= 0)
+                 || (!ENABLE_UNICODE_WIDE_WCHARS && w > 1)
+                ) {
+ subst:
+                        w = 1;
+                        wc = CONFIG_SUBST_WCHAR;
+                }
+        }
+
+# if ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS
+        *width_adj += w;
+#endif
+        return wc;
+}
+#else /* !UNICODE */
 static size_t load_string(const char *src, int maxsize)
 {
         safe_strncpy(command_ps, src, maxsize);
         return strlen(command_ps);
 }
 # if ENABLE_FEATURE_TAB_COMPLETION
-static void save_string(char *dst, int maxsize)
+static void save_string(char *dst, unsigned maxsize)
 {
         safe_strncpy(dst, command_ps, maxsize);
 }
 # endif
 # define BB_PUTCHAR(c) bb_putchar(c)
+/* Should never be called: */
+int adjust_width_and_validate_wc(unsigned *width_adj, int wc);
 #endif
 
 
@@ -251,38 +324,35 @@ static void save_string(char *dst, int maxsize)
  * Advance cursor on screen. If we reached right margin, scroll text up
  * and remove terminal margin effect by printing 'next_char' */
 #define HACK_FOR_WRONG_WIDTH 1
-#if HACK_FOR_WRONG_WIDTH
-static void cmdedit_set_out_char(void)
-#define cmdedit_set_out_char(next_char) cmdedit_set_out_char()
-#else
-static void cmdedit_set_out_char(int next_char)
-#endif
+static void put_cur_glyph_and_inc_cursor(void)
 {
         CHAR_T c = command_ps[cursor];
+        unsigned width = 0;
+        int ofs_to_right;
 
         if (c == BB_NUL) {
                 /* erase character after end of input string */
                 c = ' ';
+        } else {
+                /* advance cursor only if we aren't at the end yet */
+                cursor++;
+                if (unicode_status == UNICODE_ON) {
+                        IF_UNICODE_WIDE_WCHARS(width = cmdedit_x;)
+                        c = adjust_width_and_validate_wc(&cmdedit_x, c);
+                        IF_UNICODE_WIDE_WCHARS(width = cmdedit_x - width;)
+                } else {
+                        cmdedit_x++;
+                }
         }
-#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
-        /* Display non-printable characters in reverse */
-        if (!BB_isprint(c)) {
-                if (c >= 128)
-                        c -= 128;
-                if (c < ' ')
-                        c += '@';
-                if (c == 127)
-                        c = '?';
-                printf("\033[7m%c\033[0m", c);
-        } else
-#endif
-        {
+
+        ofs_to_right = cmdedit_x - cmdedit_termw;
+        if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right <= 0) {
+                /* c fits on this line */
                 BB_PUTCHAR(c);
         }
-        if (++cmdedit_x >= cmdedit_termw) {
-                /* terminal is scrolled down */
-                cmdedit_y++;
-                cmdedit_x = 0;
+
+        if (ofs_to_right >= 0) {
+                /* we go to the next line */
 #if HACK_FOR_WRONG_WIDTH
                 /* This works better if our idea of term width is wrong
                  * and it is actually wider (often happens on serial lines).
@@ -293,55 +363,83 @@ static void cmdedit_set_out_char(int next_char)
                  * this will break things: there will be one extra empty line */
                 puts("\r"); /* + implicit '\n' */
 #else
-                /* Works ok only if cmdedit_termw is correct */
-                /* destroy "(auto)margin" */
-                bb_putchar(next_char);
+                /* VT-10x terminals don't wrap cursor to next line when last char
+                 * on the line is printed - cursor stays "over" this char.
+                 * Need to print _next_ char too (first one to appear on next line)
+                 * to make cursor move down to next line.
+                 */
+                /* Works ok only if cmdedit_termw is correct. */
+                c = command_ps[cursor];
+                if (c == BB_NUL)
+                        c = ' ';
+                BB_PUTCHAR(c);
                 bb_putchar('\b');
 #endif
+                cmdedit_y++;
+                if (!ENABLE_UNICODE_WIDE_WCHARS || ofs_to_right == 0) {
+                        width = 0;
+                } else { /* ofs_to_right > 0 */
+                        /* wide char c didn't fit on prev line */
+                        BB_PUTCHAR(c);
+                }
+                cmdedit_x = width;
         }
-// Huh? What if command_ps[cursor] == BB_NUL (we are at the end already?)
-        cursor++;
 }
 
 /* Move to end of line (by printing all chars till the end) */
-static void input_end(void)
+static void put_till_end_and_adv_cursor(void)
 {
         while (cursor < command_len)
-                cmdedit_set_out_char(' ');
+                put_cur_glyph_and_inc_cursor();
 }
 
 /* Go to the next line */
 static void goto_new_line(void)
 {
-        input_end();
-        if (cmdedit_x)
+        put_till_end_and_adv_cursor();
+        if (cmdedit_x != 0)
                 bb_putchar('\n');
 }
 
-
-static void out1str(const char *s)
+static void beep(void)
 {
-        if (s)
-                fputs(s, stdout);
+        bb_putchar('\007');
 }
 
-static void beep(void)
+static void put_prompt(void)
 {
-        bb_putchar('\007');
+        unsigned w;
+
+        fputs(cmdedit_prompt, stdout);
+        fflush_all();
+        cursor = 0;
+        w = cmdedit_termw; /* read volatile var once */
+        cmdedit_y = cmdedit_prmt_len / w; /* new quasireal y */
+        cmdedit_x = cmdedit_prmt_len % w;
 }
 
 /* Move back one character */
 /* (optimized for slow terminals) */
 static void input_backward(unsigned num)
 {
-        int count_y;
-
         if (num > cursor)
                 num = cursor;
-        if (!num)
+        if (num == 0)
                 return;
         cursor -= num;
 
+        if ((ENABLE_UNICODE_COMBINING_WCHARS || ENABLE_UNICODE_WIDE_WCHARS)
+         && unicode_status == UNICODE_ON
+        ) {
+                /* correct NUM to be equal to _screen_ width */
+                int n = num;
+                num = 0;
+                while (--n >= 0)
+                        adjust_width_and_validate_wc(&num, command_ps[cursor + n]);
+                if (num == 0)
+                        return;
+        }
+
         if (cmdedit_x >= num) {
                 cmdedit_x -= num;
                 if (num <= 4) {
@@ -361,38 +459,61 @@ static void input_backward(unsigned num)
         }
 
         /* Need to go one or more lines up */
-        num -= cmdedit_x;
-        {
-                unsigned w = cmdedit_termw; /* volatile var */
-                count_y = 1 + (num / w);
-                cmdedit_y -= count_y;
-                cmdedit_x = w * count_y - num;
+        if (ENABLE_UNICODE_WIDE_WCHARS) {
+                /* With wide chars, it is hard to "backtrack"
+                 * and reliably figure out where to put cursor.
+                 * Example (<> is a wide char; # is an ordinary char, _ cursor):
+                 * |prompt: <><> |
+                 * |<><><><><><> |
+                 * |_            |
+                 * and user presses left arrow. num = 1, cmdedit_x = 0,
+                 * We need to go up one line, and then - how do we know that
+                 * we need to go *10* positions to the right? Because
+                 * |prompt: <>#<>|
+                 * |<><><>#<><><>|
+                 * |_            |
+                 * in this situation we need to go *11* positions to the right.
+                 *
+                 * A simpler thing to do is to redraw everything from the start
+                 * up to new cursor position (which is already known):
+                 */
+                unsigned sv_cursor;
+                /* go to 1st column; go up to first line */
+                printf("\r" "\033[%uA", cmdedit_y);
+                cmdedit_y = 0;
+                sv_cursor = cursor;
+                put_prompt(); /* sets cursor to 0 */
+                while (cursor < sv_cursor)
+                        put_cur_glyph_and_inc_cursor();
+        } else {
+                int lines_up;
+                unsigned width;
+                /* num = chars to go back from the beginning of current line: */
+                num -= cmdedit_x;
+                width = cmdedit_termw; /* read volatile var once */
+                /* num=1...w: one line up, w+1...2w: two, etc: */
+                lines_up = 1 + (num - 1) / width;
+                cmdedit_x = (width * cmdedit_y - num) % width;
+                cmdedit_y -= lines_up;
+                /* go to 1st column; go up */
+                printf("\r" "\033[%uA", lines_up);
+                /* go to correct column.
+                 * xterm, konsole, Linux VT interpret 0 as 1 below! wow.
+                 * need to *make sure* we skip it if cmdedit_x == 0 */
+                if (cmdedit_x)
+                        printf("\033[%uC", cmdedit_x);
         }
-        /* go to 1st column; go up; go to correct column */
-        printf("\r" "\033[%dA" "\033[%dC", count_y, cmdedit_x);
-}
-
-static void put_prompt(void)
-{
-        unsigned w;
-
-        out1str(cmdedit_prompt);
-        fflush_all();
-        cursor = 0;
-        w = cmdedit_termw; /* read volatile var once */
-        cmdedit_y = cmdedit_prmt_len / w; /* new quasireal y */
-        cmdedit_x = cmdedit_prmt_len % w;
 }
 
 /* draw prompt, editor line, and clear tail */
 static void redraw(int y, int back_cursor)
 {
-        if (y > 0)  /* up to start y */
+        if (y > 0) /* up y lines */
                 printf("\033[%uA", y);
         bb_putchar('\r');
         put_prompt();
-        input_end();      /* rewrite */
-        printf("\033[J"); /* erase after cursor */
+        put_till_end_and_adv_cursor();
+        printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
         input_backward(back_cursor);
 }
 
@@ -426,8 +547,9 @@ static void input_delete(int save)
                          * simplified into (command_len - j) */
                         (command_len - j) * sizeof(command_ps[0]));
         command_len--;
-        input_end();                    /* rewrite new line */
-        cmdedit_set_out_char(' ');      /* erase char */
+        put_till_end_and_adv_cursor();
+        /* Last char is still visible, erase it (and more) */
+        printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
         input_backward(cursor - j);     /* back to old pos cursor */
 }
 
@@ -445,7 +567,7 @@ static void put(void)
                         (command_len - cursor + 1) * sizeof(command_ps[0]));
         memcpy(command_ps + cursor, delbuf, j * sizeof(command_ps[0]));
         command_len += j;
-        input_end();                    /* rewrite new line */
+        put_till_end_and_adv_cursor();
         input_backward(cursor - ocursor - j + 1); /* at end of new text */
 }
 #endif
@@ -463,7 +585,7 @@ static void input_backspace(void)
 static void input_forward(void)
 {
         if (cursor < command_len)
-                cmdedit_set_out_char(command_ps[cursor + 1]);
+                put_cur_glyph_and_inc_cursor();
 }
 
 #if ENABLE_FEATURE_TAB_COMPLETION
@@ -721,21 +843,13 @@ static NOINLINE int find_match(char *matchBuf, int *len_with_quotes)
         }
 
         /* mask \+symbol and convert '\t' to ' ' */
-        for (i = j = 0; matchBuf[i]; i++, j++)
+        for (i = j = 0; matchBuf[i]; i++, j++) {
                 if (matchBuf[i] == '\\') {
                         collapse_pos(j, j + 1);
                         int_buf[j] |= QUOT;
                         i++;
-#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
-                        if (matchBuf[i] == '\t')  /* algorithm equivalent */
-                                int_buf[j] = ' ' | QUOT;
-#endif
                 }
-#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
-                else if (matchBuf[i] == '\t')
-                        int_buf[j] = ' ';
-#endif
-
+        }
         /* mask "symbols" or 'symbols' */
         c2 = 0;
         for (i = 0; int_buf[i]; i++) {
@@ -1509,7 +1623,7 @@ static void ask_terminal(void)
         pfd.events = POLLIN;
         if (safe_poll(&pfd, 1, 0) == 0) {
                 S.sent_ESC_br6n = 1;
-                out1str("\033" "[6n");
+                fputs("\033" "[6n", stdout);
                 fflush_all(); /* make terminal see it ASAP! */
         }
 }
@@ -1727,13 +1841,11 @@ static int lineedit_read_key(char *read_key_buffer)
  pushback:
                                 /* Invalid sequence. Save all "bad bytes" except first */
                                 read_key_ungets(read_key_buffer, unicode_buf + 1, unicode_idx - 1);
-                                /*
-                                 * ic = unicode_buf[0] sounds even better, but currently
-                                 * this does not work: wchar_t[] -> char[] conversion
-                                 * when lineedit finishes mangles such "raw bytes"
-                                 * (by misinterpreting them as unicode chars):
-                                 */
+# if !ENABLE_UNICODE_PRESERVE_BROKEN
                                 ic = CONFIG_SUBST_WCHAR;
+# else
+                                ic = unicode_mark_raw_byte(unicode_buf[0]);
+# endif
                         } else {
                                 /* Valid unicode char, return its code */
                                 ic = wc;
@@ -1925,7 +2037,7 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
                 case CTRL('E'):
                 vi_case('$'|VI_CMDMODE_BIT:)
                         /* Control-e -- End of line */
-                        input_end();
+                        put_till_end_and_adv_cursor();
                         break;
                 case CTRL('F'):
                 vi_case('l'|VI_CMDMODE_BIT:)
@@ -1954,12 +2066,12 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
                         /* Control-k -- clear to end of line */
                         command_ps[cursor] = BB_NUL;
                         command_len = cursor;
-                        printf("\033[J");
+                        printf(SEQ_CLEAR_TILL_END_OF_SCREEN);
                         break;
                 case CTRL('L'):
                 vi_case(CTRL('L')|VI_CMDMODE_BIT:)
                         /* Control-l -- clear screen */
-                        printf("\033[H");
+                        printf("\033[H"); /* cursor to top,left */
                         redraw(0, command_len - cursor);
                         break;
 #if MAX_HISTORY > 0
@@ -2010,7 +2122,7 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
                         vi_cmdmode = 0;
                         break;
                 case 'A'|VI_CMDMODE_BIT:
-                        input_end();
+                        put_till_end_and_adv_cursor();
                         vi_cmdmode = 0;
                         break;
                 case 'x'|VI_CMDMODE_BIT:
@@ -2170,7 +2282,7 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
                         input_backward(cursor);
                         break;
                 case KEYCODE_END:
-                        input_end();
+                        put_till_end_and_adv_cursor();
                         break;
 
                 default:
@@ -2230,7 +2342,7 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
                                 /* We are at the end, append */
                                 command_ps[cursor] = ic;
                                 command_ps[cursor + 1] = BB_NUL;
-                                cmdedit_set_out_char(' ');
+                                put_cur_glyph_and_inc_cursor();
                                 if (unicode_bidi_isrtl(ic))
                                         input_backward(1);
                         } else {
@@ -2243,8 +2355,7 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
                                 /* is right-to-left char, or neutral one (e.g. comma) was just added to rtl text? */
                                 if (!isrtl_str())
                                         sc++; /* no */
-                                /* rewrite from cursor */
-                                input_end();
+                                put_till_end_and_adv_cursor();
                                 /* to prev x pos + 1 */
                                 input_backward(cursor - sc);
                         }
@@ -2345,9 +2456,6 @@ int main(int argc, char **argv)
                 "% ";
 #endif
 
-#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
-        setlocale(LC_ALL, "");
-#endif
         while (1) {
                 int l;
                 l = read_line_input(prompt, buff);
diff --git a/libbb/read.c b/libbb/read.c
index 06ce29718..f3af144f0 100644
--- a/libbb/read.c
+++ b/libbb/read.c
@@ -6,7 +6,6 @@
  *
  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
-
 #include "libbb.h"
 
 #define ZIPPED (ENABLE_FEATURE_SEAMLESS_LZMA \
@@ -16,7 +15,7 @@
 )
 
 #if ZIPPED
-#include "unarchive.h"
+# include "unarchive.h"
 #endif
 
 ssize_t FAST_FUNC safe_read(int fd, void *buf, size_t count)
@@ -306,14 +305,11 @@ void* FAST_FUNC xmalloc_xopen_read_close(const char *filename, size_t *maxsz_p)
         return buf;
 }
 
-int FAST_FUNC open_zipped(const char *fname)
+#if ZIPPED
+int FAST_FUNC setup_unzip_on_fd(int fd /*, int fail_if_not_detected*/)
 {
-#if !ZIPPED
-        return open(fname, O_RDONLY);
-#else
+        const int fail_if_not_detected = 1;
         unsigned char magic[2];
-        char *sfx;
-        int fd;
 #if BB_MMU
         IF_DESKTOP(long long) int FAST_FUNC (*xformer)(int src_fd, int dst_fd);
         enum { xformer_prog = 0 };
@@ -322,6 +318,62 @@ int FAST_FUNC open_zipped(const char *fname)
         const char *xformer_prog;
 #endif
 
+        /* .gz and .bz2 both have 2-byte signature, and their
+         * unpack_XXX_stream wants this header skipped. */
+        xread(fd, &magic, 2);
+        if (ENABLE_FEATURE_SEAMLESS_GZ
+         && magic[0] == 0x1f && magic[1] == 0x8b
+        ) {
+# if BB_MMU
+                xformer = unpack_gz_stream;
+# else
+                xformer_prog = "gunzip";
+# endif
+                goto found_magic;
+        }
+        if (ENABLE_FEATURE_SEAMLESS_BZ2
+         && magic[0] == 'B' && magic[1] == 'Z'
+        ) {
+# if BB_MMU
+                xformer = unpack_bz2_stream;
+# else
+                xformer_prog = "bunzip2";
+# endif
+                goto found_magic;
+        }
+// TODO: xz format support. rpm adopted it, "rpm -i FILE.rpm" badly needs this.
+// Signature: 0xFD, '7', 'z', 'X', 'Z', 0x00
+// More info at: http://tukaani.org/xz/xz-file-format.txt
+
+        /* No known magic seen */
+        if (fail_if_not_detected)
+                bb_error_msg_and_die("no gzip"
+                        IF_FEATURE_SEAMLESS_BZ2("/bzip2")
+                        " magic");
+        xlseek(fd, -2, SEEK_CUR);
+        return fd;
+
+ found_magic:
+# if !BB_MMU
+        /* NOMMU version of open_transformer execs
+         * an external unzipper that wants
+         * file position at the start of the file */
+        xlseek(fd, -2, SEEK_CUR);
+# endif
+        open_transformer(fd, xformer, xformer_prog);
+
+        return fd;
+}
+#endif /* ZIPPED */
+
+int FAST_FUNC open_zipped(const char *fname)
+{
+#if !ZIPPED
+        return open(fname, O_RDONLY);
+#else
+        char *sfx;
+        int fd;
+
         fd = open(fname, O_RDONLY);
         if (fd < 0)
                 return fd;
@@ -335,40 +387,7 @@ int FAST_FUNC open_zipped(const char *fname)
                 if ((ENABLE_FEATURE_SEAMLESS_GZ && strcmp(sfx, ".gz") == 0)
                  || (ENABLE_FEATURE_SEAMLESS_BZ2 && strcmp(sfx, ".bz2") == 0)
                 ) {
-                        /* .gz and .bz2 both have 2-byte signature, and their
-                         * unpack_XXX_stream wants this header skipped. */
-                        xread(fd, &magic, 2);
-#if ENABLE_FEATURE_SEAMLESS_GZ
-#if BB_MMU
-                        xformer = unpack_gz_stream;
-#else
-                        xformer_prog = "gunzip";
-#endif
-#endif
-                        if (!ENABLE_FEATURE_SEAMLESS_GZ
-                         || magic[0] != 0x1f || magic[1] != 0x8b
-                        ) {
-                                if (!ENABLE_FEATURE_SEAMLESS_BZ2
-                                 || magic[0] != 'B' || magic[1] != 'Z'
-                                ) {
-                                        bb_error_msg_and_die("no gzip"
-                                                IF_FEATURE_SEAMLESS_BZ2("/bzip2")
-                                                " magic");
-                                }
-#if BB_MMU
-                                xformer = unpack_bz2_stream;
-#else
-                                xformer_prog = "bunzip2";
-#endif
-                        } else {
-#if !BB_MMU
-                                /* NOMMU version of open_transformer execs
-                                 * an external unzipper that wants
-                                 * file position at the start of the file */
-                                xlseek(fd, 0, SEEK_SET);
-#endif
-                        }
-                        open_transformer(fd, xformer, xformer_prog);
+                        setup_unzip_on_fd(fd /*, fail_if_not_detected: 1*/);
                 }
         }
 
diff --git a/libbb/read_key.c b/libbb/read_key.c
index 8422976c9..64557ab14 100644
--- a/libbb/read_key.c
+++ b/libbb/read_key.c
@@ -214,7 +214,7 @@ int64_t FAST_FUNC read_key(int fd, char *buffer, int timeout)
                 }
                 n++;
                 /* Try to decipher "ESC [ NNN ; NNN R" sequence */
-                if (ENABLE_FEATURE_EDITING_ASK_TERMINAL
+                if ((ENABLE_FEATURE_EDITING_ASK_TERMINAL || ENABLE_FEATURE_VI_ASK_TERMINAL)
                  && n >= 5
                  && buffer[0] == '['
                  && buffer[n-1] == 'R'
diff --git a/libbb/time.c b/libbb/time.c
index 5cd04268c..8d176e52e 100644
--- a/libbb/time.c
+++ b/libbb/time.c
@@ -68,6 +68,16 @@ void FAST_FUNC parse_datestr(const char *date_str, struct tm *ptm)
                                 end = '\0';
                         /* else end != NUL and we error out */
                 }
+        } else if (date_str[0] == '@') {
+                time_t t = bb_strtol(date_str + 1, NULL, 10);
+                if (!errno) {
+                        struct tm *lt = localtime(&t);
+                        if (lt) {
+                                *ptm = *lt;
+                                return;
+                        }
+                }
+                end = '1';
         } else {
                 /* Googled the following on an old date manpage:
                  *
diff --git a/libbb/unicode.c b/libbb/unicode.c
index 83e70b412..b2c28239b 100644
--- a/libbb/unicode.c
+++ b/libbb/unicode.c
@@ -240,7 +240,7 @@ int FAST_FUNC iswpunct(wint_t wc)
 }
 
 
-# if LAST_SUPPORTED_WCHAR >= 0x300
+# if CONFIG_LAST_SUPPORTED_WCHAR >= 0x300
 struct interval {
         uint16_t first;
         uint16_t last;
@@ -418,12 +418,11 @@ static int in_uint16_table(unsigned ucs, const uint16_t *table, unsigned max)
  * This implementation assumes that wchar_t characters are encoded
  * in ISO 10646.
  */
-static int wcwidth(unsigned ucs)
+int FAST_FUNC wcwidth(unsigned ucs)
 {
-# if LAST_SUPPORTED_WCHAR >= 0x300
+# if CONFIG_LAST_SUPPORTED_WCHAR >= 0x300
         /* sorted list of non-overlapping intervals of non-spacing characters */
         /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
-        static const struct interval combining[] = {
 #  define BIG_(a,b) { a, b },
 #  define PAIR(a,b)
 #  define ARRAY /* PAIR if < 0x4000 and no more than 4 chars big */ \
@@ -557,10 +556,9 @@ static int wcwidth(unsigned ucs)
                 BIG_(0xFE20, 0xFE23) \
                 BIG_(0xFEFF, 0xFEFF) \
                 BIG_(0xFFF9, 0xFFFB)
-                ARRAY
+        static const struct interval combining[] = { ARRAY };
 #  undef BIG_
 #  undef PAIR
-        };
 #  define BIG_(a,b)
 #  define PAIR(a,b) (a << 2) | (b-a),
         static const uint16_t combining1[] = { ARRAY };
@@ -581,14 +579,14 @@ static int wcwidth(unsigned ucs)
         if ((ucs & ~0x80) < 0x20 || ucs == 0x7f)
                 return -1;
         /* Quick abort if it is an obviously invalid char */
-        if (ucs > LAST_SUPPORTED_WCHAR)
+        if (ucs > CONFIG_LAST_SUPPORTED_WCHAR)
                 return -1;
 
         /* Optimization: no combining chars below 0x300 */
-        if (LAST_SUPPORTED_WCHAR < 0x300 || ucs < 0x300)
+        if (CONFIG_LAST_SUPPORTED_WCHAR < 0x300 || ucs < 0x300)
                 return 1;
 
-# if LAST_SUPPORTED_WCHAR >= 0x300
+# if CONFIG_LAST_SUPPORTED_WCHAR >= 0x300
         /* Binary search in table of non-spacing characters */
         if (in_interval_table(ucs, combining, ARRAY_SIZE(combining) - 1))
                 return 0;
@@ -596,25 +594,25 @@ static int wcwidth(unsigned ucs)
                 return 0;
 
         /* Optimization: all chars below 0x1100 are not double-width */
-        if (LAST_SUPPORTED_WCHAR < 0x1100 || ucs < 0x1100)
+        if (CONFIG_LAST_SUPPORTED_WCHAR < 0x1100 || ucs < 0x1100)
                 return 1;
 
-#  if LAST_SUPPORTED_WCHAR >= 0x1100
+#  if CONFIG_LAST_SUPPORTED_WCHAR >= 0x1100
         /* Invalid code points: */
         /* High (d800..dbff) and low (dc00..dfff) surrogates (valid only in UTF16) */
         /* Private Use Area (e000..f8ff) */
         /* Noncharacters fdd0..fdef */
-        if ((LAST_SUPPORTED_WCHAR >= 0xd800 && ucs >= 0xd800 && ucs <= 0xf8ff)
-         || (LAST_SUPPORTED_WCHAR >= 0xfdd0 && ucs >= 0xfdd0 && ucs <= 0xfdef)
+        if ((CONFIG_LAST_SUPPORTED_WCHAR >= 0xd800 && ucs >= 0xd800 && ucs <= 0xf8ff)
+         || (CONFIG_LAST_SUPPORTED_WCHAR >= 0xfdd0 && ucs >= 0xfdd0 && ucs <= 0xfdef)
         ) {
                 return -1;
         }
         /* 0xfffe and 0xffff in every plane are invalid */
-        if (LAST_SUPPORTED_WCHAR >= 0xfffe && ((ucs & 0xfffe) == 0xfffe)) {
+        if (CONFIG_LAST_SUPPORTED_WCHAR >= 0xfffe && ((ucs & 0xfffe) == 0xfffe)) {
                 return -1;
         }
 
-#   if LAST_SUPPORTED_WCHAR >= 0x10000
+#   if CONFIG_LAST_SUPPORTED_WCHAR >= 0x10000
         if (ucs >= 0x10000) {
                 /* Combining chars in Supplementary Multilingual Plane 0x1xxxx */
                 static const struct interval combining0x10000[] = {
@@ -627,7 +625,7 @@ static int wcwidth(unsigned ucs)
                 if (in_interval_table(ucs ^ 0x10000, combining0x10000, ARRAY_SIZE(combining0x10000) - 1))
                         return 0;
                 /* Check a few non-spacing chars in Supplementary Special-purpose Plane 0xExxxx */
-                if (LAST_SUPPORTED_WCHAR >= 0xE0001
+                if (CONFIG_LAST_SUPPORTED_WCHAR >= 0xE0001
                  && (  ucs == 0xE0001
                     || (ucs >= 0xE0020 && ucs <= 0xE007F)
                     || (ucs >= 0xE0100 && ucs <= 0xE01EF)
@@ -646,7 +644,7 @@ static int wcwidth(unsigned ucs)
                 || ucs == 0x2329 /* left-pointing angle bracket; also CJK punct. char */
                 || ucs == 0x232a /* right-pointing angle bracket; also CJK punct. char */
                 || (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs != 0x303f) /* CJK ... Yi */
-#   if LAST_SUPPORTED_WCHAR >= 0xac00
+#   if CONFIG_LAST_SUPPORTED_WCHAR >= 0xac00
                 || (ucs >= 0xac00 && ucs <= 0xd7a3) /* Hangul Syllables */
                 || (ucs >= 0xf900 && ucs <= 0xfaff) /* CJK Compatibility Ideographs */
                 || (ucs >= 0xfe10 && ucs <= 0xfe19) /* Vertical forms */
@@ -668,7 +666,6 @@ int FAST_FUNC unicode_bidi_isrtl(wint_t wc)
          * http://www.unicode.org/Public/5.2.0/ucd/extracted/DerivedBidiClass.txt
          * Bidi_Class=Left_To_Right | Bidi_Class=Arabic_Letter
          */
-        static const struct interval rtl_b[] = {
 #  define BIG_(a,b) { a, b },
 #  define PAIR(a,b)
 #  define ARRAY \
@@ -723,10 +720,9 @@ int FAST_FUNC unicode_bidi_isrtl(wint_t wc)
                 {0x10E7F, 0x10FFF},
                 {0x1E800, 0x1EFFF}
                 */
-                ARRAY
+        static const struct interval rtl_b[] = { ARRAY };
 #  undef BIG_
 #  undef PAIR
-        };
 #  define BIG_(a,b)
 #  define PAIR(a,b) (a << 2) | (b-a),
         static const uint16_t rtl_p[] = { ARRAY };
@@ -755,7 +751,6 @@ int FAST_FUNC unicode_bidi_is_neutral_wchar(wint_t wc)
          * White_Space, Other_Neutral, European_Number, European_Separator,
          * European_Terminator, Arabic_Number, Common_Separator
          */
-        static const struct interval neutral_b[] = {
 #  define BIG_(a,b) { a, b },
 #  define PAIR(a,b)
 #  define ARRAY \
@@ -929,10 +924,9 @@ int FAST_FUNC unicode_bidi_is_neutral_wchar(wint_t wc)
                 {0x1F030, 0x1F093},
                 {0x1F100, 0x1F10A}
                 */
-                ARRAY
+        static const struct interval neutral_b[] = { ARRAY };
 #  undef BIG_
 #  undef PAIR
-        };
 #  define BIG_(a,b)
 #  define PAIR(a,b) (a << 2) | (b-a),
         static const uint16_t neutral_p[] = { ARRAY };
diff --git a/libbb/xfuncs.c b/libbb/xfuncs.c
index aec165f06..d93dd2af9 100644
--- a/libbb/xfuncs.c
+++ b/libbb/xfuncs.c
@@ -210,34 +210,40 @@ char* FAST_FUNC xmalloc_ttyname(int fd)
         return buf;
 }
 
-/* It is perfectly ok to pass in a NULL for either width or for
- * height, in which case that value will not be set.  */
-int FAST_FUNC get_terminal_width_height(int fd, unsigned *width, unsigned *height)
+static int wh_helper(int value, int def_val, const char *env_name, int *err)
 {
-        struct winsize win = { 0, 0, 0, 0 };
-        int ret = ioctl(fd, TIOCGWINSZ, &win);
-
-        if (height) {
-                if (!win.ws_row) {
-                        char *s = getenv("LINES");
-                        if (s) win.ws_row = atoi(s);
-                }
-                if (win.ws_row <= 1 || win.ws_row >= 30000)
-                        win.ws_row = 24;
-                *height = (int) win.ws_row;
-        }
-
-        if (width) {
-                if (!win.ws_col) {
-                        char *s = getenv("COLUMNS");
-                        if (s) win.ws_col = atoi(s);
+        if (value == 0) {
+                char *s = getenv(env_name);
+                if (s) {
+                        value = atoi(s);
+                        /* If LINES/COLUMNS are set, pretent that there is
+                         * no error getting w/h, this prevents some ugly
+                         * cursor tricks by our callers */
+                        *err = 0;
                 }
-                if (win.ws_col <= 1 || win.ws_col >= 30000)
-                        win.ws_col = 80;
-                *width = (int) win.ws_col;
         }
+        if (value <= 1 || value >= 30000)
+                value = def_val;
+        return value;
+}
 
-        return ret;
+/* It is perfectly ok to pass in a NULL for either width or for
+ * height, in which case that value will not be set.  */
+int FAST_FUNC get_terminal_width_height(int fd, unsigned *width, unsigned *height)
+{
+        struct winsize win;
+        int err;
+
+        win.ws_row = 0;
+        win.ws_col = 0;
+        /* I've seen ioctl returning 0, but row/col is (still?) 0.
+         * We treat that as an error too.  */
+        err = ioctl(fd, TIOCGWINSZ, &win) != 0 || win.ws_row == 0;
+        if (height)
+                *height = wh_helper(win.ws_row, 24, "LINES", &err);
+        if (width)
+                *width = wh_helper(win.ws_col, 80, "COLUMNS", &err);
+        return err;
 }
 
 int FAST_FUNC tcsetattr_stdin_TCSANOW(const struct termios *tp)