less: update line input so that it doesn't interfere with

screen update. Makes "man bash", [enter], [/],
<enter search pattern>, [enter] more usable - manpage
draws as you enter the pattern! Yay!!
less: fix bug where backspace wasn't actually deleting chars
less: "examine file with empty name" doesn't abort anymore.
libbb: add "all fatal signals" mask.

getch_nowait                                           -     207    +207
status_print                                           -     105    +105
examine_file                                          64      87     +23
move_cursor                                            -      16     +16
m_status_print                                       185     195     +10
less_main                                           1656    1663      +7
decode_format_string                                 790     795      +5
test_main                                            403     405      +2
process0_stdin                                       247     249      +2
passwd_main                                         1070    1072      +2
less_gets                                            196     178     -18
buffer_print                                         169      71     -98
less_getch                                           362     138    -224
------------------------------------------------------------------------------
(add/remove: 3/0 grow/shrink: 7/3 up/down: 379/-340)           Total: 39 bytes
   text    data     bss     dec     hex filename
 798329     740    7484  806553   c4e99 busybox_old
 798368     740    7484  806592   c4ec0 busybox_unstripped

2 files changed, 82 insertions, 46 deletions

diff --git a/include/libbb.h b/include/libbb.h
index eb8b2f620..873ab8798 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -274,9 +274,32 @@ char *xrealloc_getcwd_or_warn(char *cwd);
 
 char *xmalloc_follow_symlinks(const char *path);
 
-//enum {
-//      BB_SIGS_FATAL = ,
-//};
+enum {
+        /* bb_signals(BB_SIGS_FATAL, handler) catches all signals which
+         * otherwise would kill us, except for those resulting from bugs:
+         * SIGSEGV, SIGILL, SIGFPE.
+         * Other fatal signals not included (TODO?):
+         * SIGBUS   Bus error (bad memory access)
+         * SIGPOLL  Pollable event. Synonym of SIGIO
+         * SIGPROF  Profiling timer expired
+         * SIGSYS   Bad argument to routine
+         * SIGTRAP  Trace/breakpoint trap
+         */
+        BB_SIGS_FATAL = 0
+                + (1 << SIGHUP)
+                + (1 << SIGINT)
+                + (1 << SIGTERM)
+                + (1 << SIGPIPE)   // Write to pipe with no readers
+                + (1 << SIGQUIT)   // Quit from keyboard
+                + (1 << SIGABRT)   // Abort signal from abort(3)
+                + (1 << SIGALRM)   // Timer signal from alarm(2)
+                + (1 << SIGVTALRM) // Virtual alarm clock
+                + (1 << SIGXCPU)   // CPU time limit exceeded
+                + (1 << SIGXFSZ)   // File size limit exceeded
+                + (1 << SIGUSR1)   // Yes kids, these are also fatal!
+                + (1 << SIGUSR2)
+                + 0,
+};
 void bb_signals(int sigs, void (*f)(int));
 /* Unlike signal() and bb_signals, sets handler with sigaction()
  * and in a way that while signal handler is run, no other signals
diff --git a/miscutils/less.c b/miscutils/less.c
index 85c5ec536..4229dfe15 100644
--- a/miscutils/less.c
+++ b/miscutils/less.c
@@ -90,6 +90,7 @@ enum { pattern_valid = 0 };
 struct globals {
         int cur_fline; /* signed */
         int kbd_fd;  /* fd to get input from */
+        int less_gets_pos;
 /* last position in last line, taking into account tabs */
         size_t linepos;
         unsigned max_displayed_line;
