source: branches/2.2.5/mindi-busybox/coreutils/tail.c @ 1772

Last change on this file since 1772 was 1772, checked in by bruno, 12 years ago

Update mindi-busybox to 1.7.3

File size: 6.6 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Mini tail implementation for busybox
4 *
5 * Copyright (C) 2001 by Matt Kraai <kraai@alumni.carnegiemellon.edu>
6 *
7 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
8 */
9
10/* BB_AUDIT SUSv3 compliant (need fancy for -c) */
11/* BB_AUDIT GNU compatible -c, -q, and -v options in 'fancy' configuration. */
12/* http://www.opengroup.org/onlinepubs/007904975/utilities/tail.html */
13
14/* Mar 16, 2003      Manuel Novoa III   (mjn3@codepoet.org)
15 *
16 * Pretty much rewritten to fix numerous bugs and reduce realloc() calls.
17 * Bugs fixed (although I may have forgotten one or two... it was pretty bad)
18 * 1) mixing printf/write without fflush()ing stdout
19 * 2) no check that any open files are present
20 * 3) optstring had -q taking an arg
21 * 4) no error checking on write in some cases, and a warning even then
22 * 5) q and s interaction bug
23 * 6) no check for lseek error
24 * 7) lseek attempted when count==0 even if arg was +0 (from top)
25 */
26
27#include "libbb.h"
28
29static const struct suffix_mult tail_suffixes[] = {
30    { "b", 512 },
31    { "k", 1024 },
32    { "m", 1024*1024 },
33    { }
34};
35
36struct globals {
37    bool status;
38};
39#define G (*(struct globals*)&bb_common_bufsiz1)
40
41static void tail_xprint_header(const char *fmt, const char *filename)
42{
43    if (fdprintf(STDOUT_FILENO, fmt, filename) < 0)
44        bb_perror_nomsg_and_die();
45}
46
47static ssize_t tail_read(int fd, char *buf, size_t count)
48{
49    ssize_t r;
50    off_t current;
51    struct stat sbuf;
52
53    /* (A good comment is missing here) */
54    current = lseek(fd, 0, SEEK_CUR);
55    /* /proc files report zero st_size, don't lseek them. */
56    if (fstat(fd, &sbuf) == 0 && sbuf.st_size)
57        if (sbuf.st_size < current)
58            lseek(fd, 0, SEEK_SET);
59
60    r = safe_read(fd, buf, count);
61    if (r < 0) {
62        bb_perror_msg(bb_msg_read_error);
63        G.status = EXIT_FAILURE;
64    }
65
66    return r;
67}
68
69static const char header_fmt[] ALIGN1 = "\n==> %s <==\n";
70
71static unsigned eat_num(const char *p)
72{
73    if (*p == '-')
74        p++;
75    else if (*p == '+') {
76        p++;
77        G.status = EXIT_FAILURE;
78    }
79    return xatou_sfx(p, tail_suffixes);
80}
81
82int tail_main(int argc, char **argv);
83int tail_main(int argc, char **argv)
84{
85    unsigned count = 10;
86    unsigned sleep_period = 1;
87    bool from_top;
88    int header_threshhold = 1;
89    const char *str_c, *str_n;
90    USE_FEATURE_FANCY_TAIL(const char *str_s;)
91
92    char *tailbuf;
93    size_t tailbufsize;
94    int taillen = 0;
95    int newline = 0;
96    int nfiles, nread, nwrite, seen, i, opt;
97
98    int *fds;
99    char *s, *buf;
100    const char *fmt;
101
102#if ENABLE_INCLUDE_SUSv2 || ENABLE_FEATURE_FANCY_TAIL
103    /* Allow legacy syntax of an initial numeric option without -n. */
104    if (argc >= 2 && (argv[1][0] == '+' || argv[1][0] == '-')
105     && isdigit(argv[1][1])
106    ) {
107        /* replacing arg[0] with "-n" can segfault, so... */
108        argv[1] = xasprintf("-n%s", argv[1]);
109#if 0 /* If we ever decide to make tail NOFORK */
110        char *s = alloca(strlen(argv[1]) + 3);
111        sprintf(s, "-n%s", argv[1]);
112        argv[1] = s;
113#endif
114    }
115#endif
116
117    opt = getopt32(argv, "fc:n:" USE_FEATURE_FANCY_TAIL("qs:v"),
118            &str_c, &str_n USE_FEATURE_FANCY_TAIL(,&str_s));
119#define FOLLOW (opt & 0x1)
120#define COUNT_BYTES (opt & 0x2)
121    //if (opt & 0x1) // -f
122    if (opt & 0x2) count = eat_num(str_c); // -c
123    if (opt & 0x4) count = eat_num(str_n); // -n
124#if ENABLE_FEATURE_FANCY_TAIL
125    if (opt & 0x8) header_threshhold = INT_MAX; // -q
126    if (opt & 0x10) sleep_period = xatou(str_s); // -s
127    if (opt & 0x20) header_threshhold = 0; // -v
128#endif
129    argc -= optind;
130    argv += optind;
131    from_top = G.status;
132
133    /* open all the files */
134    fds = xmalloc(sizeof(int) * (argc + 1));
135    nfiles = i = 0;
136    G.status = EXIT_SUCCESS;
137    if (argc == 0) {
138        struct stat statbuf;
139
140        if (!fstat(STDIN_FILENO, &statbuf) && S_ISFIFO(statbuf.st_mode)) {
141            opt &= ~1; /* clear FOLLOW */
142        }
143        *argv = (char *) bb_msg_standard_input;
144    }
145    do {
146        FILE* fil = fopen_or_warn_stdin(argv[i]);
147        if (!fil) {
148            G.status = EXIT_FAILURE;
149            continue;
150        }
151        fds[nfiles] = fileno(fil);
152        argv[nfiles++] = argv[i];
153    } while (++i < argc);
154
155    if (!nfiles)
156        bb_error_msg_and_die("no files");
157
158    tailbufsize = BUFSIZ;
159
160    /* tail the files */
161    if (!from_top && COUNT_BYTES) {
162        if (tailbufsize < count) {
163            tailbufsize = count + BUFSIZ;
164        }
165    }
166
167    buf = tailbuf = xmalloc(tailbufsize);
168
169    fmt = header_fmt + 1;   /* Skip header leading newline on first output. */
170    i = 0;
171    do {
172        /* Be careful.  It would be possible to optimize the count-bytes
173         * case if the file is seekable.  If you do though, remember that
174         * starting file position may not be the beginning of the file.
175         * Beware of backing up too far.  See example in wc.c.
176         */
177        if (!(count | from_top) && lseek(fds[i], 0, SEEK_END) >= 0) {
178            continue;
179        }
180
181        if (nfiles > header_threshhold) {
182            tail_xprint_header(fmt, argv[i]);
183            fmt = header_fmt;
184        }
185
186        buf = tailbuf;
187        taillen = 0;
188        seen = 1;
189        newline = 0;
190
191        while ((nread = tail_read(fds[i], buf, tailbufsize-taillen)) > 0) {
192            if (from_top) {
193                nwrite = nread;
194                if (seen < count) {
195                    if (COUNT_BYTES) {
196                        nwrite -= (count - seen);
197                        seen = count;
198                    } else {
199                        s = buf;
200                        do {
201                            --nwrite;
202                            if (*s++ == '\n' && ++seen == count) {
203                                break;
204                            }
205                        } while (nwrite);
206                    }
207                }
208                xwrite(STDOUT_FILENO, buf + nread - nwrite, nwrite);
209            } else if (count) {
210                if (COUNT_BYTES) {
211                    taillen += nread;
212                    if (taillen > count) {
213                        memmove(tailbuf, tailbuf + taillen - count, count);
214                        taillen = count;
215                    }
216                } else {
217                    int k = nread;
218                    int nbuf = 0;
219
220                    while (k) {
221                        --k;
222                        if (buf[k] == '\n') {
223                            ++nbuf;
224                        }
225                    }
226
227                    if (newline + nbuf < count) {
228                        newline += nbuf;
229                        taillen += nread;
230                    } else {
231                        int extra = 0;
232
233                        if (buf[nread-1] != '\n')
234                            extra = 1;
235                        k = newline + nbuf + extra - count;
236                        s = tailbuf;
237                        while (k) {
238                            if (*s == '\n') {
239                                --k;
240                            }
241                            ++s;
242                        }
243                        taillen += nread - (s - tailbuf);
244                        memmove(tailbuf, s, taillen);
245                        newline = count - extra;
246                    }
247                    if (tailbufsize < taillen + BUFSIZ) {
248                        tailbufsize = taillen + BUFSIZ;
249                        tailbuf = xrealloc(tailbuf, tailbufsize);
250                    }
251                }
252                buf = tailbuf + taillen;
253            }
254        }
255
256        if (!from_top) {
257            xwrite(STDOUT_FILENO, tailbuf, taillen);
258        }
259
260        taillen = 0;
261    } while (++i < nfiles);
262
263    buf = xrealloc(tailbuf, BUFSIZ);
264
265    fmt = NULL;
266
267    if (FOLLOW) while (1) {
268        sleep(sleep_period);
269        i = 0;
270        do {
271            if (nfiles > header_threshhold) {
272                fmt = header_fmt;
273            }
274            while ((nread = tail_read(fds[i], buf, sizeof(buf))) > 0) {
275                if (fmt) {
276                    tail_xprint_header(fmt, argv[i]);
277                    fmt = NULL;
278                }
279                xwrite(STDOUT_FILENO, buf, nread);
280            }
281        } while (++i < nfiles);
282    }
283    if (ENABLE_FEATURE_CLEAN_UP) {
284        free(fds);
285    }
286    return G.status;
287}
Note: See TracBrowser for help on using the repository browser.