newsyslog.c revision 80646 
1/*
2 * This file contains changes from the Open Software Foundation.
3 */
4
5/*
6 * Copyright 1988, 1989 by the Massachusetts Institute of Technology
7 *
8 * Permission to use, copy, modify, and distribute this software and its
9 * documentation for any purpose and without fee is hereby granted, provided
10 * that the above copyright notice appear in all copies and that both that
11 * copyright notice and this permission notice appear in supporting
12 * documentation, and that the names of M.I.T. and the M.I.T. S.I.P.B. not be
13 * used in advertising or publicity pertaining to distribution of the
14 * software without specific, written prior permission. M.I.T. and the M.I.T.
15 * S.I.P.B. make no representations about the suitability of this software
16 * for any purpose.  It is provided "as is" without express or implied
17 * warranty.
18 *
19 */
20
21/*
22 * newsyslog - roll over selected logs at the appropriate time, keeping the a
23 * specified number of backup files around.
24 */
25
26#ifndef lint
27static const char rcsid[] =
28"$FreeBSD: head/usr.sbin/newsyslog/newsyslog.c 80646 2001-07-30 16:27:16Z obrien $";
29#endif	/* not lint */
30
31#define OSF
32#ifndef COMPRESS_POSTFIX
33#define COMPRESS_POSTFIX ".gz"
34#endif
35#ifndef	BZCOMPRESS_POSTFIX
36#define	BZCOMPRESS_POSTFIX ".bz2"
37#endif
38
39#include <ctype.h>
40#include <err.h>
41#include <fcntl.h>
42#include <grp.h>
43#include <paths.h>
44#include <pwd.h>
45#include <signal.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <string.h>
49#include <time.h>
50#include <unistd.h>
51#include <sys/types.h>
52#include <sys/stat.h>
53#include <sys/param.h>
54#include <sys/wait.h>
55
56#include "pathnames.h"
57
58#define kbytes(size)  (((size) + 1023) >> 10)
59
60#ifdef _IBMR2
61/* Calculates (db * DEV_BSIZE) */
62#define dbtob(db)  ((unsigned)(db) << UBSHIFT)
63#endif
64
65#define CE_COMPACT 1		/* Compact the achived log files */
66#define CE_BINARY  2		/* Logfile is in binary, don't add */
67#define CE_BZCOMPACT 8		/* Compact the achived log files with bzip2 */
68				/*  status messages */
69#define	CE_TRIMAT  4		/* trim at a specific time */
70
71#define NONE -1
72
73struct conf_entry {
74	char *log;		/* Name of the log */
75	char *pid_file;		/* PID file */
76	int uid;		/* Owner of log */
77	int gid;		/* Group of log */
78	int numlogs;		/* Number of logs to keep */
79	int size;		/* Size cutoff to trigger trimming the log */
80	int hours;		/* Hours between log trimming */
81	time_t trim_at;		/* Specific time to do trimming */
82	int permissions;	/* File permissions on the log */
83	int flags;		/* CE_COMPACT, CE_BZCOMPACT, CE_BINARY */
84	int sig;		/* Signal to send */
85	struct conf_entry *next;/* Linked list pointer */
86};
87
88int archtodir = 0;		/* Archive old logfiles to other directory */
89int verbose = 0;		/* Print out what's going on */
90int needroot = 1;		/* Root privs are necessary */
91int noaction = 0;		/* Don't do anything, just show it */
92int force = 0;			/* Force the trim no matter what */
93char *archdirname;		/* Directory path to old logfiles archive */
94const char *conf = _PATH_CONF;	/* Configuration file to use */
95time_t timenow;
96
97#define MIN_PID         5
98#define MAX_PID		99999	/* was lower, see /usr/include/sys/proc.h */
99char hostname[MAXHOSTNAMELEN];	/* hostname */
100char *daytime;			/* timenow in human readable form */
101
102static struct conf_entry *parse_file(char **files);
103static char *sob(char *p);
104static char *son(char *p);
105static char *missing_field(char *p, char *errline);
106static void do_entry(struct conf_entry * ent);
107static void PRS(int argc, char **argv);
108static void usage(void);
109static void dotrim(char *log, const char *pid_file, int numdays, int falgs,
110		int perm, int owner_uid, int group_gid, int sig);
111static int log_trim(char *log);
112static void compress_log(char *log);
113static void bzcompress_log(char *log);
114static int sizefile(char *file);
115static int age_old_log(char *file);
116static pid_t get_pid(const char *pid_file);
117static time_t parse8601(char *s);
118static void movefile(char *from, char *to, int perm, int owner_uid,
119		int group_gid);
120static void createdir(char *dirpart);
121static time_t parseDWM(char *s);
122
123int
124main(int argc, char **argv)
125{
126	struct conf_entry *p, *q;
127
128	PRS(argc, argv);
129	if (needroot && getuid() && geteuid())
130		errx(1, "must have root privs");
131	p = q = parse_file(argv + optind);
132
133	while (p) {
134		do_entry(p);
135		p = p->next;
136		free((char *) q);
137		q = p;
138	}
139	return (0);
140}
141
142static void
143do_entry(struct conf_entry * ent)
144{
145	int size, modtime;
146	const char *pid_file;
147
148	if (verbose) {
149		if (ent->flags & CE_COMPACT)
150			printf("%s <%dZ>: ", ent->log, ent->numlogs);
151		else if (ent->flags & CE_BZCOMPACT)
152			printf("%s <%dJ>: ", ent->log, ent->numlogs);
153		else
154			printf("%s <%d>: ", ent->log, ent->numlogs);
155	}
156	size = sizefile(ent->log);
157	modtime = age_old_log(ent->log);
158	if (size < 0) {
159		if (verbose)
160			printf("does not exist.\n");
161	} else {
162		if (ent->flags & CE_TRIMAT) {
163			if (timenow < ent->trim_at
164			    || difftime(timenow, ent->trim_at) >= 60 * 60) {
165				if (verbose)
166					printf("--> will trim at %s",
167					    ctime(&ent->trim_at));
168				return;
169			} else if (verbose && ent->hours <= 0) {
170				printf("--> time is up\n");
171			}
172		}
173		if (verbose && (ent->size > 0))
174			printf("size (Kb): %d [%d] ", size, ent->size);
175		if (verbose && (ent->hours > 0))
176			printf(" age (hr): %d [%d] ", modtime, ent->hours);
177		if (force || ((ent->size > 0) && (size >= ent->size)) ||
178		    (ent->hours <= 0 && (ent->flags & CE_TRIMAT)) ||
179		    ((ent->hours > 0) && ((modtime >= ent->hours)
180			    || (modtime < 0)))) {
181			if (verbose)
182				printf("--> trimming log....\n");
183			if (noaction && !verbose) {
184				if (ent->flags & CE_COMPACT)
185					printf("%s <%dZ>: trimming\n",
186					    ent->log, ent->numlogs);
187				else if (ent->flags & CE_BZCOMPACT)
188					printf("%s <%dJ>: trimming\n",
189					    ent->log, ent->numlogs);
190				else
191					printf("%s <%d>: trimming\n",
192					    ent->log, ent->numlogs);
193			}
194			if (ent->pid_file) {
195				pid_file = ent->pid_file;
196			} else {
197				/* Only try to notify syslog if we are root */
198				if (needroot)
199					pid_file = _PATH_SYSLOGPID;
200				else
201					pid_file = NULL;
202			}
203			dotrim(ent->log, pid_file, ent->numlogs,
204			    ent->flags, ent->permissions, ent->uid, ent->gid,
205			    ent->sig);
206		} else {
207			if (verbose)
208				printf("--> skipping\n");
209		}
210	}
211}
212
213static void
214PRS(int argc, char **argv)
215{
216	int c;
217	char *p;
218
219	timenow = time((time_t *) 0);
220	daytime = ctime(&timenow) + 4;
221	daytime[15] = '\0';
222
223	/* Let's get our hostname */
224	(void) gethostname(hostname, sizeof(hostname));
225
226	/* Truncate domain */
227	if ((p = strchr(hostname, '.'))) {
228		*p = '\0';
229	}
230	while ((c = getopt(argc, argv, "nrvFf:a:t:")) != -1)
231		switch (c) {
232		case 'n':
233			noaction++;
234			break;
235		case 'a':
236			archtodir++;
237			archdirname = optarg;
238			break;
239		case 'r':
240			needroot = 0;
241			break;
242		case 'v':
243			verbose++;
244			break;
245		case 'f':
246			conf = optarg;
247			break;
248		case 'F':
249			force++;
250			break;
251		default:
252			usage();
253		}
254}
255
256static void
257usage(void)
258{
259
260	fprintf(stderr,
261	    "usage: newsyslog [-Fnrv] [-f config-file] [-a directory]\n");
262	exit(1);
263}
264
265/*
266 * Parse a configuration file and return a linked list of all the logs to
267 * process
268 */
269static struct conf_entry *
270parse_file(char **files)
271{
272	FILE *f;
273	char line[BUFSIZ], *parse, *q;
274	char *errline, *group;
275	char **p;
276	struct conf_entry *first, *working;
277	struct passwd *pass;
278	struct group *grp;
279	int eol;
280
281	first = working = NULL;
282
283	if (strcmp(conf, "-"))
284		f = fopen(conf, "r");
285	else
286		f = stdin;
287	if (!f)
288		err(1, "%s", conf);
289	while (fgets(line, BUFSIZ, f)) {
290		if ((line[0] == '\n') || (line[0] == '#'))
291			continue;
292		errline = strdup(line);
293
294		q = parse = missing_field(sob(line), errline);
295		parse = son(line);
296		if (!*parse)
297			errx(1, "malformed line (missing fields):\n%s",
298			    errline);
299		*parse = '\0';
300
301		if (*files) {
302			for (p = files; *p; ++p)
303				if (strcmp(*p, q) == 0)
304					break;
305			if (!*p)
306				continue;
307		}
308
309		if (!first) {
310			if ((working = malloc(sizeof(struct conf_entry))) ==
311			    NULL)
312				err(1, "malloc");
313			first = working;
314		} else {
315			if ((working->next = malloc(sizeof(struct conf_entry)))
316			    == NULL)
317				err(1, "malloc");
318			working = working->next;
319		}
320		if ((working->log = strdup(q)) == NULL)
321			err(1, "strdup");
322
323		q = parse = missing_field(sob(++parse), errline);
324		parse = son(parse);
325		if (!*parse)
326			errx(1, "malformed line (missing fields):\n%s",
327			    errline);
328		*parse = '\0';
329		if ((group = strchr(q, ':')) != NULL ||
330		    (group = strrchr(q, '.')) != NULL) {
331			*group++ = '\0';
332			if (*q) {
333				if (!(isnumber(*q))) {
334					if ((pass = getpwnam(q)) == NULL)
335						errx(1,
336				     "error in config file; unknown user:\n%s",
337						    errline);
338					working->uid = pass->pw_uid;
339				} else
340					working->uid = atoi(q);
341			} else
342				working->uid = NONE;
343
344			q = group;
345			if (*q) {
346				if (!(isnumber(*q))) {
347					if ((grp = getgrnam(q)) == NULL)
348						errx(1,
349				    "error in config file; unknown group:\n%s",
350						    errline);
351					working->gid = grp->gr_gid;
352				} else
353					working->gid = atoi(q);
354			} else
355				working->gid = NONE;
356
357			q = parse = missing_field(sob(++parse), errline);
358			parse = son(parse);
359			if (!*parse)
360				errx(1, "malformed line (missing fields):\n%s",
361				    errline);
362			*parse = '\0';
363		} else
364			working->uid = working->gid = NONE;
365
366		if (!sscanf(q, "%o", &working->permissions))
367			errx(1, "error in config file; bad permissions:\n%s",
368			    errline);
369
370		q = parse = missing_field(sob(++parse), errline);
371		parse = son(parse);
372		if (!*parse)
373			errx(1, "malformed line (missing fields):\n%s",
374			    errline);
375		*parse = '\0';
376		if (!sscanf(q, "%d", &working->numlogs))
377			errx(1, "error in config file; bad number:\n%s",
378			    errline);
379
380		q = parse = missing_field(sob(++parse), errline);
381		parse = son(parse);
382		if (!*parse)
383			errx(1, "malformed line (missing fields):\n%s",
384			    errline);
385		*parse = '\0';
386		if (isdigit(*q))
387			working->size = atoi(q);
388		else
389			working->size = -1;
390
391		working->flags = 0;
392		q = parse = missing_field(sob(++parse), errline);
393		parse = son(parse);
394		eol = !*parse;
395		*parse = '\0';
396		{
397			char *ep;
398			u_long ul;
399
400			ul = strtoul(q, &ep, 10);
401			if (ep == q)
402				working->hours = 0;
403			else if (*ep == '*')
404				working->hours = -1;
405			else if (ul > INT_MAX)
406				errx(1, "interval is too large:\n%s", errline);
407			else
408				working->hours = ul;
409
410			if (*ep != '\0' && *ep != '@' && *ep != '*' &&
411			    *ep != '$')
412				errx(1, "malformed interval/at:\n%s", errline);
413			if (*ep == '@') {
414				if ((working->trim_at = parse8601(ep + 1))
415				    == (time_t) - 1)
416					errx(1, "malformed at:\n%s", errline);
417				working->flags |= CE_TRIMAT;
418			} else if (*ep == '$') {
419				if ((working->trim_at = parseDWM(ep + 1))
420				    == (time_t) - 1)
421					errx(1, "malformed at:\n%s", errline);
422				working->flags |= CE_TRIMAT;
423			}
424		}
425
426		if (eol)
427			q = NULL;
428		else {
429			q = parse = sob(++parse);	/* Optional field */
430			parse = son(parse);
431			if (!*parse)
432				eol = 1;
433			*parse = '\0';
434		}
435
436		while (q && *q && !isspace(*q)) {
437			if ((*q == 'Z') || (*q == 'z'))
438				working->flags |= CE_COMPACT;
439			else if ((*q == 'J') || (*q == 'j'))
440				working->flags |= CE_BZCOMPACT;
441			else if ((*q == 'B') || (*q == 'b'))
442				working->flags |= CE_BINARY;
443			else if (*q != '-')
444				errx(1, "illegal flag in config file -- %c",
445				    *q);
446			q++;
447		}
448
449		if (eol)
450			q = NULL;
451		else {
452			q = parse = sob(++parse);	/* Optional field */
453			parse = son(parse);
454			if (!*parse)
455				eol = 1;
456			*parse = '\0';
457		}
458
459		working->pid_file = NULL;
460		if (q && *q) {
461			if (*q == '/')
462				working->pid_file = strdup(q);
463			else if (isdigit(*q))
464				goto got_sig;
465			else
466				errx(1,
467			"illegal pid file or signal number in config file:\n%s",
468				    errline);
469		}
470		if (eol)
471			q = NULL;
472		else {
473			q = parse = sob(++parse);	/* Optional field */
474			*(parse = son(parse)) = '\0';
475		}
476
477		working->sig = SIGHUP;
478		if (q && *q) {
479			if (isdigit(*q)) {
480		got_sig:
481				working->sig = atoi(q);
482			} else {
483		err_sig:
484				errx(1,
485				    "illegal signal number in config file:\n%s",
486				    errline);
487			}
488			if (working->sig < 1 || working->sig >= NSIG)
489				goto err_sig;
490		}
491		free(errline);
492	}
493	if (working)
494		working->next = (struct conf_entry *) NULL;
495	(void) fclose(f);
496	return (first);
497}
498
499static char *
500missing_field(char *p, char *errline)
501{
502
503	if (!p || !*p)
504		errx(1, "missing field in config file:\n%s", errline);
505	return (p);
506}
507
508static void
509dotrim(char *log, const char *pid_file, int numdays, int flags, int perm,
510    int owner_uid, int group_gid, int sig)
511{
512	char dirpart[MAXPATHLEN], namepart[MAXPATHLEN];
513	char file1[MAXPATHLEN], file2[MAXPATHLEN];
514	char zfile1[MAXPATHLEN], zfile2[MAXPATHLEN];
515	char jfile1[MAXPATHLEN];
516	int notified, need_notification, fd, _numdays;
517	struct stat st;
518	pid_t pid;
519
520#ifdef _IBMR2
521	/*
522	 * AIX 3.1 has a broken fchown- if the owner_uid is -1, it will
523	 * actually change it to be owned by uid -1, instead of leaving it
524	 * as is, as it is supposed to.
525	 */
526	if (owner_uid == -1)
527		owner_uid = geteuid();
528#endif
529
530	if (archtodir) {
531		char *p;
532
533		/* build complete name of archive directory into dirpart */
534		if (*archdirname == '/') {	/* absolute */
535			strlcpy(dirpart, archdirname, sizeof(dirpart));
536		} else {	/* relative */
537			/* get directory part of logfile */
538			strlcpy(dirpart, log, sizeof(dirpart));
539			if ((p = rindex(dirpart, '/')) == NULL)
540				dirpart[0] = '\0';
541			else
542				*(p + 1) = '\0';
543			strlcat(dirpart, archdirname, sizeof(dirpart));
544		}
545
546		/* check if archive directory exists, if not, create it */
547		if (lstat(dirpart, &st))
548			createdir(dirpart);
549
550		/* get filename part of logfile */
551		if ((p = rindex(log, '/')) == NULL)
552			strlcpy(namepart, log, sizeof(namepart));
553		else
554			strlcpy(namepart, p + 1, sizeof(namepart));
555
556		/* name of oldest log */
557		(void) snprintf(file1, sizeof(file1), "%s/%s.%d", dirpart,
558		    namepart, numdays);
559		(void) snprintf(zfile1, sizeof(zfile1), "%s%s", file1,
560		    COMPRESS_POSTFIX);
561		snprintf(jfile1, sizeof(jfile1), "%s%s", file1,
562		    BZCOMPRESS_POSTFIX);
563	} else {
564		/* name of oldest log */
565		(void) snprintf(file1, sizeof(file1), "%s.%d", log, numdays);
566		(void) snprintf(zfile1, sizeof(zfile1), "%s%s", file1,
567		    COMPRESS_POSTFIX);
568		snprintf(jfile1, sizeof(jfile1), "%s%s", file1,
569		    BZCOMPRESS_POSTFIX);
570	}
571
572	if (noaction) {
573		printf("rm -f %s\n", file1);
574		printf("rm -f %s\n", zfile1);
575		printf("rm -f %s\n", jfile1);
576	} else {
577		(void) unlink(file1);
578		(void) unlink(zfile1);
579		(void) unlink(jfile1);
580	}
581
582	/* Move down log files */
583	_numdays = numdays;	/* preserve */
584	while (numdays--) {
585
586		(void) strlcpy(file2, file1, sizeof(file2));
587
588		if (archtodir)
589			(void) snprintf(file1, sizeof(file1), "%s/%s.%d",
590			    dirpart, namepart, numdays);
591		else
592			(void) snprintf(file1, sizeof(file1), "%s.%d", log,
593			    numdays);
594
595		(void) strlcpy(zfile1, file1, sizeof(zfile1));
596		(void) strlcpy(zfile2, file2, sizeof(zfile2));
597		if (lstat(file1, &st)) {
598			(void) strlcat(zfile1, COMPRESS_POSTFIX,
599			    sizeof(zfile1));
600			(void) strlcat(zfile2, COMPRESS_POSTFIX,
601			    sizeof(zfile2));
602			if (lstat(zfile1, &st)) {
603				strlcpy(zfile1, file1, sizeof(zfile1));
604				strlcpy(zfile2, file2, sizeof(zfile2));
605				strlcat(zfile1, BZCOMPRESS_POSTFIX,
606				    sizeof(zfile1));
607				strlcat(zfile2, BZCOMPRESS_POSTFIX,
608				    sizeof(zfile2));
609				if (lstat(zfile1, &st))
610					continue;
611			}
612		}
613		if (noaction) {
614			printf("mv %s %s\n", zfile1, zfile2);
615			printf("chmod %o %s\n", perm, zfile2);
616			printf("chown %d.%d %s\n",
617			    owner_uid, group_gid, zfile2);
618		} else {
619			(void) rename(zfile1, zfile2);
620			(void) chmod(zfile2, perm);
621			(void) chown(zfile2, owner_uid, group_gid);
622		}
623	}
624	if (!noaction && !(flags & CE_BINARY))
625		(void) log_trim(log);	/* Report the trimming to the old log */
626
627	if (!_numdays) {
628		if (noaction)
629			printf("rm %s\n", log);
630		else
631			(void) unlink(log);
632	} else {
633		if (noaction)
634			printf("mv %s to %s\n", log, file1);
635		else {
636			if (archtodir)
637				movefile(log, file1, perm, owner_uid,
638				    group_gid);
639			else
640				(void) rename(log, file1);
641		}
642	}
643
644	if (noaction)
645		printf("Start new log...");
646	else {
647		fd = creat(log, perm);
648		if (fd < 0)
649			err(1, "can't start new log");
650		if (fchown(fd, owner_uid, group_gid))
651			err(1, "can't chmod new log file");
652		(void) close(fd);
653		if (!(flags & CE_BINARY))
654			if (log_trim(log))	/* Add status message */
655				err(1, "can't add status message to log");
656	}
657	if (noaction)
658		printf("chmod %o %s...\n", perm, log);
659	else
660		(void) chmod(log, perm);
661
662	pid = 0;
663	need_notification = notified = 0;
664	if (pid_file != NULL) {
665		need_notification = 1;
666		pid = get_pid(pid_file);
667	}
668	if (pid) {
669		if (noaction) {
670			notified = 1;
671			printf("kill -%d %d\n", sig, (int) pid);
672		} else if (kill(pid, sig))
673			warn("can't notify daemon, pid %d", (int) pid);
674		else {
675			notified = 1;
676			if (verbose)
677				printf("daemon pid %d notified\n", (int) pid);
678		}
679	}
680	if ((flags & CE_COMPACT) || (flags & CE_BZCOMPACT)) {
681		if (need_notification && !notified)
682			warnx(
683			    "log %s not compressed because daemon not notified",
684			    log);
685		else if (noaction)
686			printf("Compress %s.0\n", log);
687		else {
688			if (notified) {
689				if (verbose)
690					printf("small pause to allow daemon to close log\n");
691				sleep(10);
692			}
693			if (archtodir) {
694				(void) snprintf(file1, sizeof(file1), "%s/%s",
695				    dirpart, namepart);
696				if (flags & CE_COMPACT)
697					compress_log(file1);
698				else if (flags & CE_BZCOMPACT)
699					bzcompress_log(file1);
700			} else {
701				if (flags & CE_COMPACT)
702					compress_log(log);
703				else if (flags & CE_BZCOMPACT)
704					bzcompress_log(log);
705			}
706		}
707	}
708}
709
710/* Log the fact that the logs were turned over */
711static int
712log_trim(char *log)
713{
714	FILE *f;
715
716	if ((f = fopen(log, "a")) == NULL)
717		return (-1);
718	fprintf(f, "%s %s newsyslog[%d]: logfile turned over\n",
719	    daytime, hostname, (int) getpid());
720	if (fclose(f) == EOF)
721		err(1, "log_trim: fclose:");
722	return (0);
723}
724
725/* Fork of gzip to compress the old log file */
726static void
727compress_log(char *log)
728{
729	pid_t pid;
730	char tmp[MAXPATHLEN];
731
732	(void) snprintf(tmp, sizeof(tmp), "%s.0", log);
733	pid = fork();
734	if (pid < 0)
735		err(1, "gzip fork");
736	else if (!pid) {
737		(void) execl(_PATH_GZIP, _PATH_GZIP, "-f", tmp, (char *)0);
738		err(1, _PATH_GZIP);
739	}
740}
741
742/* Fork of bzip2 to compress the old log file */
743static void
744bzcompress_log(char *log)
745{
746	pid_t pid;
747	char tmp[MAXPATHLEN];
748
749	snprintf(tmp, sizeof(tmp), "%s.0", log);
750	pid = fork();
751	if (pid < 0)
752		err(1, "bzip2 fork");
753	else if (!pid) {
754		execl(_PATH_BZIP2, _PATH_BZIP2, "-f", tmp, 0);
755		err(1, _PATH_BZIP2);
756	}
757}
758
759/* Return size in kilobytes of a file */
760static int
761sizefile(char *file)
762{
763	struct stat sb;
764
765	if (stat(file, &sb) < 0)
766		return (-1);
767	return (kbytes(dbtob(sb.st_blocks)));
768}
769
770/* Return the age of old log file (file.0) */
771static int
772age_old_log(char *file)
773{
774	struct stat sb;
775	char tmp[MAXPATHLEN + sizeof(".0") + sizeof(COMPRESS_POSTFIX) + 1];
776
777	if (archtodir) {
778		char *p;
779
780		/* build name of archive directory into tmp */
781		if (*archdirname == '/') {	/* absolute */
782			strlcpy(tmp, archdirname, sizeof(tmp));
783		} else {	/* relative */
784			/* get directory part of logfile */
785			strlcpy(tmp, file, sizeof(tmp));
786			if ((p = rindex(tmp, '/')) == NULL)
787				tmp[0] = '\0';
788			else
789				*(p + 1) = '\0';
790			strlcat(tmp, archdirname, sizeof(tmp));
791		}
792
793		strlcat(tmp, "/", sizeof(tmp));
794
795		/* get filename part of logfile */
796		if ((p = rindex(file, '/')) == NULL)
797			strlcat(tmp, file, sizeof(tmp));
798		else
799			strlcat(tmp, p + 1, sizeof(tmp));
800	} else {
801		(void) strlcpy(tmp, file, sizeof(tmp));
802	}
803
804	if (stat(strcat(tmp, ".0"), &sb) < 0)
805		if (stat(strcat(tmp, COMPRESS_POSTFIX), &sb) < 0)
806			return (-1);
807	return ((int) (timenow - sb.st_mtime + 1800) / 3600);
808}
809
810static pid_t
811get_pid(const char *pid_file)
812{
813	FILE *f;
814	char line[BUFSIZ];
815	pid_t pid = 0;
816
817	if ((f = fopen(pid_file, "r")) == NULL)
818		warn("can't open %s pid file to restart a daemon",
819		    pid_file);
820	else {
821		if (fgets(line, BUFSIZ, f)) {
822			pid = atol(line);
823			if (pid < MIN_PID || pid > MAX_PID) {
824				warnx("preposterous process number: %d",
825				   (int)pid);
826				pid = 0;
827			}
828		} else
829			warn("can't read %s pid file to restart a daemon",
830			    pid_file);
831		(void) fclose(f);
832	}
833	return pid;
834}
835
836/* Skip Over Blanks */
837char *
838sob(char *p)
839{
840	while (p && *p && isspace(*p))
841		p++;
842	return (p);
843}
844
845/* Skip Over Non-Blanks */
846char *
847son(char *p)
848{
849	while (p && *p && !isspace(*p))
850		p++;
851	return (p);
852}
853
854/*
855 * Parse a limited subset of ISO 8601. The specific format is as follows:
856 *
857 * [CC[YY[MM[DD]]]][THH[MM[SS]]]	(where `T' is the literal letter)
858 *
859 * We don't accept a timezone specification; missing fields (including timezone)
860 * are defaulted to the current date but time zero.
861 */
862static time_t
863parse8601(char *s)
864{
865	char *t;
866	struct tm tm, *tmp;
867	u_long ul;
868
869	tmp = localtime(&timenow);
870	tm = *tmp;
871
872	tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
873
874	ul = strtoul(s, &t, 10);
875	if (*t != '\0' && *t != 'T')
876		return -1;
877
878	/*
879	 * Now t points either to the end of the string (if no time was
880	 * provided) or to the letter `T' which separates date and time in
881	 * ISO 8601.  The pointer arithmetic is the same for either case.
882	 */
883	switch (t - s) {
884	case 8:
885		tm.tm_year = ((ul / 1000000) - 19) * 100;
886		ul = ul % 1000000;
887	case 6:
888		tm.tm_year = tm.tm_year - (tm.tm_year % 100);
889		tm.tm_year += ul / 10000;
890		ul = ul % 10000;
891	case 4:
892		tm.tm_mon = (ul / 100) - 1;
893		ul = ul % 100;
894	case 2:
895		tm.tm_mday = ul;
896	case 0:
897		break;
898	default:
899		return -1;
900	}
901
902	/* sanity check */
903	if (tm.tm_year < 70 || tm.tm_mon < 0 || tm.tm_mon > 12
904	    || tm.tm_mday < 1 || tm.tm_mday > 31)
905		return -1;
906
907	if (*t != '\0') {
908		s = ++t;
909		ul = strtoul(s, &t, 10);
910		if (*t != '\0' && !isspace(*t))
911			return -1;
912
913		switch (t - s) {
914		case 6:
915			tm.tm_sec = ul % 100;
916			ul /= 100;
917		case 4:
918			tm.tm_min = ul % 100;
919			ul /= 100;
920		case 2:
921			tm.tm_hour = ul;
922		case 0:
923			break;
924		default:
925			return -1;
926		}
927
928		/* sanity check */
929		if (tm.tm_sec < 0 || tm.tm_sec > 60 || tm.tm_min < 0
930		    || tm.tm_min > 59 || tm.tm_hour < 0 || tm.tm_hour > 23)
931			return -1;
932	}
933	return mktime(&tm);
934}
935
936/* physically move file */
937static void
938movefile(char *from, char *to, int perm, int owner_uid, int group_gid)
939{
940	FILE *src, *dst;
941	int c;
942
943	if ((src = fopen(from, "r")) == NULL)
944		err(1, "can't fopen %s for reading", from);
945	if ((dst = fopen(to, "w")) == NULL)
946		err(1, "can't fopen %s for writing", to);
947	if (fchown(fileno(dst), owner_uid, group_gid))
948		err(1, "can't fchown %s", to);
949	if (fchmod(fileno(dst), perm))
950		err(1, "can't fchmod %s", to);
951
952	while ((c = getc(src)) != EOF) {
953		if ((putc(c, dst)) == EOF)
954			err(1, "error writing to %s", to);
955	}
956
957	if (ferror(src))
958		err(1, "error reading from %s", from);
959	if ((fclose(src)) != 0)
960		err(1, "can't fclose %s", to);
961	if ((fclose(dst)) != 0)
962		err(1, "can't fclose %s", from);
963	if ((unlink(from)) != 0)
964		err(1, "can't unlink %s", from);
965}
966
967/* create one or more directory components of a path */
968static void
969createdir(char *dirpart)
970{
971	char *s, *d;
972	char mkdirpath[MAXPATHLEN];
973	struct stat st;
974
975	s = dirpart;
976	d = mkdirpath;
977
978	for (;;) {
979		*d++ = *s++;
980		if (*s == '/' || *s == '\0') {
981			*d = '\0';
982			if (lstat(mkdirpath, &st))
983				mkdir(mkdirpath, 0755);
984		}
985		if (*s == '\0')
986			break;
987	}
988}
989
990/*-
991 * Parse a cyclic time specification, the format is as follows:
992 *
993 *	[Dhh] or [Wd[Dhh]] or [Mdd[Dhh]]
994 *
995 * to rotate a logfile cyclic at
996 *
997 *	- every day (D) within a specific hour (hh)	(hh = 0...23)
998 *	- once a week (W) at a specific day (d)     OR	(d = 0..6, 0 = Sunday)
999 *	- once a month (M) at a specific day (d)	(d = 1..31,l|L)
1000 *
1001 * We don't accept a timezone specification; missing fields
1002 * are defaulted to the current date but time zero.
1003 */
1004static time_t
1005parseDWM(char *s)
1006{
1007	char *t;
1008	struct tm tm, *tmp;
1009	u_long ul;
1010	int nd;
1011	static int mtab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
1012	int WMseen = 0;
1013	int Dseen = 0;
1014
1015	tmp = localtime(&timenow);
1016	tm = *tmp;
1017
1018	/* set no. of days per month */
1019
1020	nd = mtab[tm.tm_mon];
1021
1022	if (tm.tm_mon == 1) {
1023		if (((tm.tm_year + 1900) % 4 == 0) &&
1024		    ((tm.tm_year + 1900) % 100 != 0) &&
1025		    ((tm.tm_year + 1900) % 400 == 0)) {
1026			nd++;	/* leap year, 29 days in february */
1027		}
1028	}
1029	tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
1030
1031	for (;;) {
1032		switch (*s) {
1033		case 'D':
1034			if (Dseen)
1035				return -1;
1036			Dseen++;
1037			s++;
1038			ul = strtoul(s, &t, 10);
1039			if (ul > 23)
1040				return -1;
1041			tm.tm_hour = ul;
1042			break;
1043
1044		case 'W':
1045			if (WMseen)
1046				return -1;
1047			WMseen++;
1048			s++;
1049			ul = strtoul(s, &t, 10);
1050			if (ul > 6)
1051				return -1;
1052			if (ul != (unsigned)tm.tm_wday) {
1053				int save;
1054
1055				if (ul < (unsigned)tm.tm_wday) {
1056					save = 6 - tm.tm_wday;
1057					save += (ul + 1);
1058				} else {
1059					save = ul - tm.tm_wday;
1060				}
1061
1062				tm.tm_mday += save;
1063
1064				if (tm.tm_mday > nd) {
1065					tm.tm_mon++;
1066					tm.tm_mday = tm.tm_mday - nd;
1067				}
1068			}
1069			break;
1070
1071		case 'M':
1072			if (WMseen)
1073				return -1;
1074			WMseen++;
1075			s++;
1076			if (tolower(*s) == 'l') {
1077				tm.tm_mday = nd;
1078				s++;
1079				t = s;
1080			} else {
1081				ul = strtoul(s, &t, 10);
1082				if (ul < 1 || ul > 31)
1083					return -1;
1084
1085				if (ul > (unsigned)nd)
1086					return -1;
1087				tm.tm_mday = ul;
1088			}
1089			break;
1090
1091		default:
1092			return (-1);
1093			break;
1094		}
1095
1096		if (*t == '\0' || isspace(*t))
1097			break;
1098		else
1099			s = t;
1100	}
1101	return mktime(&tm);
1102}
1103