No empty .Rs/.Re

[netbsd-mini2440.git] / usr.bin / newsyslog / newsyslog.c

/*      $NetBSD: newsyslog.c,v 1.58 2009/06/20 19:34:19 christos Exp $  */

/*
 * Copyright (c) 1999, 2000 Andrew Doran <ad@NetBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

/*
 * This file contains changes from the Open Software Foundation.
 */

/*
 * Copyright 1988, 1989 by the Massachusetts Institute of Technology
 * 
 * Permission to use, copy, modify, and distribute this software
 * and its documentation for any purpose and without fee is
 * hereby granted, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation,
 * and that the names of M.I.T. and the M.I.T. S.I.P.B. not be
 * used in advertising or publicity pertaining to distribution
 * of the software without specific, written prior permission.
 * M.I.T. and the M.I.T. S.I.P.B. make no representations about
 * the suitability of this software for any purpose.  It is
 * provided "as is" without express or implied warranty.
 * 
 */

/*
 * newsyslog(8) - a program to roll over log files provided that specified
 * critera are met, optionally preserving a number of historical log files.
 */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: newsyslog.c,v 1.58 2009/06/20 19:34:19 christos Exp $");
#endif /* not lint */

#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/wait.h>

#include <ctype.h>
#include <fcntl.h>
#include <grp.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <err.h>
#include <paths.h>

#define PRHDRINFO(x)    \
    (/*LINTED*/(void)(verbose ? printf x : 0))
#define PRINFO(x)       \
    (/*LINTED*/(void)(verbose ? printf("  ") + printf x : 0))

#ifndef __arraycount
#define __arraycount(a) (sizeof(a) / sizeof(a[0]))
#endif

#define CE_BINARY       0x02    /* Logfile is a binary file/non-syslog */
#define CE_NOSIGNAL     0x04    /* Don't send a signal when trimmed */
#define CE_CREATE       0x08    /* Create log file if none exists */
#define CE_PLAIN0       0x10    /* Do not compress zero'th history file */
#define CE_SYSLPROTOCOL 0x20    /* log in syslog-protocol format,
                                   not configurable but detected at runtime */

struct conf_entry {
        uid_t   uid;                    /* Owner of log */
        gid_t   gid;                    /* Group of log */
        mode_t  mode;                   /* File permissions */
        int     numhist;                /* Number of historical logs to keep */
        size_t  maxsize;                /* Maximum log size */
        int     maxage;                 /* Hours between log trimming */
        time_t  trimat;                 /* Specific trim time */
        int     flags;                  /* Flags (CE_*) */
        int     signum;                 /* Signal to send */
        char    pidfile[MAXPATHLEN];    /* File containing PID to signal */
        char    logfile[MAXPATHLEN];    /* Path to log file */
};

struct compressor {
        const char *path;
        const char *args;
        const char *suffix;
        const char *flag; /* newsyslog.conf flag */
};

static struct compressor compress[] =
{
        {NULL, "", "", ""}, /* 0th compressor is "no compression" */
        {"/usr/bin/gzip", "-f", ".gz", "Z"},
        {"/usr/bin/bzip2", "-9f", ".bz2", "J"},
};

#define _PATH_NEWSYSLOGCONF     "/etc/newsyslog.conf"
#define _PATH_SYSLOGDPID        _PATH_VARRUN"syslogd.pid"

static int      verbose;                        /* Be verbose */
static int      noaction;                       /* Take no action */
static int      nosignal;                       /* Do not send signals */
static char     hostname[MAXHOSTNAMELEN + 1];   /* Hostname, with domain */
static uid_t    myeuid;                         /* EUID we are running with */
static int      ziptype;                        /* compression type, if any */

static int      getsig(const char *);
static int      isnumber(const char *);
static int      parse_cfgline(struct conf_entry *, FILE *, size_t *);
static time_t   parse_iso8601(char *);
static time_t   parse_dwm(char *);
static int      parse_userspec(const char *, struct passwd **, struct group **);
static pid_t    readpidfile(const char *);
static void     usage(void) __dead;

