1 /* tail -- output the last part of file(s)
2 Copyright (C) 1989, 90, 91, 1995-2001 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18 /* Can display any amount of data, unlike the Unix version, which uses
19 a fixed size buffer and therefore can only deliver a limited number
22 Original version by Paul Rubin <phr@ocf.berkeley.edu>.
23 Extensions by David MacKenzie <djm@gnu.ai.mit.edu>.
24 tail -f for multiple files by Ian Lance Taylor <ian@airs.com>. */
31 #include <sys/types.h>
38 #include "safe-read.h"
41 /* The official name of this program (e.g., no `g' prefix). */
42 #define PROGRAM_NAME "tail"
45 "Paul Rubin, David MacKenzie, Ian Lance Taylor, and Jim Meyering"
48 /* Some systems don't have ENOSYS -- this should be a big enough
49 value that no valid errno value will match it. */
53 /* Number of items to tail. */
54 #define DEFAULT_N_LINES 10
56 /* Size of atomic reads. */
58 # define BUFSIZ (512 * 8)
61 /* A special value for dump_remainder's N_BYTES parameter. */
62 #define COPY_TO_EOF OFF_T_MAX
64 /* FIXME: make Follow_name the default? */
65 #define DEFAULT_FOLLOW_MODE Follow_descriptor
69 /* Follow the name of each file: if the file is renamed, try to reopen
70 that name and track the end of the new file if/when it's recreated.
71 This is useful for tracking logs that are occasionally rotated. */
74 /* Follow each descriptor obtained upon opening a file.
75 That means we'll continue to follow the end of a file even after
76 it has been renamed or unlinked. */
80 /* The types of files for which tail works. */
81 #define IS_TAILABLE_FILE_TYPE(Mode) \
82 (S_ISREG (Mode) || S_ISFIFO (Mode) || S_ISCHR (Mode))
84 static char const *const follow_mode_string[] =
86 "descriptor", "name", 0
89 static enum Follow_mode const follow_mode_map[] =
91 Follow_descriptor, Follow_name,
96 /* The actual file name, or "-" for stdin. */
99 /* File descriptor on which the file is open; -1 if it's not open. */
102 /* The size of the file the last time we checked. */
105 /* The device and inode of the file the last time we checked. */
109 /* The specified name initially referred to a directory or some other
110 type for which tail isn't meaningful. Unlike for a permission problem
111 (tailable, below) once this is set, the name is not checked ever again. */
114 /* See description of DEFAULT_MAX_N_... below. */
115 unsigned int n_unchanged_stats;
117 /* See description of DEFAULT_MAX_N_... below. */
118 unsigned int n_consecutive_size_changes;
120 /* A file is tailable if it exists, is readable, and is of type
121 IS_TAILABLE_FILE_TYPE. */
124 /* The value of errno seen last time we checked this file. */
129 /* Keep trying to open a file even if it is inaccessible when tail starts
130 or if it becomes inaccessible later -- useful only with -f. */
131 static int reopen_inaccessible_files;
133 /* If nonzero, interpret the numeric argument as the number of lines.
134 Otherwise, interpret it as the number of bytes. */
135 static int count_lines;
137 /* Whether we follow the name of each file or the file descriptor
138 that is initially associated with each name. */
139 static enum Follow_mode follow_mode = Follow_descriptor;
141 /* If nonzero, read from the ends of all specified files until killed. */
144 /* If nonzero, count from start of file instead of end. */
145 static int from_start;
147 /* If nonzero, print filename headers. */
148 static int print_headers;
150 /* When to print the filename banners. */
153 multiple_files, always, never
156 /* When tailing a file by name, if there have been this many consecutive
157 iterations for which the size has remained the same, then open/fstat
158 the file to determine if that file name is still associated with the
159 same device/inode-number pair as before. This option is meaningful only
160 when following by name. --max-unchanged-stats=N */
161 #define DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS 5
162 static unsigned long max_n_unchanged_stats_between_opens =
163 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS;
165 /* This variable is used to ensure that a file that is unlinked or moved
166 aside, yet always growing will be recognized as having been renamed.
167 After detecting this many consecutive size changes for a file, open/fstat
168 the file to determine if that file name is still associated with the
169 same device/inode-number pair as before. This option is meaningful only
170 when following by name. --max-consecutive-size-changes=N */
171 #define DEFAULT_MAX_N_CONSECUTIVE_SIZE_CHANGES 200
172 static unsigned long max_n_consecutive_size_changes_between_opens =
173 DEFAULT_MAX_N_CONSECUTIVE_SIZE_CHANGES;
175 /* The name this program was run with. */
178 /* The number of seconds to sleep between iterations.
179 During one iteration, every file name or descriptor is checked to
180 see if it has changed. */
181 /* FIXME: allow fractional seconds */
182 static unsigned int sleep_interval = 1;
184 /* The process ID of the process (presumably on the current host)
185 that is writing to all followed files. */
188 /* Nonzero if we have ever read standard input. */
189 static int have_read_stdin;
191 /* For long options that have no equivalent short option, use a
192 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
195 RETRY_OPTION = CHAR_MAX + 1,
196 MAX_UNCHANGED_STATS_OPTION,
198 /* FIXME: remove this in 2001, unless someone can show a good
199 reason to keep it. */
200 MAX_CONSECUTIVE_SIZE_CHANGES_OPTION,
206 static struct option const long_options[] =
208 /* --allow-missing is deprecated; use --retry instead
209 FIXME: remove it some day */
210 {"allow-missing", no_argument, NULL, RETRY_OPTION},
211 {"bytes", required_argument, NULL, 'c'},
212 {"follow", optional_argument, NULL, LONG_FOLLOW_OPTION},
213 {"lines", required_argument, NULL, 'n'},
214 {"max-unchanged-stats", required_argument, NULL, MAX_UNCHANGED_STATS_OPTION},
215 {"max-consecutive-size-changes", required_argument, NULL,
216 MAX_CONSECUTIVE_SIZE_CHANGES_OPTION},
217 {"pid", required_argument, NULL, PID_OPTION},
218 {"quiet", no_argument, NULL, 'q'},
219 {"retry", no_argument, NULL, RETRY_OPTION},
220 {"silent", no_argument, NULL, 'q'},
221 {"sleep-interval", required_argument, NULL, 's'},
222 {"verbose", no_argument, NULL, 'v'},
223 {GETOPT_HELP_OPTION_DECL},
224 {GETOPT_VERSION_OPTION_DECL},
232 fprintf (stderr, _("Try `%s --help' for more information.\n"),
237 Usage: %s [OPTION]... [FILE]...\n\
241 Print the last %d lines of each FILE to standard output.\n\
242 With more than one FILE, precede each with a header giving the file name.\n\
243 With no FILE, or when FILE is -, read standard input.\n\
245 --retry keep trying to open a file even if it is\n\
246 inaccessible when tail starts or if it becomes\n\
247 inaccessible later -- useful only with -f\n\
248 -c, --bytes=N output the last N bytes\n\
249 -f, --follow[={name|descriptor}]\n\
250 output appended data as the file grows;\n\
251 -f, --follow, and --follow=descriptor are\n\
253 -F same as --follow=name --retry\n\
254 -n, --lines=N output the last N lines, instead of the last %d\n\
255 --max-unchanged-stats=N\n\
256 with --follow=name, reopen a FILE which has not\n\
257 changed size after N (default %d) iterations\n\
258 to see if it has been unlinked or renamed\n\
259 (this is the usual case of rotated log files)\n\
260 --pid=PID with -f, terminate after process ID, PID dies\n\
261 -q, --quiet, --silent never output headers giving file names\n\
262 -s, --sleep-interval=S with -f, each iteration lasts approximately S\n\
263 (default 1) seconds\n\
264 -v, --verbose always output headers giving file names\n\
265 --help display this help and exit\n\
266 --version output version information and exit\n\
269 DEFAULT_N_LINES, DEFAULT_N_LINES,
270 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
273 If the first character of N (the number of bytes or lines) is a `+',\n\
274 print beginning with the Nth item from the start of each file, otherwise,\n\
275 print the last N items in the file. N may have a multiplier suffix:\n\
276 b for 512, k for 1024, m for 1048576 (1 Meg). A first OPTION of -VALUE\n\
277 or +VALUE is treated like -n VALUE or -n +VALUE unless VALUE has one of\n\
278 the [bkm] suffix multipliers, in which case it is treated like -c VALUE\n\
279 or -c +VALUE. Warning: a first option of +VALUE is obsolescent, and support\n\
280 for it will be withdrawn.\n\
282 With --follow (-f), tail defaults to following the file descriptor, which\n\
283 means that even if a tail'ed file is renamed, tail will continue to track\n\
284 its end. This default behavior is not desirable when you really want to\n\
285 track the actual name of the file, not the file descriptor (e.g., log\n\
286 rotation). Use --follow=name in that case. That causes tail to track the\n\
287 named file by reopening it periodically to see if it has been removed and\n\
288 recreated by some other program.\n\
291 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
293 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
297 valid_file_spec (struct File_spec const *f)
299 /* Exactly one of the following subexpressions must be true. */
300 return ((f->fd == -1) ^ (f->errnum == 0));
304 pretty_name (struct File_spec const *f)
306 return (STREQ (f->name, "-") ? "standard input" : f->name);
310 xwrite (int fd, char *const buffer, size_t n_bytes)
312 assert (fd == STDOUT_FILENO);
313 assert (n_bytes >= 0);
314 if (n_bytes > 0 && fwrite (buffer, 1, n_bytes, stdout) == 0)
315 error (EXIT_FAILURE, errno, _("write error"));
319 close_fd (int fd, const char *filename)
321 if (fd != -1 && fd != STDIN_FILENO && close (fd))
323 error (0, errno, _("closing %s (fd=%d)"), filename, fd);
328 write_header (const char *pretty_filename)
330 static int first_file = 1;
332 printf ("%s==> %s <==\n", (first_file ? "" : "\n"), pretty_filename);
336 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
337 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
338 Return the number of bytes read from the file. */
341 dump_remainder (const char *pretty_filename, int fd, off_t n_bytes)
346 off_t n_remaining = n_bytes;
351 long n = MIN (n_remaining, (off_t) BUFSIZ);
352 bytes_read = safe_read (fd, buffer, n);
355 xwrite (STDOUT_FILENO, buffer, bytes_read);
356 n_remaining -= bytes_read;
357 n_written += bytes_read;
359 if (bytes_read == -1)
360 error (EXIT_FAILURE, errno, "%s", pretty_filename);
365 /* Print the last N_LINES lines from the end of file FD.
366 Go backward through the file, reading `BUFSIZ' bytes at a time (except
367 probably the first), until we hit the start of the file or have
368 read NUMBER newlines.
369 FILE_LENGTH is the length of the file (one more than the offset of the
370 last byte of the file).
371 Return 0 if successful, 1 if an error occurred. */
374 file_lines (const char *pretty_filename, int fd, long int n_lines,
379 int i; /* Index into `buffer' for scanning. */
380 off_t pos = file_length;
385 /* Set `bytes_read' to the size of the last, probably partial, buffer;
386 0 < `bytes_read' <= `BUFSIZ'. */
387 bytes_read = pos % BUFSIZ;
390 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
391 reads will be on block boundaries, which might increase efficiency. */
393 /* FIXME: check lseek return value */
394 lseek (fd, pos, SEEK_SET);
395 bytes_read = safe_read (fd, buffer, bytes_read);
396 if (bytes_read == -1)
398 error (0, errno, "%s", pretty_filename);
402 /* Count the incomplete line on files that don't end with a newline. */
403 if (bytes_read && buffer[bytes_read - 1] != '\n')
408 /* Scan backward, counting the newlines in this bufferfull. */
409 for (i = bytes_read - 1; i >= 0; i--)
411 /* Have we counted the requested number of newlines yet? */
412 if (buffer[i] == '\n' && n_lines-- == 0)
414 /* If this newline wasn't the last character in the buffer,
415 print the text after it. */
416 if (i != bytes_read - 1)
417 xwrite (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1));
418 dump_remainder (pretty_filename, fd,
419 file_length - (pos + bytes_read));
423 /* Not enough newlines in that bufferfull. */
426 /* Not enough lines in the file; print the entire file. */
427 /* FIXME: check lseek return value */
428 lseek (fd, (off_t) 0, SEEK_SET);
429 dump_remainder (pretty_filename, fd, file_length);
433 /* FIXME: check lseek return value */
434 lseek (fd, pos, SEEK_SET);
436 while ((bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0);
438 if (bytes_read == -1)
440 error (0, errno, "%s", pretty_filename);
447 /* Print the last N_LINES lines from the end of the standard input,
448 open for reading as pipe FD.
449 Buffer the text as a linked list of LBUFFERs, adding them as needed.
450 Return 0 if successful, 1 if an error occured. */
453 pipe_lines (const char *pretty_filename, int fd, long int n_lines)
459 struct linebuffer *next;
461 typedef struct linebuffer LBUFFER;
462 LBUFFER *first, *last, *tmp;
463 int i; /* Index into buffers. */
464 int total_lines = 0; /* Total number of newlines in all buffers. */
466 int nbytes; /* Size of most recent read */
468 first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER));
469 first->nbytes = first->nlines = 0;
471 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
473 /* Input is always read into a fresh buffer. */
474 while ((nbytes = tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
479 /* Count the number of newlines just read. */
480 for (i = 0; i < tmp->nbytes; i++)
481 if (tmp->buffer[i] == '\n')
483 total_lines += tmp->nlines;
485 /* If there is enough room in the last buffer read, just append the new
486 one to it. This is because when reading from a pipe, `nbytes' can
487 often be very small. */
488 if (tmp->nbytes + last->nbytes < BUFSIZ)
490 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
491 last->nbytes += tmp->nbytes;
492 last->nlines += tmp->nlines;
496 /* If there's not enough room, link the new buffer onto the end of
497 the list, then either free up the oldest buffer for the next
498 read if that would leave enough lines, or else malloc a new one.
499 Some compaction mechanism is possible but probably not
501 last = last->next = tmp;
502 if (total_lines - first->nlines > n_lines)
505 total_lines -= first->nlines;
509 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
517 error (0, errno, "%s", pretty_filename);
522 /* If the file is empty, then bail out. */
523 if (last->nbytes == 0)
526 /* This prevents a core dump when the pipe contains no newlines. */
530 /* Count the incomplete line on files that don't end with a newline. */
531 if (last->buffer[last->nbytes - 1] != '\n')
537 /* Run through the list, printing lines. First, skip over unneeded
539 for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
540 total_lines -= tmp->nlines;
542 /* Find the correct beginning, then print the rest of the file. */
543 if (total_lines > n_lines)
547 /* Skip `total_lines' - `n_lines' newlines. We made sure that
548 `total_lines' - `n_lines' <= `tmp->nlines'. */
550 for (i = total_lines - n_lines; i; --i)
551 while (*cp++ != '\n')
553 i = cp - tmp->buffer;
557 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
559 for (tmp = tmp->next; tmp; tmp = tmp->next)
560 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
566 free ((char *) first);
572 /* Print the last N_BYTES characters from the end of pipe FD.
573 This is a stripped down version of pipe_lines.
574 Return 0 if successful, 1 if an error occurred. */
577 pipe_bytes (const char *pretty_filename, int fd, off_t n_bytes)
583 struct charbuffer *next;
585 typedef struct charbuffer CBUFFER;
586 CBUFFER *first, *last, *tmp;
587 int i; /* Index into buffers. */
588 int total_bytes = 0; /* Total characters in all buffers. */
591 first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER));
594 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
596 /* Input is always read into a fresh buffer. */
597 while ((tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
601 total_bytes += tmp->nbytes;
602 /* If there is enough room in the last buffer read, just append the new
603 one to it. This is because when reading from a pipe, `nbytes' can
604 often be very small. */
605 if (tmp->nbytes + last->nbytes < BUFSIZ)
607 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
608 last->nbytes += tmp->nbytes;
612 /* If there's not enough room, link the new buffer onto the end of
613 the list, then either free up the oldest buffer for the next
614 read if that would leave enough characters, or else malloc a new
615 one. Some compaction mechanism is possible but probably not
617 last = last->next = tmp;
618 if (total_bytes - first->nbytes > n_bytes)
621 total_bytes -= first->nbytes;
626 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
630 if (tmp->nbytes == -1)
632 error (0, errno, "%s", pretty_filename);
640 /* Run through the list, printing characters. First, skip over unneeded
642 for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
643 total_bytes -= tmp->nbytes;
645 /* Find the correct beginning, then print the rest of the file.
646 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
647 if (total_bytes > n_bytes)
648 i = total_bytes - n_bytes;
651 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
653 for (tmp = tmp->next; tmp; tmp = tmp->next)
654 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
660 free ((char *) first);
666 /* Skip N_BYTES characters from the start of pipe FD, and print
667 any extra characters that were read beyond that.
668 Return 1 on error, 0 if ok. */
671 start_bytes (const char *pretty_filename, int fd, off_t n_bytes)
676 while (n_bytes > 0 && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
677 n_bytes -= bytes_read;
678 if (bytes_read == -1)
680 error (0, errno, "%s", pretty_filename);
683 else if (n_bytes < 0)
684 xwrite (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
688 /* Skip N_LINES lines at the start of file or pipe FD, and print
689 any extra characters that were read beyond that.
690 Return 1 on error, 0 if ok. */
693 start_lines (const char *pretty_filename, int fd, long int n_lines)
697 int bytes_to_skip = 0;
699 while (n_lines && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
702 while (bytes_to_skip < bytes_read)
703 if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
706 if (bytes_read == -1)
708 error (0, errno, "%s", pretty_filename);
711 else if (bytes_to_skip < bytes_read)
713 xwrite (STDOUT_FILENO, &buffer[bytes_to_skip],
714 bytes_read - bytes_to_skip);
719 /* FIXME: describe */
722 recheck (struct File_spec *f)
724 /* open/fstat the file and announce if dev/ino have changed */
725 struct stat new_stats;
728 int is_stdin = (STREQ (f->name, "-"));
729 int was_tailable = f->tailable;
730 int prev_errnum = f->errnum;
733 assert (valid_file_spec (f));
735 fd = (is_stdin ? STDIN_FILENO : open (f->name, O_RDONLY));
737 /* If the open fails because the file doesn't exist,
738 then mark the file as not tailable. */
739 f->tailable = !(reopen_inaccessible_files && fd == -1);
741 if (fd == -1 || fstat (fd, &new_stats) < 0)
749 /* FIXME-maybe: detect the case in which the file first becomes
750 unreadable (perms), and later becomes readable again and can
751 be seen to be the same file (dev/ino). Otherwise, tail prints
752 the entire contents of the file when it becomes readable. */
753 error (0, f->errnum, _("`%s' has become inaccessible"),
758 /* say nothing... it's still not tailable */
761 else if (prev_errnum != errno)
763 error (0, errno, "%s", pretty_name (f));
766 else if (!IS_TAILABLE_FILE_TYPE (new_stats.st_mode))
770 error (0, 0, _("`%s' has been replaced with an untailable file;\
771 giving up on this name"),
783 close_fd (fd, pretty_name (f));
784 close_fd (f->fd, pretty_name (f));
787 else if (prev_errnum && prev_errnum != ENOENT)
790 assert (f->fd == -1);
791 error (0, 0, _("`%s' has become accessible"), pretty_name (f));
793 else if (f->ino != new_stats.st_ino || f->dev != new_stats.st_dev)
799 _("`%s' has appeared; following end of new file"),
804 /* Close the old one. */
805 close_fd (f->fd, pretty_name (f));
807 /* File has been replaced (e.g., via log rotation) --
810 _("`%s' has been replaced; following end of new file"),
818 /* This happens when one iteration finds the file missing,
819 then the preceding <dev,inode> pair is reused as the
820 file is recreated. */
825 close_fd (fd, pretty_name (f));
831 /* Record new file info in f. */
833 f->size = 0; /* Start at the beginning of the file... */
834 f->dev = new_stats.st_dev;
835 f->ino = new_stats.st_ino;
836 f->n_unchanged_stats = 0;
837 f->n_consecutive_size_changes = 0;
839 /* FIXME: check lseek return value */
840 lseek (f->fd, f->size, SEEK_SET);
844 /* FIXME: describe */
847 n_live_files (const struct File_spec *f, int n_files)
850 unsigned int n_live = 0;
852 for (i = 0; i < n_files; i++)
860 /* Tail NFILES files forever, or until killed.
861 The pertinent information for each file is stored in an entry of F.
862 Loop over each of them, doing an fstat to see if they have changed size,
863 and an occasional open/fstat to see if any dev/ino pair has changed.
864 If none of them have changed size in one iteration, sleep for a
865 while and try again. Continue until the user interrupts us. */
868 tail_forever (struct File_spec *f, int nfiles)
871 int writer_is_dead = 0;
881 for (i = 0; i < nfiles; i++)
894 if (fstat (f[i].fd, &stats) < 0)
898 error (0, errno, "%s", pretty_name (&f[i]));
902 if (stats.st_size == f[i].size)
904 f[i].n_consecutive_size_changes = 0;
905 if (++f[i].n_unchanged_stats > max_n_unchanged_stats_between_opens
906 && follow_mode == Follow_name)
909 f[i].n_unchanged_stats = 0;
915 ++f[i].n_consecutive_size_changes;
917 /* Ensure that a file that's unlinked or moved aside, yet always
918 growing will be recognized as having been renamed. */
919 if (follow_mode == Follow_name
920 && (f[i].n_consecutive_size_changes
921 > max_n_consecutive_size_changes_between_opens))
923 f[i].n_consecutive_size_changes = 0;
928 /* This file has changed size. Print out what we can, and
929 then keep looping. */
934 f[i].n_unchanged_stats = 0;
936 if (stats.st_size < f[i].size)
938 error (0, 0, _("%s: file truncated"), pretty_name (&f[i]));
940 /* FIXME: check lseek return value */
941 lseek (f[i].fd, stats.st_size, SEEK_SET);
942 f[i].size = stats.st_size;
949 write_header (pretty_name (&f[i]));
952 f[i].size += dump_remainder (pretty_name (&f[i]), f[i].fd,
956 if (n_live_files (f, nfiles) == 0 && ! reopen_inaccessible_files)
958 error (0, 0, _("no files remaining"));
962 /* If none of the files changed size, sleep. */
967 sleep (sleep_interval);
969 /* Once the writer is dead, read the files once more to
970 avoid a race condition. */
971 writer_is_dead = (pid != 0
972 && kill (pid, 0) != 0
973 /* Handle the case in which you cannot send a
974 signal to the writer, so kill fails and sets
981 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
982 Return 0 if successful, 1 if an error occurred. */
985 tail_bytes (const char *pretty_filename, int fd, off_t n_bytes)
989 /* We need binary input, since `tail' relies on `lseek' and byte counts,
990 while binary output will preserve the style (Unix/DOS) of text file. */
991 SET_BINARY2 (fd, STDOUT_FILENO);
993 if (fstat (fd, &stats))
995 error (0, errno, "%s", pretty_filename);
1001 if (S_ISREG (stats.st_mode))
1003 /* FIXME: check lseek return value */
1004 lseek (fd, n_bytes, SEEK_CUR);
1006 else if (start_bytes (pretty_filename, fd, n_bytes))
1010 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1014 if (S_ISREG (stats.st_mode))
1016 off_t current_pos, end_pos;
1017 size_t bytes_remaining;
1019 if ((current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
1020 && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
1023 /* Be careful here. The current position may actually be
1024 beyond the end of the file. */
1025 bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
1029 error (0, errno, "%s", pretty_filename);
1033 if (bytes_remaining <= n_bytes)
1035 /* From the current position to end of file, there are no
1036 more bytes than have been requested. So reposition the
1037 file pointer to the incoming current position and print
1038 everything after that. */
1039 /* FIXME: check lseek return value */
1040 lseek (fd, current_pos, SEEK_SET);
1044 /* There are more bytes remaining than were requested.
1046 /* FIXME: check lseek return value */
1047 lseek (fd, -n_bytes, SEEK_END);
1049 dump_remainder (pretty_filename, fd, n_bytes);
1052 return pipe_bytes (pretty_filename, fd, n_bytes);
1057 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1058 Return 0 if successful, 1 if an error occurred. */
1061 tail_lines (const char *pretty_filename, int fd, long int n_lines)
1066 /* We need binary input, since `tail' relies on `lseek' and byte counts,
1067 while binary output will preserve the style (Unix/DOS) of text file. */
1068 SET_BINARY2 (fd, STDOUT_FILENO);
1070 if (fstat (fd, &stats))
1072 error (0, errno, "%s", pretty_filename);
1078 if (start_lines (pretty_filename, fd, n_lines))
1080 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1084 /* Use file_lines only if FD refers to a regular file with
1085 its file pointer positioned at beginning of file. */
1086 /* FIXME: adding the lseek conjunct is a kludge.
1087 Once there's a reasonable test suite, fix the true culprit:
1088 file_lines. file_lines shouldn't presume that the input
1089 file pointer is initially positioned to beginning of file. */
1090 if (S_ISREG (stats.st_mode)
1091 && lseek (fd, (off_t) 0, SEEK_CUR) == (off_t) 0)
1093 length = lseek (fd, (off_t) 0, SEEK_END);
1094 if (length != 0 && file_lines (pretty_filename, fd, n_lines, length))
1098 return pipe_lines (pretty_filename, fd, n_lines);
1103 /* Display the last N_UNITS units of file FILENAME, open for reading
1105 Return 0 if successful, 1 if an error occurred. */
1108 tail (const char *pretty_filename, int fd, off_t n_units)
1111 return tail_lines (pretty_filename, fd, (long) n_units);
1113 return tail_bytes (pretty_filename, fd, n_units);
1116 /* Display the last N_UNITS units of the file described by F.
1117 Return 0 if successful, 1 if an error occurred. */
1120 tail_file (struct File_spec *f, off_t n_units)
1125 int is_stdin = (STREQ (f->name, "-"));
1129 have_read_stdin = 1;
1134 fd = open (f->name, O_RDONLY);
1137 f->tailable = !(reopen_inaccessible_files && fd == -1);
1149 error (0, errno, "%s", pretty_name (f));
1155 write_header (pretty_name (f));
1156 errors = tail (pretty_name (f), fd, n_units);
1160 /* FIXME: duplicate code */
1161 if (fstat (fd, &stats) < 0)
1165 error (0, errno, "%s", pretty_name (f));
1167 else if (!IS_TAILABLE_FILE_TYPE (stats.st_mode))
1169 error (0, 0, _("%s: cannot follow end of this type of file;\
1170 giving up on this name"),
1179 close_fd (fd, pretty_name (f));
1185 f->size = stats.st_size;
1186 f->dev = stats.st_dev;
1187 f->ino = stats.st_ino;
1188 f->n_unchanged_stats = 0;
1189 f->n_consecutive_size_changes = 0;
1195 if (!is_stdin && close (fd))
1197 error (0, errno, "%s", pretty_name (f));
1206 /* If the command line arguments are of the obsolescent form and the
1207 option string is well-formed, set *FAIL to zero, set *N_UNITS, the
1208 globals COUNT_LINES, FOREVER, and FROM_START, and return non-zero.
1209 Otherwise, if the command line arguments appear to be of the
1210 obsolescent form but the option string is malformed, set *FAIL to
1211 non-zero, don't modify any other parameter or global variable, and
1212 return non-zero. Otherwise, return zero and don't modify any parameter
1213 or global variable. */
1216 parse_obsolescent_option (int argc, const char *const *argv,
1217 off_t *n_units, int *fail)
1219 const char *p = argv[1];
1220 const char *n_string = NULL;
1221 const char *n_string_end;
1227 /* With the obsolescent form, there is one option string and
1228 (technically) at most one file argument. But we allow two or more
1233 /* If P starts with `+', `-N' (where N is a digit), or `-l',
1234 then it is obsolescent. Return zero otherwise. */
1235 if ( ! (p[0] == '+' || (p[0] == '-' && (p[1] == 'l' || ISDIGIT (p[1])))) )
1253 while (ISDIGIT (*p));
1258 if (*p == 'c' || *p == 'b')
1277 /* If (argv[1] begins with a `+' or if it begins with `-' followed
1278 by a digit), but has an invalid suffix character, give a diagnostic
1279 and indicate to caller that this *is* of the obsolescent form,
1280 but that it's an invalid option. */
1281 if (t_from_start || n_string)
1284 _("%c: invalid suffix character in obsolescent option" ), *p);
1289 /* Otherwise, it might be a valid non-obsolescent option like -n. */
1294 if (n_string == NULL)
1295 *n_units = DEFAULT_N_LINES;
1299 unsigned long int tmp_ulong;
1302 s_err = xstrtoul (n_string, &end, 10, &tmp_ulong,
1303 *n_string_end == 'b' ? "b" : NULL);
1304 if (s_err == LONGINT_OK && tmp_ulong <= OFF_T_MAX)
1305 *n_units = (off_t) tmp_ulong;
1308 /* Extract a NUL-terminated string for the error message. */
1309 size_t len = n_string_end - n_string;
1310 char *n_string_tmp = xmalloc (len + 1);
1312 strncpy (n_string_tmp, n_string, len);
1313 n_string_tmp[len] = '\0';
1316 _("%s: %s is so large that it is not representable"),
1317 n_string_tmp, (t_count_lines
1318 ? _("number of lines")
1319 : _("number of bytes")));
1320 free (n_string_tmp);
1329 int posix_pedantic = (getenv ("POSIXLY_CORRECT") != NULL);
1331 /* When POSIXLY_CORRECT is set, enforce the `at most one
1332 file argument' requirement. */
1336 too many arguments; When using tail's obsolescent option syntax (%s)\n\
1337 there may be no more than one file argument. Use the equivalent -n or -c\n\
1338 option instead."), argv[1]);
1343 #if DISABLED /* FIXME: enable or remove this warning. */
1345 Warning: it is not portable to use two or more file arguments with\n\
1346 tail's obsolescent option syntax (%s). Use the equivalent -n or -c\n\
1347 option instead."), argv[1]);
1352 from_start = t_from_start;
1353 count_lines = t_count_lines;
1354 forever = t_forever;
1361 parse_options (int argc, char **argv,
1362 off_t *n_units, enum header_mode *header_mode)
1367 forever = from_start = print_headers = 0;
1369 while ((c = getopt_long (argc, argv, "c:n:fFqs:v", long_options, NULL))
1379 follow_mode = Follow_name;
1380 reopen_inaccessible_files = 1;
1385 count_lines = (c == 'n');
1388 else if (*optarg == '-')
1394 s_err = xstrtoumax (optarg, NULL, 10, &n, "bkm");
1395 if (s_err == LONGINT_INVALID)
1397 error (EXIT_FAILURE, 0, "%s: %s", optarg,
1399 ? _("invalid number of lines")
1400 : _("invalid number of bytes")));
1403 if (s_err != LONGINT_OK)
1404 error (EXIT_FAILURE, 0,
1405 _("%s: is so large that it is not representable"), optarg);
1408 error (EXIT_FAILURE, 0,
1409 _("%s is larger than the maximum file size on this system"),
1411 *n_units = (off_t) n;
1416 case LONG_FOLLOW_OPTION:
1419 follow_mode = DEFAULT_FOLLOW_MODE;
1421 follow_mode = XARGMATCH ("--follow", optarg,
1422 follow_mode_string, follow_mode_map);
1426 reopen_inaccessible_files = 1;
1429 case MAX_UNCHANGED_STATS_OPTION:
1430 /* --max-unchanged-stats=N */
1431 if (xstrtoul (optarg, NULL, 10,
1432 &max_n_unchanged_stats_between_opens, "") != LONGINT_OK)
1434 error (EXIT_FAILURE, 0,
1435 _("%s: invalid maximum number of unchanged stats between opens"),
1440 case MAX_CONSECUTIVE_SIZE_CHANGES_OPTION:
1441 /* --max-consecutive-size-changes=N */
1442 if (xstrtoul (optarg, NULL, 10,
1443 &max_n_consecutive_size_changes_between_opens, "")
1446 error (EXIT_FAILURE, 0,
1447 _("%s: invalid maximum number of consecutive size changes"),
1455 unsigned long int tmp_ulong;
1456 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1457 if (s_err != LONGINT_OK || tmp_ulong > PID_T_MAX)
1459 error (EXIT_FAILURE, 0, _("%s: invalid PID"), optarg);
1466 *header_mode = never;
1472 unsigned long int tmp_ulong;
1473 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1474 if (s_err != LONGINT_OK || tmp_ulong > UINT_MAX)
1476 error (EXIT_FAILURE, 0,
1477 _("%s: invalid number of seconds"), optarg);
1479 sleep_interval = tmp_ulong;
1484 *header_mode = always;
1487 case_GETOPT_HELP_CHAR;
1489 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1496 if (reopen_inaccessible_files && follow_mode != Follow_name)
1497 error (0, 0, _("warning: --retry is useful only when following by name"));
1499 if (pid && !forever)
1501 _("warning: PID ignored; --pid=PID is useful only when following"));
1502 else if (pid && kill (pid, 0) != 0 && errno == ENOSYS)
1504 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1510 main (int argc, char **argv)
1512 enum header_mode header_mode = multiple_files;
1513 int exit_status = 0;
1514 /* If from_start, the number of items to skip before printing; otherwise,
1515 the number of items at the end of the file to print. Although the type
1516 is signed, the value is never negative. */
1517 off_t n_units = DEFAULT_N_LINES;
1520 struct File_spec *F;
1523 program_name = argv[0];
1524 setlocale (LC_ALL, "");
1525 bindtextdomain (PACKAGE, LOCALEDIR);
1526 textdomain (PACKAGE);
1528 atexit (close_stdout);
1530 have_read_stdin = 0;
1533 int found_obsolescent;
1535 found_obsolescent = parse_obsolescent_option (argc,
1536 (const char *const *) argv,
1538 if (found_obsolescent)
1541 exit (EXIT_FAILURE);
1546 parse_options (argc, argv, &n_units, &header_mode);
1550 /* To start printing with item N_UNITS from the start of the file, skip
1551 N_UNITS - 1 items. `tail +0' is actually meaningless, but for Unix
1552 compatibility it's treated the same as `tail +1'. */
1559 n_files = argc - optind;
1560 file = argv + optind;
1564 static char *dummy_stdin = "-";
1566 file = &dummy_stdin;
1569 F = (struct File_spec *) xmalloc (n_files * sizeof (F[0]));
1570 for (i = 0; i < n_files; i++)
1571 F[i].name = file[i];
1573 if (header_mode == always
1574 || (header_mode == multiple_files && n_files > 1))
1577 for (i = 0; i < n_files; i++)
1578 exit_status |= tail_file (&F[i], n_units);
1582 /* This fflush appears to be required only on Solaris2.7. */
1583 if (fflush (stdout) < 0)
1584 error (EXIT_FAILURE, errno, _("write error"));
1586 SETVBUF (stdout, NULL, _IONBF, 0);
1587 tail_forever (F, n_files);
1590 if (have_read_stdin && close (0) < 0)
1591 error (EXIT_FAILURE, errno, "-");
1592 exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);