359 lines
10 KiB
C
359 lines
10 KiB
C
/* tail - copy the end of a file Author: Norbert Schlenker */
|
|
|
|
/* Syntax: tail [-f] [-c number | -n number] [file]
|
|
* tail -[number][c|l][f] [file] (obsolescent)
|
|
* tail +[number][c|l][f] [file] (obsolescent)
|
|
* Flags:
|
|
* -c number Measure starting point in bytes. If number begins
|
|
* with '+', the starting point is relative to the
|
|
* the file's beginning. If number begins with '-'
|
|
* or has no sign, the starting point is relative to
|
|
* the end of the file.
|
|
* -f Keep trying to read after EOF on files and FIFOs.
|
|
* -n number Measure starting point in lines. The number
|
|
* following the flag has significance similar to
|
|
* that described for the -c flag.
|
|
*
|
|
* If neither -c nor -n are specified, the default is tail -n 10.
|
|
*
|
|
* In the obsolescent syntax, an argument with a 'c' following the
|
|
* (optional) number is equivalent to "-c number" in the standard
|
|
* syntax, with number including the leading sign ('+' or '-') of the
|
|
* argument. An argument with 'l' following the number is equivalent
|
|
* to "-n number" in the standard syntax. If the number is not
|
|
* specified, 10 is used as the default. If neither 'c' nor 'l' are
|
|
* specified, 'l' is assumed. The character 'f' may be suffixed to
|
|
* the argument and is equivalent to specifying "-f" in the standard
|
|
* syntax. Look for lines marked "OBSOLESCENT".
|
|
*
|
|
* If no file is specified, standard input is assumed.
|
|
*
|
|
* P1003.2 does not specify tail's behavior when a count of 0 is given.
|
|
* It also does not specify clearly whether the first byte (line) of a
|
|
* file should be numbered 0 or 1. Historical behavior is that the
|
|
* first byte is actually number 1 (contrary to all Unix standards).
|
|
* Historically, a count of 0 (or -0) results in no output whatsoever,
|
|
* while a count of +0 results in the entire file being copied (just like
|
|
* +1). The implementor does not agree with these behaviors, but has
|
|
* copied them slavishly. Look for lines marked "HISTORICAL".
|
|
*
|
|
* Author: Norbert Schlenker
|
|
* Copyright: None. Released to the public domain.
|
|
* Reference: P1003.2 section 4.59 (draft 10)
|
|
* Notes: Under Minix, this program requires chmem =30000.
|
|
* Bugs: No internationalization support; all messages are in English.
|
|
*/
|
|
|
|
/* Force visible Posix names */
|
|
#ifndef _POSIX_SOURCE
|
|
#define _POSIX_SOURCE 1
|
|
#endif
|
|
|
|
/* External interfaces */
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
/* External interfaces that should have been standardized into <getopt.h> */
|
|
extern char *optarg;
|
|
extern int optind;
|
|
|
|
/* We expect this constant to be defined in <limits.h> in a Posix program,
|
|
* but we'll specify it here just in case it's been left out.
|
|
*/
|
|
#ifndef LINE_MAX
|
|
#define LINE_MAX 2048 /* minimum acceptable lower bound */
|
|
#endif
|
|
|
|
/* Magic numbers suggested or required by Posix specification */
|
|
#define SUCCESS 0 /* exit code in case of success */
|
|
#define FAILURE 1 /* or failure */
|
|
#define DEFAULT_COUNT 10 /* default number of lines or bytes */
|
|
#define MIN_BUFSIZE (LINE_MAX * DEFAULT_COUNT)
|
|
#define SLEEP_INTERVAL 1 /* sleep for one second intervals with -f */
|
|
|
|
#define FALSE 0
|
|
#define TRUE 1
|
|
|
|
/* Internal functions - prototyped under Minix */
|
|
_PROTOTYPE(int main, (int argc, char **argv));
|
|
_PROTOTYPE(int tail, (int count, int bytes, int read_until_killed));
|
|
_PROTOTYPE(int keep_reading, (void));
|
|
_PROTOTYPE(void usage, (void));
|
|
|
|
int main(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
int cflag = FALSE;
|
|
int nflag = FALSE;
|
|
int fflag = FALSE;
|
|
int number = -DEFAULT_COUNT;
|
|
char *suffix;
|
|
int opt;
|
|
struct stat stat_buf;
|
|
|
|
/* Determining whether this invocation is via the standard syntax or
|
|
* via an obsolescent one is a nasty kludge. Here it is, but there is
|
|
* no pretense at elegance.
|
|
*/
|
|
if (argc == 1) { /* simple: default read of a pipe */
|
|
exit(tail(-DEFAULT_COUNT, 0, fflag));
|
|
}
|
|
if ((argv[1][0] == '+') || /* OBSOLESCENT */
|
|
(argv[1][0] == '-' && ((isdigit(argv[1][1])) ||
|
|
(argv[1][1] == 'l') ||
|
|
(argv[1][1] == 'c' && argv[1][2] == 'f')))) {
|
|
--argc; ++argv;
|
|
if (isdigit(argv[0][1])) {
|
|
number = (int)strtol(argv[0], &suffix, 10);
|
|
if (number == 0) { /* HISTORICAL */
|
|
if (argv[0][0] == '+')
|
|
number = 1;
|
|
else
|
|
exit(SUCCESS);
|
|
}
|
|
} else {
|
|
number = (argv[0][0] == '+') ? DEFAULT_COUNT : -DEFAULT_COUNT;
|
|
suffix = &(argv[0][1]);
|
|
}
|
|
if (*suffix != '\0') {
|
|
if (*suffix == 'c') {
|
|
cflag = TRUE;
|
|
++suffix;
|
|
}
|
|
else
|
|
if (*suffix == 'l') {
|
|
nflag = TRUE;
|
|
++suffix;
|
|
}
|
|
}
|
|
if (*suffix != '\0') {
|
|
if (*suffix == 'f') {
|
|
fflag = TRUE;
|
|
++suffix;
|
|
}
|
|
}
|
|
if (*suffix != '\0') { /* bad form: assume to be a file name */
|
|
number = -DEFAULT_COUNT;
|
|
cflag = nflag = FALSE;
|
|
fflag = FALSE;
|
|
} else {
|
|
--argc; ++argv;
|
|
}
|
|
} else { /* new standard syntax */
|
|
while ((opt = getopt(argc, argv, "c:fn:")) != EOF) {
|
|
switch (opt) {
|
|
case 'c':
|
|
cflag = TRUE;
|
|
if (*optarg == '+' || *optarg == '-')
|
|
number = atoi(optarg);
|
|
else
|
|
if (isdigit(*optarg))
|
|
number = -atoi(optarg);
|
|
else
|
|
usage();
|
|
if (number == 0) { /* HISTORICAL */
|
|
if (*optarg == '+')
|
|
number = 1;
|
|
else
|
|
exit(SUCCESS);
|
|
}
|
|
break;
|
|
case 'f':
|
|
fflag = TRUE;
|
|
break;
|
|
case 'n':
|
|
nflag = TRUE;
|
|
if (*optarg == '+' || *optarg == '-')
|
|
number = atoi(optarg);
|
|
else
|
|
if (isdigit(*optarg))
|
|
number = -atoi(optarg);
|
|
else
|
|
usage();
|
|
if (number == 0) { /* HISTORICAL */
|
|
if (*optarg == '+')
|
|
number = 1;
|
|
else
|
|
exit(SUCCESS);
|
|
}
|
|
break;
|
|
default:
|
|
usage();
|
|
/* NOTREACHED */
|
|
}
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
}
|
|
|
|
if (argc > 1 || /* too many arguments */
|
|
(cflag && nflag)) { /* both bytes and lines specified */
|
|
usage();
|
|
}
|
|
|
|
if (argc > 0) { /* an actual file */
|
|
if (freopen(argv[0], "r", stdin) != stdin) {
|
|
fputs("tail: could not open ", stderr);
|
|
fputs(argv[0], stderr);
|
|
fputs("\n", stderr);
|
|
exit(FAILURE);
|
|
}
|
|
/* There is an optimization possibility here. If a file is being
|
|
* read, we need not look at the front of it. If we seek backwards
|
|
* from the end, we can (potentially) avoid looking at most of the
|
|
* file. Some systems fail when asked to seek backwards to a point
|
|
* before the start of the file, so we avoid that possibility.
|
|
*/
|
|
if (number < 0 && fstat(fileno(stdin), &stat_buf) == 0) {
|
|
long offset = cflag ? (long)number : (long)number * LINE_MAX;
|
|
|
|
if (-offset < stat_buf.st_size)
|
|
fseek(stdin, offset, SEEK_END);
|
|
}
|
|
} else {
|
|
fflag = FALSE; /* force -f off when reading a pipe */
|
|
}
|
|
exit(tail(number, cflag, fflag));
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
int tail(count, bytes, read_until_killed)
|
|
int count; /* lines or bytes desired */
|
|
int bytes; /* TRUE if we want bytes */
|
|
int read_until_killed; /* keep reading at EOF */
|
|
{
|
|
int c;
|
|
char *buf; /* pointer to input buffer */
|
|
char *buf_end; /* and one past its end */
|
|
char *start; /* pointer to first desired character in buf */
|
|
char *finish; /* pointer past last desired character */
|
|
int wrapped_once = FALSE; /* TRUE after buf has been filled once */
|
|
|
|
/* This is magic. If count is positive, it means start at the count'th
|
|
* line or byte, with the first line or byte considered number 1. Thus,
|
|
* we want to SKIP one less line or byte than the number specified. In
|
|
* the negative case, we look backward from the end of the file for the
|
|
* (count + 1)'th newline or byte, so we really want the count to be one
|
|
* LARGER than was specified (in absolute value). In either case, the
|
|
* right thing to do is:
|
|
*/
|
|
--count;
|
|
|
|
/* Count is positive: skip the desired lines or bytes and then copy. */
|
|
if (count >= 0) {
|
|
while (count > 0 && (c = getchar()) != EOF) {
|
|
if (bytes || c == '\n')
|
|
--count;
|
|
}
|
|
while ((c = getchar()) != EOF) {
|
|
if (putchar(c) == EOF)
|
|
return FAILURE;
|
|
}
|
|
if (read_until_killed)
|
|
return keep_reading();
|
|
return ferror(stdin) ? FAILURE : SUCCESS;
|
|
}
|
|
|
|
/* Count is negative: allocate a reasonably large buffer. */
|
|
if ((buf = (char *)malloc(MIN_BUFSIZE + 1)) == (char *)NULL) {
|
|
fputs("tail: out of memory\n", stderr);
|
|
return FAILURE;
|
|
}
|
|
buf_end = buf + (MIN_BUFSIZE + 1);
|
|
|
|
/* Read the entire file into the buffer. */
|
|
finish = buf;
|
|
while ((c = getchar()) != EOF) {
|
|
*finish++ = c;
|
|
if (finish == buf_end) {
|
|
finish = buf;
|
|
wrapped_once = TRUE;
|
|
}
|
|
}
|
|
if (ferror(stdin))
|
|
return FAILURE;
|
|
|
|
/* Back up inside the buffer. The count has already been adjusted to
|
|
* back up exactly one character too far, so we will bump the buffer
|
|
* pointer once after we're done.
|
|
*
|
|
* BUG: For large line counts, the buffer may not be large enough to
|
|
* hold all the lines. The specification allows the program to
|
|
* fail in such a case - this program will simply dump the entire
|
|
* buffer's contents as its best attempt at the desired behavior.
|
|
*/
|
|
if (finish != buf || wrapped_once) { /* file was not empty */
|
|
start = (finish == buf) ? buf_end - 1 : finish - 1;
|
|
while (start != finish) {
|
|
if ((bytes || *start == '\n') && ++count == 0)
|
|
break;
|
|
if (start == buf) {
|
|
start = buf_end - 1;
|
|
if (!wrapped_once) /* never wrapped: stop now */
|
|
break;
|
|
} else {
|
|
--start;
|
|
}
|
|
}
|
|
if (++start == buf_end) { /* bump after going too far */
|
|
start = buf;
|
|
}
|
|
if (finish > start) {
|
|
fwrite(start, 1, finish - start, stdout);
|
|
} else {
|
|
fwrite(start, 1, buf_end - start, stdout);
|
|
fwrite(buf, 1, finish - buf, stdout);
|
|
}
|
|
}
|
|
if (read_until_killed)
|
|
return keep_reading();
|
|
return ferror(stdout) ? FAILURE : SUCCESS;
|
|
}
|
|
|
|
/* Wake at intervals to reread standard input. Copy anything read to
|
|
* standard output and then go to sleep again.
|
|
*/
|
|
int keep_reading()
|
|
{
|
|
char buf[1024];
|
|
int n;
|
|
int i;
|
|
off_t pos;
|
|
struct stat st;
|
|
|
|
pos = lseek(0, (off_t) 0, SEEK_CUR);
|
|
for (;;) {
|
|
for (i = 0; i < 60; i++) {
|
|
while ((n = read(0, buf, sizeof(buf))) > 0) {
|
|
if (write(1, buf, n) < 0) return FAILURE;
|
|
}
|
|
if (n < 0) return FAILURE;
|
|
|
|
sleep(SLEEP_INTERVAL);
|
|
}
|
|
|
|
/* Rewind if suddenly truncated. */
|
|
if (pos != -1) {
|
|
if (fstat(0, &st) == -1) {
|
|
pos = -1;
|
|
} else
|
|
if (st.st_size < pos) {
|
|
pos = lseek(0, (off_t) 0, SEEK_SET);
|
|
} else {
|
|
pos = st.st_size;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Tell the user the standard syntax. */
|
|
void usage()
|
|
{
|
|
fputs("Usage: tail [-f] [-c number | -n number] [file]\n", stderr);
|
|
exit(FAILURE);
|
|
}
|