Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/miscutils/less.c

Timestamp:

Dec 20, 2016, 4:07:32 PM (7 years ago)

Author:

Bruno Cornec

Message:

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.

Location:

branches/3.3

Files:

• . (copied) (copied from branches/3.2 )
• mindi-busybox/miscutils/less.c (modified) (37 diffs)

branches/3.3/mindi-busybox/miscutils/less.c

@@ -48 +48 @@
 //config:   help
 //config:     The -M/-m flag enables a more sophisticated status line.
+//config:
+//config:config FEATURE_LESS_TRUNCATE
+//config:   bool "Enable -S"
+//config:   default y
+//config:   depends on LESS
+//config:   help
+//config:     The -S flag causes long lines to be truncated rather than
+//config:     wrapped.
 //config:
 //config:config FEATURE_LESS_MARKS
@@ -99 +107 @@
 
 //usage:#define less_trivial_usage
-//usage:       "[-E" IF_FEATURE_LESS_FLAGS("Mm") "Nh~I?] [FILE]..."
+//usage:       "[-E" IF_FEATURE_LESS_REGEXP("I")IF_FEATURE_LESS_FLAGS("Mm")
+//usage:       "N" IF_FEATURE_LESS_TRUNCATE("S") "h~] [FILE]..."
 //usage:#define less_full_usage "\n\n"
 //usage:       "View FILE (or stdin) one screenful at a time\n"
 //usage:     "\n    -E  Quit once the end of a file is reached"
+//usage:    IF_FEATURE_LESS_REGEXP(
+//usage:     "\n    -I  Ignore case in all searches"
+//usage:    )
 //usage:    IF_FEATURE_LESS_FLAGS(
 //usage:     "\n    -M,-m   Display status line with line numbers"
@@ -108 +120 @@
 //usage:    )
 //usage:     "\n    -N  Prefix line number to each line"
-//usage:     "\n    -I  Ignore case in all searches"
+//usage:    IF_FEATURE_LESS_TRUNCATE(
+//usage:     "\n    -S  Truncate long lines"
+//usage:    )
 //usage:     "\n    -~  Suppress ~s displayed past EOF"
 
@@ -114 +128 @@
 
 #include "libbb.h"
+#include "common_bufsiz.h"
 #if ENABLE_FEATURE_LESS_REGEXP
 #include "xregex.h"
@@ -143 +158 @@
     FLAG_TILDE = 1 << 4,
     FLAG_I = 1 << 5,
-    FLAG_S = (1 << 6) * ENABLE_FEATURE_LESS_DASHCMD,
+    FLAG_S = (1 << 6) * ENABLE_FEATURE_LESS_TRUNCATE,
 /* hijack command line options variable for internal state vars */
     LESS_STATE_MATCH_BACKWARDS = 1 << 15,
@@ -175 +190 @@
     char *filename;
     char **files;
+#if ENABLE_FEATURE_LESS_FLAGS
+    int num_lines; /* a flag if < 0, line count if >= 0 */
+# define REOPEN_AND_COUNT (-1)
+# define REOPEN_STDIN     (-2)
+# define NOT_REGULAR_FILE (-3)
+#endif
 #if ENABLE_FEATURE_LESS_MARKS
     unsigned num_marks;
@@ -216 +237 @@
 #define filename            (G.filename          )
 #define files               (G.files             )
+#define num_lines           (G.num_lines         )
 #define num_marks           (G.num_marks         )
 #define mark_lines          (G.mark_lines        )