static void     log_compress(struct conf_entry *, const char *);
static void     log_create(struct conf_entry *);
static void     log_examine(struct conf_entry *, int);
static void     log_trim(struct conf_entry *);
static void     log_trimmed(struct conf_entry *);
static void     log_get_format(struct conf_entry *);

/*
 * Program entry point.
 */
int
main(int argc, char **argv)
{
        struct conf_entry log;
        FILE *fd;
        const char *cfile;
        int c, needroot, i, force;
        size_t lineno;

        force = 0;
        needroot = 1;
        ziptype = 0;
        cfile = _PATH_NEWSYSLOGCONF;

        (void)gethostname(hostname, sizeof(hostname));
        hostname[sizeof(hostname) - 1] = '\0';

        /* Parse command line options. */
        while ((c = getopt(argc, argv, "f:nrsvF")) != -1) {
                switch (c) {
                case 'f':
                        cfile = optarg;
                        break;
                case 'n':
                        noaction = 1;
                        verbose = 1;
                        break;
                case 'r':
                        needroot = 0;
                        break;
                case 's':
                        nosignal = 1;
                        break;
                case 'v':
                        verbose = 1;
                        break;
                case 'F':
                        force = 1;
                        break;
                default:
                        usage();
                        /* NOTREACHED */
                }
        }

        myeuid = geteuid();
        if (needroot && myeuid != 0)
                errx(EXIT_FAILURE, "must be run as root");

        argc -= optind;
        argv += optind;
        
        if (strcmp(cfile, "-") == 0)
                fd = stdin;
        else if ((fd = fopen(cfile, "rt")) == NULL)
                err(EXIT_FAILURE, "%s", cfile);
        
        for (lineno = 0; !parse_cfgline(&log, fd, &lineno);) {
                /* 
                 * If specific log files were specified, touch only 
                 * those. 
                 */
                if (argc != 0) {
                        for (i = 0; i < argc; i++)
                                if (strcmp(log.logfile, argv[i]) == 0)
                                        break;
                        if (i == argc)
                                continue;
                }
                log_examine(&log, force);
        }
        
        if (fd != stdin)
                (void)fclose(fd);

        exit(EXIT_SUCCESS);
        /* NOTREACHED */
}

/*
 * Parse a single line from the configuration file.
 */
