From 5858819e4e3bc738463e8f7cc7d808a388ebc6c1 Mon Sep 17 00:00:00 2001 From: Tobias Klauser Date: Sat, 3 Mar 2007 17:25:42 +0100 Subject: Initial import of debian package for inotail --- inotail.c | 464 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 464 insertions(+) create mode 100644 inotail.c (limited to 'inotail.c') diff --git a/inotail.c b/inotail.c new file mode 100644 index 0000000..7b58477 --- /dev/null +++ b/inotail.c @@ -0,0 +1,464 @@ +/* + * inotail.c + * A fast implementation of tail which uses the inotify API present in + * recent versions of the Linux kernel. + * + * Copyright (C) 2005-2006, Tobias Klauser + * + * The idea was taken from turbotail. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation; either version 2, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "inotify.h" +#include "inotify-syscalls.h" + +#include "inotail.h" + +#define PROGRAM_NAME "inotail" +#define BUFFER_SIZE 4096 + +/* (ino)tail works on these file types */ +#define IS_TAILABLE(mode) \ + (S_ISREG(mode) || S_ISFIFO(mode) || S_ISSOCK(mode) || S_ISCHR(mode)) + +/* Print header with filename before tailing the file? */ +static char verbose = 0; + +/* Tailing relative to begin or end of file */ +static char from_begin = 0; + +/* Command line options */ +static const struct option long_opts[] = { + {"bytes", required_argument, NULL, 'c'}, + {"follow", optional_argument, NULL, 'f'}, + {"lines", required_argument, NULL, 'n'}, + {"verbose", no_argument, NULL, 'v'}, + {"help", no_argument, NULL, 'h'}, + {"version", no_argument, NULL, 'V'}, + {NULL, 0, NULL, 0} +}; + +static void usage(const int status) +{ + fprintf(stderr, "Usage: %s [OPTION]... [FILE]...\n\n" + " -c N, --bytes=N output the last N bytes\n" + " -f, --follow output as the file grows\n" + " -n N, --lines=N output the last N lines (default: %d)\n" + " -v, --verbose print headers with file names\n" + " -h, --help show this help and exit\n" + " -V, --version show version and exit\n\n" + "If the first character of N (the number of bytes or lines) is a `+',\n" + "begin printing with the Nth item from the start of each file, otherwise,\n" + "print the last N items in the file.\n", PROGRAM_NAME, DEFAULT_N_LINES); + + exit(status); +} + +static void setup_file(struct file_struct *f) +{ + f->fd = -1; + f->st_size = 0; + f->ignore = 0; + f->i_watch = -1; +} + +static inline char *pretty_name(char *filename) +{ + return (strncmp(filename, "-", 1) == 0) ? "standard input" : filename; +} + +static void write_header(char *filename) +{ + static unsigned short first_file = 1; + + fprintf(stdout, "%s==> %s <==\n", (first_file ? "" : "\n"), pretty_name(filename)); + first_file = 0; +} + +static off_t lines_to_offset_from_end(struct file_struct *f, unsigned int n_lines) +{ + char buf[BUFFER_SIZE]; + off_t offset = f->st_size; + + n_lines++; /* We also count the last \n */ + memset(&buf, 0, sizeof(buf)); + + while (offset > 0 && n_lines > 0) { + int i, rc; + int block_size = BUFFER_SIZE; /* Size of the current block we're reading */ + + if (offset < BUFFER_SIZE) + block_size = offset; + + /* Start of current block */ + offset -= block_size; + + lseek(f->fd, offset, SEEK_SET); + + rc = read(f->fd, &buf, block_size); + if (rc < 0) { + fprintf(stderr, "Error: Could not read from file '%s' (%s)\n", f->name, strerror(errno)); + return -1; + } + + for (i = block_size; i > 0; i--) { + if (buf[i] == '\n') { + n_lines--; + + if (n_lines == 0) { + offset += i + 1; /* We don't want the first \n */ + break; + } + } + } + } + + return offset; + +} + +static off_t lines_to_offset_from_begin(struct file_struct *f, unsigned int n_lines) +{ + char buf[BUFFER_SIZE]; + off_t offset = 0; + + /* tail everything for 'inotail -n +0' */ + if (n_lines == 0) + return 0; + + n_lines--; + memset(&buf, 0, sizeof(buf)); + + while (offset <= f->st_size && n_lines > 0) { + int i, rc; + int block_size = BUFFER_SIZE; + + lseek(f->fd, offset, SEEK_SET); + + rc = read(f->fd, &buf, block_size); + if (rc < 0) { + fprintf(stderr, "Error: Could not read from file '%s' (%s)\n", f->name, strerror(errno)); + return -1; + } + + for (i = 0; i < block_size; i++) { + if (buf[i] == '\n') { + n_lines--; + if (n_lines == 0) { + offset += i + 1; + return offset; + } + } + } + + offset += block_size; + } + + return offset; +} + +static off_t lines_to_offset(struct file_struct *f, unsigned int n_lines) +{ + if (from_begin) + return lines_to_offset_from_begin(f, n_lines); + else + return lines_to_offset_from_end(f, n_lines); +} + +static inline off_t bytes_to_offset(struct file_struct *f, unsigned int n_bytes) +{ + /* tail everything for 'inotail -c +0' */ + if (from_begin && n_bytes == 0) + return 0; + else + return (from_begin ? ((off_t) n_bytes - 1) : (f->st_size - (off_t) n_bytes)); +} + +static int tail_pipe(struct file_struct *f) +{ + int rc; + char buf[BUFFER_SIZE]; + + if (verbose) + write_header(f->name); + + /* We will just tail everything here */ + while ((rc = read(f->fd, &buf, BUFFER_SIZE)) > 0) + write(STDOUT_FILENO, buf, (size_t) rc); + + return rc; +} + +static int tail_file(struct file_struct *f, unsigned int n_units, char mode) +{ + int ret = -1; + ssize_t bytes_read = 0; + off_t offset = 0; + char buf[BUFFER_SIZE]; + struct stat finfo; + + if (strncmp(f->name, "-", 1) == 0) + f->fd = STDIN_FILENO; + else { + f->fd = open(f->name, O_RDONLY); + if (f->fd < 0) { + fprintf(stderr, "Error: Could not open file '%s' (%s)\n", f->name, strerror(errno)); + return -1; + } + } + + if (fstat(f->fd, &finfo) < 0) { + fprintf(stderr, "Error: Could not stat file '%s' (%s)\n", f->name, strerror(errno)); + goto out; + } + + if (!IS_TAILABLE(finfo.st_mode)) { + fprintf(stderr, "Error: '%s' of unsupported file type\n", f->name); + goto out; + } + + /* We cannot seek on these */ + if (S_ISFIFO(finfo.st_mode) || S_ISSOCK(finfo.st_mode) || f->fd == STDIN_FILENO) + return tail_pipe(f); + + f->st_size = finfo.st_size; + + if (mode == M_LINES) + offset = lines_to_offset(f, n_units); + else + offset = bytes_to_offset(f, n_units); + + /* We only get negative offsets on errors */ + if (offset < 0) + goto out; + + if (verbose) + write_header(f->name); + + lseek(f->fd, offset, SEEK_SET); + + while ((bytes_read = read(f->fd, &buf, BUFFER_SIZE)) > 0) + write(STDOUT_FILENO, buf, (size_t) bytes_read); + + ret = 0; +out: + if (close(f->fd) < 0) { + fprintf(stderr, "Error: Could not close file '%s' (%s)\n", f->name, strerror(errno)); + ret = -1; + } + + return ret; +} + +static int handle_inotify_event(struct inotify_event *inev, struct file_struct *fil, int n_ignored) +{ + off_t offset; + + if (inev->mask & IN_MODIFY) { + int rc; + char fbuf[BUFFER_SIZE]; + struct stat finfo; + + fil->fd = open(fil->name, O_RDONLY); + if (fil->fd < 0) { + fprintf(stderr, "Error: Could not open file '%s' (%s)\n", fil->name, strerror(errno)); + goto ignore; + } + + if (fstat(fil->fd, &finfo) < 0) { + fprintf(stderr, "Error: Could not stat file '%s' (%s)\n", fil->name, strerror(errno)); + close(fil->fd); + goto ignore; + } + + offset = fil->st_size; + fil->st_size = finfo.st_size; + + if (verbose) + write_header(fil->name); + + memset(&fbuf, 0, sizeof(fbuf)); + + lseek(fil->fd, offset, SEEK_SET); + while ((rc = read(fil->fd, &fbuf, BUFFER_SIZE)) != 0) + write(STDOUT_FILENO, fbuf, rc); + + close(fil->fd); + + return n_ignored; + } else if (inev->mask & IN_DELETE_SELF) { + fprintf(stderr, "File '%s' deleted.\n", fil->name); + } else if (inev->mask & IN_MOVE_SELF) { + /* TODO: Try to follow file/fd */ + fprintf(stderr, "File '%s' moved.\n", fil->name); + } else if (inev->mask & IN_UNMOUNT) { + fprintf(stderr, "Device containing file '%s' unmounted.\n", fil->name); + } + +ignore: + fil->ignore = 1; + n_ignored++; + + return n_ignored; +} + +static int watch_files(struct file_struct *f, int n_files) +{ + int ifd, i, n_ignored = 0; + unsigned buflen = 2 * n_files * sizeof(struct inotify_event); + struct inotify_event *inev; + char *buf; + + ifd = inotify_init(); + if (ifd < 0) { + fprintf(stderr, "Error: Inotify is not supported by the kernel you're currently running.\n"); + exit(EXIT_FAILURE); + } + + for (i = 0; i < n_files; i++) { + if (!f[i].ignore) + f[i].i_watch = inotify_add_watch(ifd, f[i].name, + IN_MODIFY|IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT); + else + n_ignored++; + } + + buf = malloc(buflen); + memset(buf, 0, buflen); + + while (n_ignored < n_files) { + int len; + + len = read(ifd, buf, buflen); + inev = (struct inotify_event *) buf; + + while (len > 0) { + struct file_struct *fil = NULL; + + /* Which file has produced the event? */ + for (i = 0; i < n_files; i++) { + if (!f[i].ignore && f[i].fd >= 0 && f[i].i_watch == inev->wd) { + fil = &f[i]; + break; + } + } + + if (unlikely(!fil)) + break; + + n_ignored = handle_inotify_event(inev, fil, n_ignored); + len -= sizeof(struct inotify_event) + inev->len; + inev = (struct inotify_event *) ((char *) inev + sizeof(struct inotify_event) + inev->len); + } + } + + free(buf); + close(ifd); + + return n_ignored; +} + +int main(int argc, char **argv) +{ + int i, c, ret = 0; + int n_files = 0; + int n_units = DEFAULT_N_LINES; + char forever = 0, mode = M_LINES; + char **filenames; + struct file_struct *files; + + while ((c = getopt_long(argc, argv, "c:n:fvVh", long_opts, NULL)) != -1) { + switch (c) { + case 'c': + mode = M_BYTES; + /* fall through */ + case 'n': + if (*optarg == '+') + from_begin = 1; + else if (*optarg == '-') + optarg++; + n_units = strtoul(optarg, NULL, 0); + if (n_units < 0) + n_units = 0; + break; + case 'f': + forever = 1; + break; + case 'v': + verbose = 1; + break; + case 'V': + fprintf(stderr, "%s %s\n", PROGRAM_NAME, VERSION); + return 0; + case 'h': + usage(EXIT_SUCCESS); + default: + usage(EXIT_FAILURE); + } + } + + /* Do we have some files to read from? */ + if (optind < argc) { + n_files = argc - optind; + filenames = argv + optind; + } else { + /* It must be stdin then */ + static char *dummy_stdin = "-"; + n_files++; + filenames = &dummy_stdin; + + /* POSIX says that -f is ignored if no file operand is + specified and standard input is a pipe. */ + if (forever) { + struct stat finfo; + if (fstat(STDIN_FILENO, &finfo) == 0 + && (S_ISFIFO(finfo.st_mode) || S_ISSOCK(finfo.st_mode))) + forever = 0; + } + } + + files = malloc(n_files * sizeof(struct file_struct)); + if (!files) { + fprintf(stderr, "Error: Not enough memory (%s)\n", strerror(errno)); + exit(EXIT_FAILURE); + } + + for (i = 0; i < n_files; i++) { + files[i].name = filenames[i]; + setup_file(&files[i]); + ret = tail_file(&files[i], n_units, mode); + if (ret < 0) + files[i].ignore = 1; + } + + if (forever) + ret = watch_files(files, n_files); + + free(files); + + return ret; +} -- cgit v1.2.3-54-g00ecf