@@ -318 +340 @@
         if (*d != '\0') {
             new_line_pos++;
-            if (*d == '\t') /* tab */
+            if (*d == '\t') { /* tab */
                 new_line_pos += 7;
+                new_line_pos &= (~7);
+            }
             s++;
             d++;
@@ -381 +405 @@
 #endif
 
+static int at_end(void)
+{
+    return (option_mask32 & FLAG_S)
+        ? !(cur_fline <= max_fline &&
+            max_lineno > LINENO(flines[cur_fline]) + max_displayed_line)
+        : !(max_fline > cur_fline + max_displayed_line);
+}
+
 /* Devilishly complex routine.
  *
@@ -403 +435 @@
  *      (takes into account tabs and backspaces)
  * eof_error - < 0 error, == 0 EOF, > 0 not EOF/error
+ *
+ * "git log -p | less -m" on the kernel git tree is a good test for EAGAINs,
+ * "/search on very long input" and "reaching max line count" corner cases.
  */
 static void read_lines(void)
 {
-#define readbuf bb_common_bufsiz1
     char *current_line, *p;
     int w = width;
     char last_terminated = terminated;
+    time_t last_time = 0;
+    int retry_EAGAIN = 2;
 #if ENABLE_FEATURE_LESS_REGEXP
     unsigned old_max_fline = max_fline;
-    time_t last_time = 0;
-    unsigned seconds_p1 = 3; /* seconds_to_loop + 1 */
-#endif
+#endif
+
+#define readbuf bb_common_bufsiz1
+    setup_common_bufsiz();
+
+    /* (careful: max_fline can be -1) */
+    if (max_fline + 1 > MAXLINES)
+        return;
 
     if (option_mask32 & FLAG_N)
         w -= 8;
 
- IF_FEATURE_LESS_REGEXP(again0:)
-
-    p = current_line = ((char*)xmalloc(w + 4)) + 4;
-    max_fline += last_terminated;
+    p = current_line = ((char*)xmalloc(w + 5)) + 4;
     if (!last_terminated) {
         const char *cp = flines[max_fline];
-        strcpy(p, cp);
-        p += strlen(current_line);
-        free(MEMPTR(flines[max_fline]));
+        p = stpcpy(p, cp);
+        free(MEMPTR(cp));
         /* last_line_pos is still valid from previous read_lines() */
     } else {
+        max_fline++;
         last_line_pos = 0;
     }
@@ -440 +478 @@
             /* if no unprocessed chars left, eat more */
             if (readpos >= readeof) {
-                ndelay_on(0);
-                eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf));
-                ndelay_off(0);
+                int flags = ndelay_on(0);
+
+                while (1) {
+                    time_t t;
+
+                    errno = 0;
+                    eof_error = safe_read(STDIN_FILENO, readbuf, COMMON_BUFSIZE);
+                    if (errno != EAGAIN)
+                        break;
+                    t = time(NULL);
+                    if (t != last_time) {
+                        last_time = t;
+                        if (--retry_EAGAIN < 0)
+                            break;
+                    }
+                    sched_yield();
+                }
+                fcntl(0, F_SETFL, flags); /* ndelay_off(0) */
                 readpos = 0;
                 readeof = eof_error;
                 if (eof_error <= 0)
                     goto reached_eof;
+                retry_EAGAIN = 1;
             }
             c = readbuf[readpos];
@@ -465 +519 @@
                     new_last_line_pos &= (~7);
                 }
-                if ((int)new_last_line_pos >= w)
+                if ((int)new_last_line_pos > w)
                     break;
                 last_line_pos = new_last_line_pos;
@@ -481 +535 @@
             *p = '\0';
         } /* end of "read chars until we have a line" loop */
+#if 0
+//BUG: also triggers on this:
+// { printf "\nfoo\n"; sleep 1; printf "\nbar\n"; } | less
+// (resulting in lost empty line between "foo" and "bar" lines)
+// the "terminated" logic needs fixing (or explaining)
         /* Corner case: linewrap with only "" wrapping to next line */
         /* Looks ugly on screen, so we do not store this empty line */
@@ -488 +547 @@
             continue;
         }
+#endif
  reached_eof:
         last_terminated = terminated;
@@ -501 +561 @@
             break;
         }