static int
parse_cfgline(struct conf_entry *log, FILE *fd, size_t *_lineno)
{
        char *line, *q, **ap, *argv[10];
        struct passwd *pw;
        struct group *gr;
        int nf, lineno, i, rv;

        rv = -1;
        line = NULL;
        ziptype = 0;

        /* Place the white-space separated fields into an array. */
        do {
                if (line != NULL)
                        free(line);
                if ((line = fparseln(fd, NULL, _lineno, NULL, 0)) == NULL)
                        return (rv);
                lineno = (int)*_lineno;

                for (ap = argv, nf = 0; (*ap = strsep(&line, " \t")) != NULL;)
                        if (**ap != '\0') {
                                if (++nf == sizeof(argv) / sizeof(argv[0])) {
                                        warnx("config line %d: "
                                            "too many fields", lineno);
                                        goto bad;
                                }
                                ap++;
                        }
        } while (nf == 0);
                
        if (nf < 6)
                errx(EXIT_FAILURE, "config line %d: too few fields", lineno);
        
        (void)memset(log, 0, sizeof(*log));
        
        /* logfile_name */
        ap = argv;
        (void)strlcpy(log->logfile, *ap++, sizeof(log->logfile));
        if (log->logfile[0] != '/')
                errx(EXIT_FAILURE, 
                    "config line %d: logfile must have a full path", lineno);

        /* owner:group */
        if (strchr(*ap, ':') != NULL || strchr(*ap, '.') != NULL) {
                if (parse_userspec(*ap++, &pw, &gr)) {
                        warnx("config line %d: unknown user/group", lineno);
                        goto bad;
                }
                
                /*
                 * We may only change the file's owner as non-root.
                 */
                if (myeuid != 0) {
                        if (pw->pw_uid != myeuid)
                                errx(EXIT_FAILURE, "config line %d: user:group "
                                    "as non-root must match current user", 
                                    lineno);
                        log->uid = (uid_t)-1;
                } else
                        log->uid = pw->pw_uid;
                log->gid = gr->gr_gid;
                if (nf < 7)
                        errx(EXIT_FAILURE, "config line %d: too few fields",
                            lineno);
        } else if (myeuid != 0) {
                log->uid = (uid_t)-1;
                log->gid = getegid();
        }

        /* mode */
        if (sscanf(*ap++, "%o", &i) != 1) {
                warnx("config line %d: bad permissions", lineno);
                goto bad;
        }
        log->mode = (mode_t)i;

        /* count */
        if (sscanf(*ap++, "%d", &log->numhist) != 1) {
                warnx("config line %d: bad log count", lineno);
                goto bad;
        }

        /* size */
        if (**ap == '*')
                log->maxsize = (size_t)-1;
        else {
                log->maxsize = (int)strtol(*ap, &q, 0);
                if (*q != '\0') {
                        warnx("config line %d: bad log size", lineno);
                        goto bad;
                }
        }
        ap++;

        /* when */
        log->maxage = -1;
        log->trimat = (time_t)-1;
        q = *ap++;
        
        if (strcmp(q, "*") != 0) {
                if (isdigit((unsigned char)*q))
                        log->maxage = (int)strtol(q, &q, 10);
        
                /* 
                 * One class of periodic interval specification can follow a
                 * maximum age specification.  Handle it.
                 */
                if (*q == '@') {
                        log->trimat = parse_iso8601(q + 1);
                        if (log->trimat == (time_t)-1) {
                                warnx("config line %d: bad trim time", lineno);
                                goto bad;
                        }
                } else if (*q == '$') {
                        if ((log->trimat = parse_dwm(q + 1)) == (time_t)-1) {
                                warnx("config line %d: bad trim time", lineno);
                                goto bad;
                        }
                } else if (log->maxage == -1) {
                        warnx("config line %d: bad log age", lineno);
                        goto bad;
                }
        }
        
        /* flags */
        log->flags = (nosignal ? CE_NOSIGNAL : 0);

        for (q = *ap++; q != NULL && *q != '\0'; q++) {
                char qq = toupper((unsigned char)*q);
                switch (qq) {
                case 'B':
                        log->flags |= CE_BINARY;
                        break;
                case 'C':
                        log->flags |= CE_CREATE;
                        break;
                case 'N':
                        log->flags |= CE_NOSIGNAL;
                        break;
                case 'P':
                        log->flags |= CE_PLAIN0;
                        break;
                case 'J': case 'Z':
                        for (ziptype = __arraycount(compress); --ziptype; ) {
                                if (*compress[ziptype].flag == qq)
                                    break;
                        }
                        break;
                case '-':
                        break;
                default:
                        warnx("config line %d: bad flags", lineno);
                        goto bad;
                }
        }

        /* path_to_pidfile */
        if (*ap != NULL && **ap == '/')
                (void)strlcpy(log->pidfile, *ap++, sizeof(log->pidfile));
        else
                log->pidfile[0] = '\0';

        /* sigtype */
        if (*ap != NULL) {
                if ((log->signum = getsig(*ap++)) < 0) {
                        warnx("config line %d: bad signal type", lineno);
                        goto bad;
                }
        } else
                log->signum = SIGHUP;

        rv = 0;

bad:
        free(line);
        return (rv);
}

/* 
 * Examine a log file.  If the trim conditions are met, call log_trim() to
 * trim the log file.
 */
