/* $NetBSD: newsyslog.c,v 1.61 2013/09/05 11:34:40 prlw1 Exp $ */ /* * Copyright (c) 1999, 2000 Andrew Doran * 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 #ifndef lint __RCSID("$NetBSD: newsyslog.c,v 1.61 2013/09/05 11:34:40 prlw1 Exp $"); #endif /* not lint */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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"}, {"/usr/bin/xz", "-f", ".xz", "X"}, }; #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 'X': 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); }