/*
 * tail.c - copy the last part of a file
 *
 * Version: 2008-1.01
 * Build:   c89 -o tail tail.c
 * Source:  <http://pdcore.sourceforge.net/>
 * Spec:    <http://www.opengroup.org/onlinepubs/9699919799/utilities/tail.html>
 *
 * This is free and unencumbered software released into the public domain,
 * provided "as is", without warranty of any kind, express or implied. See the
 * file UNLICENSE and the website <http://unlicense.org> for further details.
 */


#define _POSIX_SOURCE

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#define USAGE     "usage: tail [-f] [-c number] [-n number] [file]\n"
#define NOMALLOC  "Unable to allocate memory for read buffer"
#define NOFOLLOW  "tail: Option [-f] ignored; can only follow regular files and FIFOs\n"
#define BADBYTES  "Option [-c] requires non-zero byte offset"
#define BADLINES  "Option [-n] requires integer line offset"
#define CNMUTEXCL "Options [-c] and [-n] are mutually exclusive"
#define FVANISH   "Followed file has vanished"
#define FSHRUNK   "Followed file has shrunk"
#define SYSERR    1
#define APPERR    0

static int isdecint(char *s);
static void tailfile(int fd, char *fn);
static void tailbyteoffset(int fd, char *fn, int isregfile, ssize_t len);
static void taillineoffset(int fd, char *fn, int isregfile, ssize_t len);
static void copytoeof(int fd, char *fn);
static void fatal(int errtype, char *s);

static unsigned char* buf;
static ssize_t bufsize, offset;
static int optf, optc, optn;


int main(int argc, char **argv)
{
    extern int opterr, optind;
    extern char *optarg;
    int c, fd;
    char *fn;

    setlocale(LC_ALL, "");
    opterr = 0;

    /*
     * try to get a buffer _twice_ the size mandated by the standard as in
     * later processing we may be paging through the file in _half_ buffer
     * increments; this way we guarentee POSIX buffer size conformance
     */
    bufsize = sysconf(_SC_LINE_MAX) * 20;   /* POSIX says [{LINE_MAX)*10] */
    bufsize = bufsize < 4096 ? 4096 : bufsize;

    if ((buf = malloc(bufsize)) == NULL)
        fatal(APPERR, NOMALLOC);

    while ((c = getopt(argc, argv, "fc:n:")) != -1)
        switch (c)
        {
        case 'f':   /* follow file */
            optf = 1;
            break;

        case 'c':   /* offset in bytes */
            optc = 1;
            offset = 0;
            if (*optarg && isdecint(optarg))
            {
                offset = atol(optarg);
                offset = isdigit(*optarg) ? -offset : offset;
            }

            if (offset == 0)
                fatal(APPERR, BADBYTES);
            else
                break;

        case 'n':   /* offset in lines */
            optn = 1;
            if (*optarg && isdecint(optarg))
            {
                offset = atol(optarg);
                offset = isdigit(*optarg) ? -offset : offset;

                /* the standard says [-n 0] is OK, but [-n +0] isn't &_& */
                if (offset != 0 || (offset == 0 && *optarg != '+'))
                    break;
            }
            fatal(APPERR, BADLINES);

        default:
            fprintf(stderr, USAGE);
            exit(1);
        }

    if (! optc && ! optn)   /* if none, set the default options */
    {
        optn = 1;
        offset = -10;
    }

    if (optc && optn)
        fatal(APPERR, CNMUTEXCL);

    if (optind >= argc)
        tailfile(STDIN_FILENO, "stdin");
    else
    {
        fn = argv[optind++];

        if (strcmp(fn, "-") == 0)
            tailfile(STDIN_FILENO, "stdin");
        else
            if ((fd = open(fn, O_RDONLY)) == -1)
                fatal(SYSERR, fn);
            else
            {
                tailfile(fd, fn);
                if (close(fd) == -1)
                    fatal(SYSERR, fn);
            }
    }

    return(0);
}


int isdecint(char *s)
{
    int badch = 0;
    char *c = s;

    if (! (isdigit(*c) || *c == '+' || *c == '-'))
        badch = 1;
    else
        for (c++; *c; c++)
            if (! isdigit(*c))
                badch = 1;

    return (! badch);
}


void tailfile(int fd, char *fn)
{
    struct stat sbuf;
    int isregfile;
    ssize_t n, len;

    if (fstat(fd, &sbuf) == -1)
        fatal(SYSERR, fn);

    if (S_ISREG(sbuf.st_mode))
    {
        isregfile = 1;
        len = sbuf.st_size;
    }
    else
        isregfile = len = 0;

    if (offset != 0)   /* [-n 0] is permitted; but no point processing that */
    {
        if (optc)
            tailbyteoffset(fd, fn, isregfile, len);
        else
            taillineoffset(fd, fn, isregfile, len);
    }

    if (optf)
    {
        if (fd == STDIN_FILENO)   /* can't follow; warn then exit no error */
        {
            fprintf(stderr, NOFOLLOW);
            exit(0);
        }

        while(1)   /* follow forever */
        {
            sleep(1);

            if (isregfile)   /* if we can, be polite to the user */
            {
                if (stat(fn, &sbuf) == -1)
                    fatal(APPERR, FVANISH);
                else if (sbuf.st_size < len)
                    fatal(APPERR, FSHRUNK);

                len = sbuf.st_size;
            }

            while ((n = read(fd, buf, bufsize)) > 0)
                if (write(STDOUT_FILENO, buf, n) != n)
                    fatal(SYSERR, "stdout");

            if (n < 0)
                fatal(SYSERR, fn);
        }
    }
}