-        if (!(option_mask32 & FLAG_S)
-          ? (max_fline > cur_fline + max_displayed_line)
-          : (max_fline >= cur_fline
-             && max_lineno > LINENO(flines[cur_fline]) + max_displayed_line)
-        ) {
+        if (!at_end()) {
 #if !ENABLE_FEATURE_LESS_REGEXP
             break;
@@ -518 +574 @@
         }
         if (eof_error <= 0) {
-            if (eof_error < 0) {
-                if (errno == EAGAIN) {
-                    /* not yet eof or error, reset flag (or else
-                     * we will hog CPU - select() will return
-                     * immediately */
-                    eof_error = 1;
-                } else {
-                    print_statusline(bb_msg_read_error);
-                }
-            }
-#if !ENABLE_FEATURE_LESS_REGEXP
             break;
-#else
-            if (wanted_match < num_matches) {
-                break;
-            } else { /* goto_match called us */
-                time_t t = time(NULL);
-                if (t != last_time) {
-                    last_time = t;
-                    if (--seconds_p1 == 0)
-                        break;
-                }
-                sched_yield();
-                goto again0; /* go loop again (max 2 seconds) */
-            }
-#endif
         }
         max_fline++;
-        current_line = ((char*)xmalloc(w + 4)) + 4;
+        current_line = ((char*)xmalloc(w + 5)) + 4;
         p = current_line;
         last_line_pos = 0;
     } /* end of "read lines until we reach cur_fline" loop */
+
+    if (eof_error < 0) {
+        if (errno == EAGAIN) {
+            eof_error = 1;
+        } else {
+            print_statusline(bb_msg_read_error);
+        }
+    }
+#if ENABLE_FEATURE_LESS_FLAGS
+    else if (eof_error == 0)
+        num_lines = max_lineno;
+#endif
+
     fill_match_lines(old_max_fline);
 #if ENABLE_FEATURE_LESS_REGEXP
@@ -559 +603 @@
 
 #if ENABLE_FEATURE_LESS_FLAGS
