Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/coreutils/tail.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/coreutils/tail.c (modified) (13 diffs)

branches/2.2.9/mindi-busybox/coreutils/tail.c

@@ -5 +5 @@
  * Copyright (C) 2001 by Matt Kraai <kraai@alumni.carnegiemellon.edu>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -31 +31 @@
     { "k", 1024 },
     { "m", 1024*1024 },
-    { }
+    { "", 0 }
 };
 
 struct globals {
     bool status;
-};
+} FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
 
@@ -51 +51 @@
     struct stat sbuf;
 
-    /* (A good comment is missing here) */
-    current = lseek(fd, 0, SEEK_CUR);
     /* /proc files report zero st_size, don't lseek them. */
-    if (fstat(fd, &sbuf) == 0 && sbuf.st_size)
+    if (fstat(fd, &sbuf) == 0 && sbuf.st_size > 0) {
+        current = lseek(fd, 0, SEEK_CUR);
         if (sbuf.st_size < current)
-            lseek(fd, 0, SEEK_SET);
-
-    r = safe_read(fd, buf, count);
+            xlseek(fd, 0, SEEK_SET);
+    }
+
+    r = full_read(fd, buf, count);
     if (r < 0) {
         bb_perror_msg(bb_msg_read_error);
@@ -67 +67 @@
 }
 
-static const char header_fmt[] ALIGN1 = "\n==> %s <==\n";
+#define header_fmt_str "\n==> %s <==\n"
 
 static unsigned eat_num(const char *p)
@@ -75 +75 @@
     else if (*p == '+') {
         p++;
-        G.status = EXIT_FAILURE;
+        G.status = 1; /* mark that we saw "+" */
     }
     return xatou_sfx(p, tail_suffixes);
 }
 