static void
log_examine(struct conf_entry *log, int force)
{
        struct stat sb;
        size_t size;
        int age, trim;
        unsigned int j;
        char tmp[MAXPATHLEN];
        const char *reason;
        time_t now;

        now = time(NULL);

        PRHDRINFO(("\n%s <%d%s>: ", log->logfile, log->numhist, 
            compress[ziptype].flag));

        /*
         * stat() the logfile.  If it doesn't exist and the `c' flag has
         * been specified, create it.  If it doesn't exist and the `c' flag
         * hasn't been specified, give up.
         */
        if (stat(log->logfile, &sb) < 0) {
                if (errno == ENOENT && (log->flags & CE_CREATE) != 0) {
                        PRHDRINFO(("creating; "));
                        if (!noaction)
                                log_create(log);
                        else {
                                PRHDRINFO(("can't proceed with `-n'\n"));
                                return;
                        }
                        if (stat(log->logfile, &sb))
                                err(EXIT_FAILURE, "%s", log->logfile);
                } else if (errno == ENOENT) {
                        PRHDRINFO(("does not exist --> skip log\n"));
                        return;
                } else if (errno != 0)
                        err(EXIT_FAILURE, "%s", log->logfile);
        }

        if (!S_ISREG(sb.st_mode)) {
                PRHDRINFO(("not a regular file --> skip log\n"));
                return;
        }

        /* Size of the log file in kB. */
        size = ((size_t)sb.st_blocks * S_BLKSIZE) >> 10;

        /* 
         * Get the age (expressed in hours) of the current log file with
         * respect to the newest historical log file.
         */
        age = -1;
        for (j = 0; j < __arraycount(compress); j++) {
                (void)strlcpy(tmp, log->logfile, sizeof(tmp));
                (void)strlcat(tmp, ".0", sizeof(tmp));
                (void)strlcat(tmp, compress[j].suffix, sizeof(tmp));
                if (!stat(tmp, &sb)) {
                        age = (int)(now - sb.st_mtime + 1800) / 3600;
                        break;
                }
        }

        /*
         * Examine the set of given trim conditions and if any one is met,
         * trim the log.
         *
         * Note: if `maxage' or `trimat' is used as a trim condition, we
         * need at least one historical log file to determine the `age' of
         * the active log file.  WRT `trimat', we will trim up to one hour
         * after the specific trim time has passed - we need to know if
         * we've trimmed to meet that condition with a previous invocation
         * of newsyslog(8).
         */
        if (log->maxage >= 0 && (age >= log->maxage || age < 0)) {
                trim = 1;
                reason = "log age > interval";
        } else if (size >= log->maxsize) {
                trim = 1;
                reason = "log size > size";
        } else if (log->trimat != (time_t)-1 && now >= log->trimat &&
                   (age == -1 || age > 1) &&
                   difftime(now, log->trimat) < 60 * 60) {
                trim = 1;
                reason = "specific trim time";
        } else {
                trim = force;
                reason = "trim forced";
        }

        if (trim) {
                PRHDRINFO(("--> trim log (%s)\n", reason));
                log_trim(log);
        } else
                PRHDRINFO(("--> skip log (trim conditions not met)\n"));
}

/*
 * Trim the specified log file.
 */