-/* Interestingly, writing calc_percent as a function saves around 32 bytes
- * on my build. */
-static int calc_percent(void)
-{
-    unsigned p = (100 * (cur_fline+max_displayed_line+1) + max_fline/2) / (max_fline+1);
-    return p <= 100 ? p : 100;
+static int safe_lineno(int fline)
+{
+    if (fline >= max_fline)
+        fline = max_fline - 1;
+
+    /* also catches empty file (max_fline == 0) */
+    if (fline < 0)
+        return 0;
+
+    return LINENO(flines[fline]) + 1;
+}
+
+/* count number of lines in file */
+static void update_num_lines(void)
+{
+    int count, fd;
+    struct stat stbuf;
+    ssize_t len, i;
+    char buf[4096];
+
+    /* only do this for regular files */
+    if (num_lines == REOPEN_AND_COUNT || num_lines == REOPEN_STDIN) {
+        count = 0;
+        fd = open("/proc/self/fd/0", O_RDONLY);
+        if (fd < 0 && num_lines == REOPEN_AND_COUNT) {
+            /* "filename" is valid only if REOPEN_AND_COUNT */
+            fd = open(filename, O_RDONLY);
+        }
+        if (fd < 0) {
+            /* somebody stole my file! */
+            num_lines = NOT_REGULAR_FILE;
+            return;
+        }
+        if (fstat(fd, &stbuf) != 0 || !S_ISREG(stbuf.st_mode)) {
+            num_lines = NOT_REGULAR_FILE;
+            goto do_close;
+        }
+        while ((len = safe_read(fd, buf, sizeof(buf))) > 0) {
+            for (i = 0; i < len; ++i) {
+                if (buf[i] == '\n' && ++count == MAXLINES)
+                    goto done;
+            }
+        }
+ done:
+        num_lines = count;
+ do_close:
+        close(fd);
+    }
 }
 
@@ -570 +656 @@
 static void m_status_print(void)
 {
-    int percentage;
+    int first, last;
+    unsigned percent;
 
     if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
@@ -579 +666 @@
     if (num_files > 1)
         printf(" (file %i of %i)", current_file, num_files);
-    printf(" lines %i-%i/%i ",
-            cur_fline + 1, cur_fline + max_displayed_line + 1,
-            max_fline + 1);
-    if (cur_fline >= (int)(max_fline - max_displayed_line)) {
-        printf("(END)"NORMAL);
+
+    first = safe_lineno(cur_fline);
+    last = (option_mask32 & FLAG_S)
+            ? MIN(first + max_displayed_line, max_lineno)
+            : safe_lineno(cur_fline + max_displayed_line);
+    printf(" lines %i-%i", first, last);
+
+    update_num_lines();
+    if (num_lines >= 0)
+        printf("/%i", num_lines);
+
+    if (at_end()) {
+        printf(" (END)");
         if (num_files > 1 && current_file != num_files)
-            printf(HIGHLIGHT" - next: %s"NORMAL, files[current_file]);
-        return;
-    }
-    percentage = calc_percent();
-    printf("%i%%"NORMAL, percentage);
+            printf(" - next: %s", files[current_file]);
+    } else if (num_lines > 0) {
+        percent = (100 * last + num_lines/2) / num_lines;
+        printf(" %i%%", percent <= 100 ? percent : 100);
+    }
+    printf(NORMAL);
 }
 #endif
@@ -611 +707 @@
 
     clear_line();
-    if (cur_fline && cur_fline < (int)(max_fline - max_displayed_line)) {
+    if (cur_fline && !at_end()) {
         bb_putchar(':');
         return;
@@ -624 +720 @@
     }
     print_hilite(p);
-}
-
-static void cap_cur_fline(int nlines)
-{
-    int diff;
-    if (cur_fline < 0)
-        cur_fline = 0;
-    if (cur_fline + max_displayed_line > max_fline + TILDES) {
-        cur_fline -= nlines;
-        if (cur_fline < 0)
-            cur_fline = 0;
-        diff = max_fline - (cur_fline + max_displayed_line) + TILDES;
-        /* As the number of lines requested was too large, we just move
-         * to the end of the file */
-        if (diff > 0)
-            cur_fline += diff;
-    }
 }
 
@@ -654 +733 @@
     "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f";
 
-static void lineno_str(char *nbuf9, const char *line)
-{
-    nbuf9[0] = '\0';
-    if (option_mask32 & FLAG_N) {
-        const char *fmt;
-        unsigned n;
-
-        if (line == empty_line_marker) {
-            memset(nbuf9, ' ', 8);
-            nbuf9[8] = '\0';
-            return;
-        }
+static void print_lineno(const char *line)
+{
+    const char *fmt = "        ";
+    unsigned n = n; /* for compiler */
+
+    if (line != empty_line_marker) {
         /* Width of 7 preserves tab spacing in the text */
         fmt = "%7u ";
         n = LINENO(line) + 1;
-        if (n > 9999999) {
+        if (n > 9999999 && MAXLINES > 9999999) {
             n %= 10000000;
             fmt = "%07u ";
         }
-        sprintf(nbuf9, fmt, n);
-    }
+    }
+    printf(fmt, n);
 }
 
@@ -686 +759 @@
     regmatch_t match_structs;
 
-    char buf[width];
-    char nbuf9[9];
+    char buf[width+1];
     const char *str = line;
     char *p = buf;
@@ -737 +809 @@
     }
 
-    lineno_str(nbuf9, line);
-    if (!growline) {
-        printf(CLEAR_2_EOL"%s%s\n", nbuf9, str);
-        return;
-    }
-    printf(CLEAR_2_EOL"%s%s%s\n", nbuf9, growline, str);
+    printf("%s%s\n", growline ? growline : "", str);
     free(growline);
 }
@@ -751 +818 @@
 static void print_ascii(const char *str)
 {
-    char buf[width];
-    char nbuf9[9];
+    char buf[width+1];
     char *p;
     size_t n;
-
-    lineno_str(nbuf9, str);
-    printf(CLEAR_2_EOL"%s", nbuf9);
 
     while (*str) {
@@ -791 +854 @@
 
     move_cursor(0, 0);
-    for (i = 0; i <= max_displayed_line; i++)
+    for (i = 0; i <= max_displayed_line; i++) {
+        printf(CLEAR_2_EOL);
+        if (option_mask32 & FLAG_N)
+            print_lineno(buffer[i]);
         if (pattern_valid)
             print_found(buffer[i]);
         else
             print_ascii(buffer[i]);
+    }
+    if ((option_mask32 & FLAG_E)
+     && eof_error <= 0
+     && (max_fline - cur_fline) <= max_displayed_line
+    ) {
+        less_exit(EXIT_SUCCESS);
+    }
     status_print();
 }
@@ -802 +875 @@
 {
     unsigned i;
-#if ENABLE_FEATURE_LESS_DASHCMD
+#if ENABLE_FEATURE_LESS_TRUNCATE
     int fpos = cur_fline;
 
@@ -834 +907 @@
 }
 
+/* move cur_fline to a given line number, reading lines if necessary */
+static void goto_lineno(int target)
+{
+    if (target <= 0 ) {
+        cur_fline = 0;
+    }
+    else if (target > LINENO(flines[cur_fline])) {
+ retry:
+        while (LINENO(flines[cur_fline]) != target && cur_fline < max_fline)
+            ++cur_fline;
+        /* target not reached but more input is available */
+        if (LINENO(flines[cur_fline]) != target && eof_error > 0) {
+            read_lines();
+            goto retry;
+        }
+    }
+    else {
+        /* search backwards through already-read lines */
+        while (LINENO(flines[cur_fline]) != target && cur_fline > 0)
+            --cur_fline;
+    }
+}
+
+static void cap_cur_fline(void)
+{
+    if ((option_mask32 & FLAG_S)) {
+        if (cur_fline > max_fline)
+            cur_fline = max_fline;
+        if (LINENO(flines[cur_fline]) + max_displayed_line > max_lineno + TILDES) {
+            goto_lineno(max_lineno - max_displayed_line + TILDES);
+            read_lines();
+        }
+    }
+    else {
+        if (cur_fline + max_displayed_line > max_fline + TILDES)
+            cur_fline = max_fline - max_displayed_line + TILDES;
+        if (cur_fline < 0)
+            cur_fline = 0;
+    }
+}
+
 /* Move the buffer up and down in the file in order to scroll */
 static void buffer_down(int nlines)
 {
-    cur_fline += nlines;
+    if ((option_mask32 & FLAG_S))
+        goto_lineno(LINENO(flines[cur_fline]) + nlines);
+    else
+        cur_fline += nlines;
     read_lines();
-    cap_cur_fline(nlines);
+    cap_cur_fline();
     buffer_fill_and_print();
 }
@@ -845 +962 @@
 static void buffer_up(int nlines)
 {
-    cur_fline -= nlines;
-    if (cur_fline < 0) cur_fline = 0;
+    if ((option_mask32 & FLAG_S)) {
+        goto_lineno(LINENO(flines[cur_fline]) - nlines);
+    }
+    else {
+        cur_fline -= nlines;
+        if (cur_fline < 0)
+            cur_fline = 0;
+    }
     read_lines();
     buffer_fill_and_print();
 }
 
+/* display a given line where the argument can be either an index into
+ * the flines array or a line number */
+static void buffer_to_line(int linenum, int is_lineno)
+{
+    if (linenum <= 0)
+        cur_fline = 0;
+    else if (is_lineno)
+        goto_lineno(linenum);
+    else
+        cur_fline = linenum;
+    read_lines();
+    cap_cur_fline();
+    buffer_fill_and_print();
+}
+
 static void buffer_line(int linenum)
 {
-    if (linenum < 0)
-        linenum = 0;
-    cur_fline = linenum;
-    read_lines();
-    if (linenum + max_displayed_line > max_fline)
-        linenum = max_fline - max_displayed_line + TILDES;
-    if (linenum < 0)
-        linenum = 0;
-    cur_fline = linenum;
-    buffer_fill_and_print();
+    buffer_to_line(linenum, FALSE);
+}
+
+static void buffer_lineno(int lineno)
+{
+    buffer_to_line(lineno, TRUE);
 }
 
@@ -869 +1003 @@
     if (filename) {
         xmove_fd(xopen(filename, O_RDONLY), STDIN_FILENO);
+#if ENABLE_FEATURE_LESS_FLAGS
+        num_lines = REOPEN_AND_COUNT;
+#endif
     } else {
         /* "less" with no arguments in argv[] */
         /* For status line only */
         filename = xstrdup(bb_msg_standard_input);
+#if ENABLE_FEATURE_LESS_FLAGS
+        num_lines = REOPEN_STDIN;
+#endif
     }
     readpos = 0;
@@ -924 +1064 @@
     rd = 1;
     /* Are we interested in stdin? */
-//TODO: reuse code for determining this
-    if (!(option_mask32 & FLAG_S)
-       ? !(max_fline > cur_fline + max_displayed_line)
-       : !(max_fline >= cur_fline
-           && max_lineno > LINENO(flines[cur_fline]) + max_displayed_line)
-    ) {
+    if (at_end()) {
         if (eof_error > 0) /* did NOT reach eof yet */
             rd = 0; /* yes, we are interested in stdin */
@@ -1240 +1375 @@
     while (i < sizeof(num_input)-1) {
         keypress = less_getch(i + 1);
-        if ((unsigned)keypress > 255 || !isdigit(num_input[i]))
+        if ((unsigned)keypress > 255 || !isdigit(keypress))
             break;
         num_input[i] = keypress;
@@ -1264 +1399 @@
         break;
     case 'g': case '<': case 'G': case '>':
-        cur_fline = num + max_displayed_line;
-        read_lines();
-        buffer_line(num - 1);
+        buffer_lineno(num - 1);
         break;
     case 'p': case '%':
-        num = num * (max_fline / 100); /* + max_fline / 2; */
-        cur_fline = num + max_displayed_line;
-        read_lines();
-        buffer_line(num);
+#if ENABLE_FEATURE_LESS_FLAGS
+        update_num_lines();
+        num = num * (num_lines > 0 ? num_lines : max_lineno) / 100;
+#else
+        num = num * max_lineno / 100;
+#endif
+        buffer_lineno(num);
         break;
 #if ENABLE_FEATURE_LESS_REGEXP
@@ -1312 +1448 @@
         option_mask32 ^= FLAG_TILDE;
         break;
+#if ENABLE_FEATURE_LESS_TRUNCATE
     case 'S':
         option_mask32 ^= FLAG_S;
         buffer_fill_and_print();
         break;
+#endif
 #if ENABLE_FEATURE_LESS_LINENUMS
     case 'N':
@@ -1609 +1747 @@
 int less_main(int argc, char **argv)
 {
+    char *tty_name;
+    int tty_fd;
+
     INIT_G();
 
-    /* TODO: -x: do not interpret backspace, -xx: tab also */
-    /* -xxx: newline also */
-    /* -w N: assume width N (-xxx -w 32: hex viewer of sorts) */
-    getopt32(argv, "EMmN~I" IF_FEATURE_LESS_DASHCMD("S"));
+    /* TODO: -x: do not interpret backspace, -xx: tab also
+     * -xxx: newline also
+     * -w N: assume width N (-xxx -w 32: hex viewer of sorts)
+     * -s: condense many empty lines to one
+     *     (used by some setups for manpage display)
+     */
+    getopt32(argv, "EMmN~I" IF_FEATURE_LESS_TRUNCATE("S") /*ignored:*/"s");
     argc -= optind;
     argv += optind;
@@ -1638 +1782 @@
         empty_line_marker = "";
 
-    kbd_fd = open(CURRENT_TTY, O_RDONLY);
-    if (kbd_fd < 0)
-        return bb_cat(argv);
-    ndelay_on(kbd_fd);
+    /* Some versions of less can survive w/o controlling tty,
+     * try to do the same. This also allows to specify an alternative
+     * tty via "less 1<>TTY".
+     * We don't try to use STDOUT_FILENO directly,
+     * since we want to set this fd to non-blocking mode,
+     * and not bother with restoring it on exit.
+     */
+    tty_name = xmalloc_ttyname(STDOUT_FILENO);
+    if (tty_name) {
+        tty_fd = open(tty_name, O_RDONLY);
+        free(tty_name);
+        if (tty_fd < 0)
+            goto try_ctty;
+    } else {
+        /* Try controlling tty */
+ try_ctty:
+        tty_fd = open(CURRENT_TTY, O_RDONLY);
+        if (tty_fd < 0)
+            return bb_cat(argv);
+    }
+    ndelay_on(tty_fd);
+    kbd_fd = tty_fd; /* save in a global */
 
     tcgetattr(kbd_fd, &term_orig);
@@ -1806 +1968 @@
         or from within less by using the - or -- command.
         Options may be given in one of two forms: either a single
-        character preceded by a -, or a name preceeded by --.
+        character preceded by a -, or a name preceded by --.
   -?  ........  --help
                   Display help (from command line).