void tailbyteoffset(int fd, char *fn, int isregfile, ssize_t len)
{
    ssize_t n, halfbuf;

    if (isregfile)   /* should be seekable, so we'll do so; it's fastest */
    {
        if (offset > 0)
            offset = (offset - 1) > len ? len : offset - 1;
        else
            offset = (len + offset) > 0 ? len + offset : 0;

        if (lseek(fd, (off_t)offset, SEEK_SET) == (off_t)-1)
            fatal(SYSERR, fn);

        copytoeof(fd, fn);
    }

    else   /* possibly non-seekable */
    {
        if (offset > 0)   /* forwards through file */
        {
            offset--;

            while(1)
            {
                if ((n = read(fd, buf, bufsize)) < 0)
                    fatal(SYSERR, fn);

                if (n == 0)
                    offset = 0;

                if (offset <= n)
                    break;
                else
                    offset -= n;
            }

            if (write(STDOUT_FILENO, buf + offset, n - offset) != n - offset)
                fatal(SYSERR, "stdout");

            copytoeof(fd, fn);
        }

        else   /* backwards through file; remember that offset is negative */
        {
            halfbuf = bufsize / 2;

            if ((n = read(fd, buf, bufsize)) < 0)
                fatal(SYSERR, fn);

            if (n < bufsize)   /* we've got the whole file */
            {
                offset = (n + offset) < 0 ? 0 : n + offset;
                len = n - offset;
            }

            else   /* we haven't got the whole file */
            {
                while(1)   /* page through the file, half a buffer at a time */
                {
                    memcpy(buf, buf + halfbuf, halfbuf);

                    if ((n = read(fd, buf + halfbuf, halfbuf)) < 0)
                        fatal(SYSERR, fn);
                    else if (n < halfbuf)
                        break;
                }

                offset = (halfbuf + n + offset) < 0 ? 0 : halfbuf + n + offset;
                len = halfbuf + n - offset;
            }

            if (write(STDOUT_FILENO, buf + offset, len) != len)
                fatal(SYSERR, "stdout");
        }
    }
}


void taillineoffset(int fd, char *fn, int isregfile, ssize_t len)
{
    ssize_t n, i, halfbuf;

    if (offset > 0)   /* forwards through file */
    {
        offset--;

        while(1)
        {
            if ((n = read(fd, buf, bufsize)) < 0)
                fatal(SYSERR, fn);

            if (n == 0)
            {
                offset = 0;
                break;
            }

            for (i = 0; i < n && offset > 0; i++)
                if (buf[i] == '\n')
                    offset--;

            if (offset == 0)
            {
                offset = i;
                break;
            }
        }

        if (write(STDOUT_FILENO, buf + offset, n - offset) != n - offset)
            fatal(SYSERR, "stdout");

        copytoeof(fd, fn);
    }

    else   /* backwards through file; remember that offset is negative */
    {
        if (isregfile && len > 0)   /* should be seekable, so we'll do so */
        {
            n = (len - bufsize) < 0 ? 0 : len - bufsize;

            if (lseek(fd, (off_t)n, SEEK_SET) == (off_t)-1)
                fatal(SYSERR, fn);

            if ((n = read(fd, buf, bufsize)) < 0)
                fatal(SYSERR, fn);

            if (buf[n-1] == '\n')
                offset--;

            for (i = n - 1; i >= 0 && offset < 0; i--)
                if (buf[i] == '\n')
                    offset++;

            if (offset == 0)
                offset = i + 2;
            else
                offset = 0;

            len = n - offset;

            if (write(STDOUT_FILENO, buf + offset, len) != len)
                fatal(SYSERR, "stdout");
        }

        else
        {
            halfbuf = bufsize / 2;

            if ((n = read(fd, buf, bufsize)) < 0)
                fatal(SYSERR, fn);

            if (n < bufsize)   /* we've got the whole file */
            {
                if (n == 0)
                    offset = 0;
                else
                {
                    if (buf[n-1] == '\n')
                        offset--;

                    for (i = n - 1; i >= 0 && offset < 0; i--)
                        if (buf[i] == '\n')
                            offset++;

                    if (offset == 0)
                        offset = i + 2;
                    else
                        offset = 0;
                }

                len = n - offset;
            }

            else   /* we haven't got the whole file */
            {
                while(1)   /* page through the file, half a buffer at a time */
                {
                    memcpy(buf, buf + halfbuf, halfbuf);

                    if ((n = read(fd, buf + halfbuf, halfbuf)) < 0)
                        fatal(SYSERR, fn);
                    else if (n < halfbuf)
                        break;
                }

                if (buf[halfbuf+n-1] == '\n')
                    offset--;

                for (i = halfbuf + n - 1; i >= 0 && offset < 0; i--)
                    if (buf[i] == '\n')
                        offset++;

                if (offset == 0)
                    offset = i + 2;
                else
                    offset = 0;

                len = halfbuf + n - offset;
            }

            if (write(STDOUT_FILENO, buf + offset, len) != len)
                fatal(SYSERR, "stdout");
        }
    }
}


void copytoeof(int fd, char *fn)
{
    ssize_t n;

    while ((n = read(fd, buf, bufsize)) > 0)
        if (write(STDOUT_FILENO, buf, n) != n)
            fatal(SYSERR, "stdout");

    if (n < 0)
        fatal(SYSERR, fn);
}


void fatal(int errtype, char *s)
{
    if (errtype == SYSERR)
        fprintf(stderr, "tail: %s: %s\n", s, strerror(errno));
    else
        fprintf(stderr, "tail: %s\n", s);

    exit(1);
}