static void
log_trim(struct conf_entry *log)
{
        char file1[MAXPATHLEN], file2[MAXPATHLEN];
        int i, j, k;
        struct stat st;
        pid_t pid;

        if (log->numhist != 0) {
                /* Remove oldest historical log. */
                for (j = 0; j < (int)__arraycount(compress); j++) {
                        (void)snprintf(file1, sizeof(file1), "%s.%d",
                            log->logfile, log->numhist - 1);
                        (void)strlcat(file1, compress[j].suffix,
                            sizeof(file1));
                        PRINFO(("rm -f %s\n", file1));
                        if (!noaction)
                                (void)unlink(file1);
                }
        }

        /*
         * If a historical log file isn't compressed, and 'z' has been
         * specified, compress it.  (This is convenient, but is also needed
         * if 'p' has been specified.)  It should be noted that gzip(1)
         * preserves file ownership and file mode.
         */
        if (ziptype) {
                for (i = 0; i < log->numhist; i++) {
                        snprintf(file1, sizeof(file1), "%s.%d", log->logfile, i);
                        if (lstat(file1, &st) != 0)
                                continue;
                        snprintf(file2, sizeof(file2), "%s%s", file1,
                            compress[ziptype].suffix);
                        if (lstat(file2, &st) == 0)
                                continue;
                        log_compress(log, file1);
                }
        }

        /* Move down log files. */
        for (i = log->numhist - 1; i > 0; i--) {
                for (j = 0; j < (int)__arraycount(compress); j++) {
                        snprintf(file1, sizeof(file1), "%s.%d%s", log->logfile,
                            i - 1, compress[j].suffix);
                        snprintf(file2, sizeof(file2), "%s.%d%s", log->logfile,
                            i, compress[j].suffix);
                        k = lstat(file1, &st);
                        if (!k) break;
                }
                if (k) continue;

                PRINFO(("mv %s %s\n", file1, file2));
                if (!noaction)
                        if (rename(file1, file2))
                                err(EXIT_FAILURE, "%s", file1);
                PRINFO(("chmod %o %s\n", log->mode, file2));
                if (!noaction)
                        if (chmod(file2, log->mode))
                                err(EXIT_FAILURE, "%s", file2); 
                PRINFO(("chown %d:%d %s\n", log->uid, log->gid,
                    file2));
                if (!noaction)
                        if (chown(file2, log->uid, log->gid))
                                err(EXIT_FAILURE, "%s", file2);
        }

        log_get_format(log);
        log_trimmed(log);

        /* Create the historical log file if we're maintaining history. */
        if (log->numhist == 0) {
                PRINFO(("rm -f %s\n", log->logfile));
                if (!noaction)
                        if (unlink(log->logfile))
                                err(EXIT_FAILURE, "%s", log->logfile);
        } else {
                (void)snprintf(file1, sizeof(file1), "%s.0", log->logfile);
                PRINFO(("mv %s %s\n", log->logfile, file1));
                if (!noaction)
                        if (rename(log->logfile, file1))
                                err(EXIT_FAILURE, "%s", log->logfile);
        }

        PRINFO(("(create new log)\n"));
        log_create(log);
        log_trimmed(log);

        /* Set the correct permissions on the log. */
        PRINFO(("chmod %o %s\n", log->mode, log->logfile));
        if (!noaction)
                if (chmod(log->logfile, log->mode))
                        err(EXIT_FAILURE, "%s", log->logfile);

        /* Do we need to signal a daemon? */
        if ((log->flags & CE_NOSIGNAL) == 0) {
                if (log->pidfile[0] != '\0')
                        pid = readpidfile(log->pidfile);
                else
                        pid = readpidfile(_PATH_SYSLOGDPID);
                
                if (pid != (pid_t)-1) {
                        PRINFO(("kill -%s %lu\n", 
                            sys_signame[log->signum], (u_long)pid));
                        if (!noaction)
                                if (kill(pid, log->signum))
                                        warn("kill");
                }
        }

        /* If the newest historical log is to be compressed, do it here. */
        if (ziptype && !(log->flags & CE_PLAIN0) && log->numhist != 0) {
                snprintf(file1, sizeof(file1), "%s.0", log->logfile);
                if ((log->flags & CE_NOSIGNAL) == 0) {
                        PRINFO(("sleep for 10 seconds before compressing...\n"));
                        (void)sleep(10);
                }
                log_compress(log, file1);
        }
}

static void
log_get_format(struct conf_entry *log)
{
        FILE *fd;
        char *line;
        size_t linelen;

        if ((log->flags & CE_BINARY) != 0)
                return;
        PRINFO(("(read line format of %s)\n", log->logfile));
        if (noaction)
                return;

        if ((fd = fopen(log->logfile, "r")) == NULL)
                return;

        /* read 2nd line */
        line = fgetln(fd, &linelen);
        if ((line = fgetln(fd, &linelen)) != NULL
          && line[10] == 'T')
                log->flags |= CE_SYSLPROTOCOL;
        (void)fclose(fd);
}

/* 
 * Write an entry to the log file recording the fact that it was trimmed.
 */