-int tail_main(int argc, char **argv);
+int tail_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int tail_main(int argc, char **argv)
 {
@@ -86 +86 @@
     unsigned sleep_period = 1;
     bool from_top;
-    int header_threshhold = 1;
     const char *str_c, *str_n;
-    USE_FEATURE_FANCY_TAIL(const char *str_s;)
 
     char *tailbuf;
     size_t tailbufsize;
-    int taillen = 0;
-    int newline = 0;
-    int nfiles, nread, nwrite, seen, i, opt;
+    unsigned header_threshhold = 1;
+    unsigned nfiles;
+    int i, opt;
 
     int *fds;
-    char *s, *buf;
     const char *fmt;
 
 #if ENABLE_INCLUDE_SUSv2 || ENABLE_FEATURE_FANCY_TAIL
     /* Allow legacy syntax of an initial numeric option without -n. */
-    if (argc >= 2 && (argv[1][0] == '+' || argv[1][0] == '-')
+    if (argv[1] && (argv[1][0] == '+' || argv[1][0] == '-')
      && isdigit(argv[1][1])
     ) {
-        /* replacing arg[0] with "-n" can segfault, so... */
-        argv[1] = xasprintf("-n%s", argv[1]);
-#if 0 /* If we ever decide to make tail NOFORK */
-        char *s = alloca(strlen(argv[1]) + 3);
-        sprintf(s, "-n%s", argv[1]);
-        argv[1] = s;
+        count = eat_num(argv[1]);
+        argv++;
+        argc--;
+    }
 #endif
-    }
-#endif
-
-    opt = getopt32(argv, "fc:n:" USE_FEATURE_FANCY_TAIL("qs:v"),
-            &str_c, &str_n USE_FEATURE_FANCY_TAIL(,&str_s));
+
+    /* -s NUM, -F imlies -f */
+    IF_FEATURE_FANCY_TAIL(opt_complementary = "s+:Ff";)
+    opt = getopt32(argv, "fc:n:" IF_FEATURE_FANCY_TAIL("qs:vF"),
+            &str_c, &str_n IF_FEATURE_FANCY_TAIL(,&sleep_period));
 #define FOLLOW (opt & 0x1)
 #define COUNT_BYTES (opt & 0x2)
@@ -123 +118 @@
     if (opt & 0x4) count = eat_num(str_n); // -n
 #if ENABLE_FEATURE_FANCY_TAIL
-    if (opt & 0x8) header_threshhold = INT_MAX; // -q
-    if (opt & 0x10) sleep_period = xatou(str_s); // -s
+    /* q: make it impossible for nfiles to be > header_threshhold */
+    if (opt & 0x8) header_threshhold = UINT_MAX; // -q
+    //if (opt & 0x10) // -s
     if (opt & 0x20) header_threshhold = 0; // -v
+# define FOLLOW_RETRY (opt & 0x40)
+#else
+# define FOLLOW_RETRY 0
 #endif
     argc -= optind;
     argv += optind;
-    from_top = G.status;
+    from_top = G.status; /* 1 if there was "-c +N" or "-n +N" */
+    G.status = EXIT_SUCCESS;
 
     /* open all the files */
-    fds = xmalloc(sizeof(int) * (argc + 1));
+    fds = xmalloc(sizeof(fds[0]) * (argc + 1));
+    if (!argv[0]) {
+        struct stat statbuf;
+
+        if (fstat(STDIN_FILENO, &statbuf) == 0
+         && S_ISFIFO(statbuf.st_mode)
+        ) {
+            opt &= ~1; /* clear FOLLOW */
+        }
+        argv[0] = (char *) bb_msg_standard_input;
+    }
     nfiles = i = 0;
-    G.status = EXIT_SUCCESS;
-    if (argc == 0) {
-        struct stat statbuf;
-
-        if (!fstat(STDIN_FILENO, &statbuf) && S_ISFIFO(statbuf.st_mode)) {
-            opt &= ~1; /* clear FOLLOW */
-        }
-        *argv = (char *) bb_msg_standard_input;
-    }
     do {
-        FILE* fil = fopen_or_warn_stdin(argv[i]);
-        if (!fil) {
+        int fd = open_or_warn_stdin(argv[i]);
+        if (fd < 0 && !FOLLOW_RETRY) {
             G.status = EXIT_FAILURE;
             continue;
         }
-        fds[nfiles] = fileno(fil);
+        fds[nfiles] = fd;
         argv[nfiles++] = argv[i];
     } while (++i < argc);
@@ -156 +157 @@
         bb_error_msg_and_die("no files");
 
+    /* prepare the buffer */
     tailbufsize = BUFSIZ;
+    if (!from_top && COUNT_BYTES) {
+        if (tailbufsize < count + BUFSIZ) {
+            tailbufsize = count + BUFSIZ;
+        }
+    }
+    tailbuf = xmalloc(tailbufsize);
 
     /* tail the files */
-    if (!from_top && COUNT_BYTES) {
-        if (tailbufsize < count) {
-            tailbufsize = count + BUFSIZ;
-        }
-    }
-
-    buf = tailbuf = xmalloc(tailbufsize);
-
-    fmt = header_fmt + 1;   /* Skip header leading newline on first output. */
+    fmt = header_fmt_str + 1; /* skip header leading newline on first output */
     i = 0;
     do {
-        /* Be careful.  It would be possible to optimize the count-bytes
-         * case if the file is seekable.  If you do though, remember that
-         * starting file position may not be the beginning of the file.
-         * Beware of backing up too far.  See example in wc.c.
-         */
-        if (!(count | from_top) && lseek(fds[i], 0, SEEK_END) >= 0) {
-            continue;
-        }
+        char *buf;
+        int taillen;
+        int newlines_seen;
+        unsigned seen;
+        int nread;
+        int fd = fds[i];
+
+        if (ENABLE_FEATURE_FANCY_TAIL && fd < 0)
+            continue; /* may happen with -E */
 
         if (nfiles > header_threshhold) {
             tail_xprint_header(fmt, argv[i]);
-            fmt = header_fmt;
+            fmt = header_fmt_str;
+        }
+
+        if (!from_top) {
+            off_t current = lseek(fd, 0, SEEK_END);
+            if (current > 0) {
+                unsigned off;
+                if (COUNT_BYTES) {
+                /* Optimizing count-bytes case if the file is seekable.
+                 * Beware of backing up too far.
+                 * Also we exclude files with size 0 (because of /proc/xxx) */
+                    if (count == 0)
+                        continue; /* showing zero bytes is easy :) */
+                    current -= count;
+                    if (current < 0)
+                        current = 0;
+                    xlseek(fd, current, SEEK_SET);
+                    bb_copyfd_size(fd, STDOUT_FILENO, count);
+                    continue;
+                }
+#if 1 /* This is technically incorrect for *LONG* strings, but very useful */
+                /* Optimizing count-lines case if the file is seekable.
+                 * We assume the lines are <64k.
+                 * (Users complain that tail takes too long
+                 * on multi-gigabyte files) */
+                off = (count | 0xf); /* for small counts, be more paranoid */
+                if (off > (INT_MAX / (64*1024)))
+                    off = (INT_MAX / (64*1024));
+                current -= off * (64*1024);
+                if (current < 0)
+                    current = 0;
+                xlseek(fd, current, SEEK_SET);
+#endif
+            }
         }
 
         buf = tailbuf;
         taillen = 0;
+        /* "We saw 1st line/byte".
+         * Used only by +N code ("start from Nth", 1-based): */
         seen = 1;
-        newline = 0;
-
-        while ((nread = tail_read(fds[i], buf, tailbufsize-taillen)) > 0) {
+        newlines_seen = 0;
+        while ((nread = tail_read(fd, buf, tailbufsize-taillen)) > 0) {
             if (from_top) {
-                nwrite = nread;
+                int nwrite = nread;
                 if (seen < count) {
+                    /* We need to skip a few more bytes/lines */
                     if (COUNT_BYTES) {
                         nwrite -= (count - seen);
                         seen = count;
                     } else {
-                        s = buf;
+                        char *s = buf;
                         do {
                             --nwrite;
@@ -206 +242 @@
                     }
                 }
-                xwrite(STDOUT_FILENO, buf + nread - nwrite, nwrite);
+                if (nwrite > 0)
+                    xwrite(STDOUT_FILENO, buf + nread - nwrite, nwrite);
             } else if (count) {
                 if (COUNT_BYTES) {
                     taillen += nread;
-                    if (taillen > count) {
+                    if (taillen > (int)count) {
                         memmove(tailbuf, tailbuf + taillen - count, count);
                         taillen = count;
@@ -216 +253 @@
                 } else {
                     int k = nread;
-                    int nbuf = 0;
-
-                    while (k) {
-                        --k;
+                    int newlines_in_buf = 0;
+
+                    do { /* count '\n' in last read */
+                        k--;
                         if (buf[k] == '\n') {
-                            ++nbuf;
+                            newlines_in_buf++;
                         }
-                    }
-
-                    if (newline + nbuf < count) {
-                        newline += nbuf;
+                    } while (k);
+
+                    if (newlines_seen + newlines_in_buf < (int)count) {
+                        newlines_seen += newlines_in_buf;
                         taillen += nread;
                     } else {
-                        int extra = 0;
-
-                        if (buf[nread-1] != '\n')
-                            extra = 1;
-                        k = newline + nbuf + extra - count;
+                        int extra = (buf[nread-1] != '\n');
+                        char *s;
+
+                        k = newlines_seen + newlines_in_buf + extra - count;
                         s = tailbuf;
                         while (k) {
                             if (*s == '\n') {
-                                --k;
+                                k--;
                             }
-                            ++s;
+                            s++;
                         }
                         taillen += nread - (s - tailbuf);
                         memmove(tailbuf, s, taillen);
-                        newline = count - extra;
-                    }
-                    if (tailbufsize < taillen + BUFSIZ) {
+                        newlines_seen = count - extra;
+                    }
+                    if (tailbufsize < (size_t)taillen + BUFSIZ) {
                         tailbufsize = taillen + BUFSIZ;
                         tailbuf = xrealloc(tailbuf, tailbufsize);
@@ -252 +288 @@
                 buf = tailbuf + taillen;
             }
-        }
-
+        } /* while (tail_read() > 0) */
         if (!from_top) {
             xwrite(STDOUT_FILENO, tailbuf, taillen);
         }
-
-        taillen = 0;
     } while (++i < nfiles);
 
-    buf = xrealloc(tailbuf, BUFSIZ);
+    tailbuf = xrealloc(tailbuf, BUFSIZ);
 
     fmt = NULL;
@@ -267 +300 @@
     if (FOLLOW) while (1) {
         sleep(sleep_period);
+
         i = 0;
         do {
+            int nread;
+            const char *filename = argv[i];
+            int fd = fds[i];
+
+            if (FOLLOW_RETRY) {
+                struct stat sbuf, fsbuf;
+
+                if (fd < 0
+                 || fstat(fd, &fsbuf) < 0
+                 || stat(filename, &sbuf) < 0
+                 || fsbuf.st_dev != sbuf.st_dev
+                 || fsbuf.st_ino != sbuf.st_ino
+                ) {
+                    int new_fd;
+
+                    if (fd >= 0)
+                        close(fd);
+                    new_fd = open(filename, O_RDONLY);
+                    if (new_fd >= 0) {
+                        bb_error_msg("%s has %s; following end of new file",
+                            filename, (fd < 0) ? "appeared" : "been replaced"
+                        );
+                    } else if (fd >= 0) {
+                        bb_perror_msg("%s has become inaccessible", filename);
+                    }
+                    fds[i] = fd = new_fd;
+                }
+            }
+            if (ENABLE_FEATURE_FANCY_TAIL && fd < 0)
+                continue;
             if (nfiles > header_threshhold) {
-                fmt = header_fmt;
-            }
-            while ((nread = tail_read(fds[i], buf, sizeof(buf))) > 0) {
+                fmt = header_fmt_str;
+            }
+            while ((nread = tail_read(fd, tailbuf, BUFSIZ)) > 0) {
                 if (fmt) {
-                    tail_xprint_header(fmt, argv[i]);
+                    tail_xprint_header(fmt, filename);
                     fmt = NULL;
                 }
-                xwrite(STDOUT_FILENO, buf, nread);
+                xwrite(STDOUT_FILENO, tailbuf, nread);
             }
         } while (++i < nfiles);
@@ -283 +347 @@
     if (ENABLE_FEATURE_CLEAN_UP) {
         free(fds);
+        free(tailbuf);
     }
     return G.status;