@@ -123,6 +124,7 @@ struct globals {
 #define G (*ptr_to_globals)
 #define cur_fline           (G.cur_fline         )
 #define kbd_fd              (G.kbd_fd            )
+#define less_gets_pos       (G.less_gets_pos     )
 #define linepos             (G.linepos           )
 #define max_displayed_line  (G.max_displayed_line)
 #define max_fline           (G.max_fline         )
@@ -152,6 +154,7 @@ struct globals {
 #define term_less           (G.term_less         )
 #define INIT_G() do { \
                 PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
+                less_gets_pos = -1; \
                 empty_line_marker = "~"; \
                 num_files = 1; \
                 current_file = 1; \
@@ -385,6 +388,9 @@ static void m_status_print(void)
 {
         int percentage;
 
+        if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
+                return;
+
         clear_line();
         printf(HIGHLIGHT"%s", filename);
         if (num_files > 1)
@@ -408,6 +414,9 @@ static void status_print(void)
 {
         const char *p;
 
+        if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
+                return;
+
         /* Change the status if flags have been set */
 #if ENABLE_FEATURE_LESS_FLAGS
         if (option_mask32 & (FLAG_M|FLAG_m)) {
@@ -652,43 +661,46 @@ static void reinitialize(void)
         buffer_fill_and_print();
 }
 
-static void getch_nowait(char* input, int sz)
+static ssize_t getch_nowait(char* input, int sz)
 {
         ssize_t rd;
-        fd_set readfds;
- again:
-        fflush(stdout);
+        struct pollfd pfd[2];
 
-        /* NB: select returns whenever read will not block. Therefore:
-         * (a) with O_NONBLOCK'ed fds select will return immediately
-         * (b) if eof is reached, select will also return
-         *     because read will immediately return 0 bytes.
-         * Even if select says that input is available, read CAN block
+        pfd[0].fd = STDIN_FILENO;
+        pfd[0].events = POLLIN;
+        pfd[1].fd = kbd_fd;
+        pfd[1].events = POLLIN;
+ again:
+        tcsetattr(kbd_fd, TCSANOW, &term_less);
+        /* NB: select/poll returns whenever read will not block. Therefore:
+         * if eof is reached, select/poll will return immediately
+         * because read will immediately return 0 bytes.
+         * Even if select/poll says that input is available, read CAN block
          * (switch fd into O_NONBLOCK'ed mode to avoid it)
          */
-        FD_ZERO(&readfds);
+        rd = 1;
         if (max_fline <= cur_fline + max_displayed_line
          && eof_error > 0 /* did NOT reach eof yet */
         ) {
                 /* We are interested in stdin */
-                FD_SET(0, &readfds);
+                rd = 0;
         }
-        FD_SET(kbd_fd, &readfds);
-        tcsetattr(kbd_fd, TCSANOW, &term_less);
-        select(kbd_fd + 1, &readfds, NULL, NULL, NULL);
+        /* position cursor if line input is done */
+        if (less_gets_pos >= 0)
+                move_cursor(max_displayed_line + 2, less_gets_pos + 1);
+        fflush(stdout);
+        safe_poll(pfd + rd, 2 - rd, -1);
 
         input[0] = '\0';
-        ndelay_on(kbd_fd);
-        rd = read(kbd_fd, input, sz);
-        ndelay_off(kbd_fd);
-        if (rd < 0) {
-                /* No keyboard input, but we have input on stdin! */
-                if (errno != EAGAIN) /* Huh?? */
-                        return;
+        rd = safe_read(kbd_fd, input, sz); /* NB: kbd_fd is in O_NONBLOCK mode */
+        if (rd < 0 && errno == EAGAIN) {
+                /* No keyboard input -> we have input on stdin! */
                 read_lines();
                 buffer_fill_and_print();
                 goto again;
         }
+        set_tty_cooked();
+        return rd;
 }
 
 /* Grab a character from input without requiring the return key. If the
@@ -696,7 +708,7 @@ static void getch_nowait(char* input, int sz)
  * special return codes. Note that this function works best with raw input. */
 static int less_getch(void)
 {
-        char input[16];
+        unsigned char input[16];
         unsigned i;
  again:
         memset(input, 0, sizeof(input));
@@ -705,7 +717,6 @@ static int less_getch(void)
         /* Detect escape sequences (i.e. arrow keys) and handle
          * them accordingly */
         if (input[0] == '\033' && input[1] == '[') {
-                set_tty_cooked();
                 i = input[2] - REAL_KEY_UP;
                 if (i < 4)
                         return 20 + i;
@@ -724,8 +735,8 @@ static int less_getch(void)
         }
         /* Reject almost all control chars */
         i = input[0];
-        if (i < ' ' && i != 0x0d && i != 8) goto again;
-        set_tty_cooked();
+        if (i < ' ' && i != 0x0d && i != 8)
+                goto again;
         return i;
 }
 
@@ -734,22 +745,21 @@ static char* less_gets(int sz)
         char c;
         int i = 0;
         char *result = xzalloc(1);
-        while (1) {
-                fflush(stdout);
-
-                /* I be damned if I know why is it needed *repeatedly*,
-                 * but it is needed. Is it because of stdio? */
-                tcsetattr(kbd_fd, TCSANOW, &term_less);
 
+        while (1) {
                 c = '\0';
-                read(kbd_fd, &c, 1);
-                if (c == 0x0d)
+                less_gets_pos = sz + i;
+                getch_nowait(&c, 1);
+                if (c == 0x0d) {
+                        less_gets_pos = -1;
                         return result;
+                }
                 if (c == 0x7f)
                         c = 8;
                 if (c == 8 && i) {
                         printf("\x8 \x8");
                         i--;
+                        result[i] = '\0';
                 }
                 if (c < ' ')
                         continue;
@@ -764,9 +774,17 @@ static char* less_gets(int sz)
 
 static void examine_file(void)
 {
+        char *new_fname;
+
         print_statusline("Examine: ");
+        new_fname = less_gets(sizeof("Examine: ")-1);
+        if (!new_fname[0]) {
+                free(new_fname);
+                status_print();
+                return;
+        }
         free(filename);
-        filename = less_gets(sizeof("Examine: ")-1);
+        filename = new_fname;
         /* files start by = argv. why we assume that argv is infinitely long??
         files[num_files] = filename;
         current_file = num_files + 1;
@@ -1087,7 +1105,7 @@ static void save_input_to_file(void)
 
         print_statusline("Log file: ");
         current_line = less_gets(sizeof("Log file: ")-1);
-        if (strlen(current_line) > 0) {
+        if (current_line[0]) {
                 fp = fopen(current_line, "w");
                 if (!fp) {
                         msg = "Error opening log file";
@@ -1334,6 +1352,7 @@ int less_main(int argc, char **argv)
         kbd_fd = open(CURRENT_TTY, O_RDONLY);
         if (kbd_fd < 0)
                 return bb_cat(argv);
+        ndelay_on(kbd_fd);
 
         if (!num_files) {
                 if (isatty(STDIN_FILENO)) {
@@ -1354,11 +1373,9 @@ int less_main(int argc, char **argv)
         if (option_mask32 & FLAG_TILDE)
                 empty_line_marker = "";
 
+        bb_signals(BB_SIGS_FATAL, sig_catcher);
+
         tcgetattr(kbd_fd, &term_orig);
-        bb_signals(0
-                + (1 << SIGTERM)
-                + (1 << SIGINT)
-                , sig_catcher);
         term_less = term_orig;
         term_less.c_lflag &= ~(ICANON | ECHO);
         term_less.c_iflag &= ~(IXON | ICRNL);
@@ -1366,10 +1383,6 @@ int less_main(int argc, char **argv)
         term_less.c_cc[VMIN] = 1;
         term_less.c_cc[VTIME] = 0;
 
-        /* Want to do it just once, but it doesn't work, */
-        /* so we are redoing it (see code above). Mystery... */
-        /*tcsetattr(kbd_fd, TCSANOW, &term_less);*/
-
         reinitialize();
         while (1) {
                 keypress = less_getch();