static void
log_trimmed(struct conf_entry *log)
{
        FILE *fd;
        time_t now;
        const char *daytime;
        const char  trim_message[] = "log file turned over";

        if ((log->flags & CE_BINARY) != 0)
                return;
        PRINFO(("(append rotation notice to %s)\n", log->logfile));
        if (noaction)
                return;

        if ((fd = fopen(log->logfile, "at")) == NULL)
                err(EXIT_FAILURE, "%s", log->logfile);

        if ((log->flags & CE_SYSLPROTOCOL) == 0) {
                char shorthostname[MAXHOSTNAMELEN];
                char *p;
                
                /* Truncate domain. */
                (void)strlcpy(shorthostname, hostname, sizeof(shorthostname));
                if ((p = strchr(shorthostname, '.')) != NULL)
                        *p = '\0';

                now = time(NULL);
                daytime = p = ctime(&now) + 4;
                p[15] = '\0';
        
                (void)fprintf(fd, "%s %s newsyslog[%lu]: %s\n",
                    daytime, hostname, (u_long)getpid(), trim_message);
        } else {
                struct tm *tmnow;
                struct timeval tv;
                char timestamp[35];
                unsigned i, j;
                
                if (gettimeofday(&tv, NULL) == -1) {
                        daytime = "-";
                } else {
                        tzset();
                        now = (time_t) tv.tv_sec;
                        tmnow = localtime(&now);
        
                        i = strftime(timestamp, sizeof(timestamp),
                                "%FT%T", tmnow);
                        i += snprintf(timestamp+i, sizeof(timestamp)-i,
                                ".%06ld", (long)tv.tv_usec);
                        i += j = strftime(timestamp+i, sizeof(timestamp)-i-1,
                                "%z", tmnow);
                        /* strftime gives eg. "+0200", but we need "+02:00" */
                        if (j == 5) {
                                timestamp[i+1] = timestamp[i];
                                timestamp[i]   = timestamp[i-1];
                                timestamp[i-1] = timestamp[i-2];
                                timestamp[i-2] = ':';
                                i += 1;
                        }
                        daytime = timestamp;
                }
                (void)fprintf(fd, "%s %s newsyslog %lu - - %s\n",
                        daytime, hostname, (u_long)getpid(), trim_message);
                
        }
        (void)fclose(fd);
}

/*
 * Create a new log file.
 */
static void
log_create(struct conf_entry *log)
{
        int fd;

        if (noaction)
                return;

        if ((fd = creat(log->logfile, log->mode)) < 0)
                err(EXIT_FAILURE, "%s", log->logfile);
        if (fchown(fd, log->uid, log->gid) < 0)
                err(EXIT_FAILURE, "%s", log->logfile);
        (void)close(fd);
}

/*
 * Fork off gzip(1) to compress a log file.  This routine takes an
 * additional string argument (the name of the file to compress): it is also
 * used to compress historical log files other than the newest.
 */
static void
log_compress(struct conf_entry *log, const char *fn)
{
        char tmp[MAXPATHLEN];

        PRINFO(("%s %s %s\n", compress[ziptype].path, compress[ziptype].args,
            fn));
        if (!noaction) {
                pid_t pid;
                int status;

                if ((pid = vfork()) < 0)
                        err(EXIT_FAILURE, "vfork");
                else if (pid == 0) {
                        (void)execl(compress[ziptype].path,
                           compress[ziptype].path, compress[ziptype].args, fn,
                           NULL);
                        _exit(EXIT_FAILURE);
                }
                while (waitpid(pid, &status, 0) != pid);

                if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
                        errx(EXIT_FAILURE, "%s failed", compress[ziptype].path);
        }

        (void)snprintf(tmp, sizeof(tmp), "%s%s", fn, compress[ziptype].suffix);
        PRINFO(("chown %d:%d %s\n", log->uid, log->gid, tmp));
        if (!noaction)
                if (chown(tmp, log->uid, log->gid))
                        err(EXIT_FAILURE, "%s", tmp);
}

/*
 * Display program usage information.
 */
static void
usage(void)
{

        (void)fprintf(stderr, 
            "Usage: %s [-nrsvF] [-f config-file] [file ...]\n", getprogname());
        exit(EXIT_FAILURE);
}

/*
 * Return non-zero if a string represents a decimal value.
 */
static int
isnumber(const char *string)
{

        while (isdigit((unsigned char)*string))
                string++;

        return *string == '\0';
}

/* 
 * Given a signal name, attempt to find the corresponding signal number.
 */
static int
getsig(const char *sig)
{
        char *p;
        int n;
        
        if (isnumber(sig)) {
                n = (int)strtol(sig, &p, 0);
                if (p != '\0' || n < 0 || n >= NSIG)
                        return -1;
                return n;
        }

        if (strncasecmp(sig, "SIG", 3) == 0)
                sig += 3;
        for (n = 1; n < NSIG; n++)
                if (strcasecmp(sys_signame[n], sig) == 0)
                        return n;
        return -1;
}

/*
 * Given a path to a PID file, return the PID contained within.
 */
static pid_t
readpidfile(const char *file)
{
        FILE *fd;
        char line[BUFSIZ];
        pid_t pid;

#ifdef notyet
        if (file[0] != '/')
                (void)snprintf(tmp, sizeof(tmp), "%s%s", _PATH_VARRUN, file);
        else
                (void)strlcpy(tmp, file, sizeof(tmp));
#endif

        if ((fd = fopen(file, "r")) == NULL) {
                warn("%s", file);
                return (pid_t)-1;
        }
        
        if (fgets(line, sizeof(line) - 1, fd) != NULL) {
                line[sizeof(line) - 1] = '\0';
                pid = (pid_t)strtol(line, NULL, 0);
        } else {
                warnx("unable to read %s", file);
                pid = (pid_t)-1;
        }

        (void)fclose(fd);
        return pid;
}

/*
 * Parse a user:group specification.
 *
 * XXX This is over the top for newsyslog(8).  It should be moved to libutil.
 */
int
parse_userspec(const char *name, struct passwd **pw, struct group **gr)
{
        char buf[MAXLOGNAME * 2 + 2], *group;

        (void)strlcpy(buf, name, sizeof(buf));
        *gr = NULL;

        /* 
         * Before attempting to use '.' as a separator, see if the whole 
         * string resolves as a user name.
         */
        if ((*pw = getpwnam(buf)) != NULL) {
                *gr = getgrgid((*pw)->pw_gid);
                return (0);
        }
        
        /* Split the user and group name. */
        if ((group = strchr(buf, ':')) != NULL || 
            (group = strchr(buf, '.')) != NULL)
                *group++ = '\0';

        if (isnumber(buf))
                *pw = getpwuid((uid_t)atoi(buf));
        else
                *pw = getpwnam(buf);
                
        /* 
         * Find the group.  If a group wasn't specified, use the user's
         * `natural' group.  We get to this point even if no user was found.
         * This is to allow the caller to get a better idea of what went
         * wrong, if anything.
         */
        if (group == NULL || *group == '\0') {
                if (*pw == NULL)
                        return -1;
                *gr = getgrgid((*pw)->pw_gid);
        } else if (isnumber(group))
                *gr = getgrgid((gid_t)atoi(group));
        else
                *gr = getgrnam(group);
                
        return *pw != NULL && *gr != NULL ? 0 : -1;
}

/*
 * Parse a cyclic time specification, the format is as follows:
 *
 *      [Dhh] or [Wd[Dhh]] or [Mdd[Dhh]]
 *
 * to rotate a log file cyclic at
 *
 *      - every day (D) within a specific hour (hh)     (hh = 0...23)
 *      - once a week (W) at a specific day (d)     OR  (d = 0..6, 0 = Sunday)
 *      - once a month (M) at a specific day (d)        (d = 1..31,l|L)
 *
 * We don't accept a timezone specification; missing fields are defaulted to
 * the current date but time zero.
 */
static time_t
parse_dwm(char *s)
{
        char *t;
        struct tm tm, *tmp;
        long ul;
        time_t now;
        static int mtab[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        int wmseen, dseen, nd, save;
        
        wmseen = 0;
        dseen = 0;

        now = time(NULL);
        tmp = localtime(&now);
        tm = *tmp;

        /* Set no. of days per month */
        nd = mtab[tm.tm_mon];

        if (tm.tm_mon == 1 &&
            ((tm.tm_year + 1900) % 4 == 0) &&
            ((tm.tm_year + 1900) % 100 != 0) &&
            ((tm.tm_year + 1900) % 400 == 0))
                nd++;   /* leap year, 29 days in february */
        tm.tm_hour = tm.tm_min = tm.tm_sec = 0;

        for (;;) {
                switch (*s) {
                case 'D':
                        if (dseen)
                                return (time_t)-1;
                        dseen++;
                        s++;
                        ul = strtol(s, &t, 10);
                        if (ul > 23 || ul < 0)
                                return (time_t)-1;
                        tm.tm_hour = ul;
                        break;

                case 'W':
                        if (wmseen)
                                return (time_t)-1;
                        wmseen++;
                        s++;
                        ul = strtol(s, &t, 10);
                        if (ul > 6 || ul < 0)
                                return (-1);
                        if (ul != tm.tm_wday) {
                                if (ul < tm.tm_wday) {
                                        save = 6 - tm.tm_wday;
                                        save += (ul + 1);
                                } else
                                        save = ul - tm.tm_wday;
                                tm.tm_mday += save;

                                if (tm.tm_mday > nd) {
                                        tm.tm_mon++;
                                        tm.tm_mday = tm.tm_mday - nd;
                                }
                        }
                        break;

                case 'M':
                        if (wmseen)
                                return (time_t)-1;
                        wmseen++;
                        s++;
                        if (tolower((unsigned char)*s) == 'l') {
                                tm.tm_mday = nd;
                                s++;
                                t = s;
                        } else {
                                ul = strtol(s, &t, 10);
                                if (ul < 1 || ul > 31)
                                        return (time_t)-1;

                                if (ul > nd)
                                        return (time_t)-1;
                                tm.tm_mday = ul;
                        }
                        break;

                default:
                        return (time_t)-1;
                }

                if (*t == '\0' || isspace((unsigned char)*t))
                        break;
                else
                        s = t;
        }
        
        return mktime(&tm);
}

/*
 * Parse a limited subset of ISO 8601.  The specific format is as follows:
 *
 * [CC[YY[MM[DD]]]][THH[MM[SS]]]        (where `T' is the literal letter)
 *
 * We don't accept a timezone specification; missing fields (including
 * timezone) are defaulted to the current date but time zero.
 */
static time_t
parse_iso8601(char *s)
{
        char *t;
        struct tm tm, *tmp;
        u_long ul;
        time_t now;

        now = time(NULL);
        tmp = localtime(&now);
        tm = *tmp;

        tm.tm_hour = tm.tm_min = tm.tm_sec = 0;

        ul = strtoul(s, &t, 10);
        if (*t != '\0' && *t != 'T')
                return (time_t)-1;

        /*
         * Now t points either to the end of the string (if no time was
         * provided) or to the letter `T' which separates date and time in
         * ISO 8601.  The pointer arithmetic is the same for either case.
         */
        switch (t - s) {
        case 8:
                tm.tm_year = ((ul / 1000000) - 19) * 100;
                ul = ul % 1000000;
                /* FALLTHROUGH */
        case 6:
                tm.tm_year = tm.tm_year - (tm.tm_year % 100);
                tm.tm_year += ul / 10000;
                ul = ul % 10000;
                /* FALLTHROUGH */
        case 4:
                tm.tm_mon = (ul / 100) - 1;
                ul = ul % 100;
                /* FALLTHROUGH */
        case 2:
                tm.tm_mday = ul;
                /* FALLTHROUGH */
        case 0:
                break;
        default:
                return (time_t)-1;
        }

        /* Sanity check */
        if (tm.tm_year < 70 || tm.tm_mon < 0 || tm.tm_mon > 12 ||
            tm.tm_mday < 1 || tm.tm_mday > 31)
                return (time_t)-1;

        if (*t != '\0') {
                s = ++t;
                ul = strtoul(s, &t, 10);
                if (*t != '\0' && !isspace((unsigned char)*t))
                        return (time_t)-1;

                switch (t - s) {
                case 6:
                        tm.tm_sec = ul % 100;
                        ul /= 100;
                        /* FALLTHROUGH */
                case 4:
                        tm.tm_min = ul % 100;
                        ul /= 100;
                        /* FALLTHROUGH */
                case 2:
                        tm.tm_hour = ul;
                        /* FALLTHROUGH */
                case 0:
                        break;
                default:
                        return (time_t)-1;
                }

                /* Sanity check */
                if (tm.tm_sec < 0 || tm.tm_sec > 60 || tm.tm_min < 0 ||
                    tm.tm_min > 59 || tm.tm_hour < 0 || tm.tm_hour > 23)
                        return (time_t)-1;
        }
        
        return mktime(&tm);
}