1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
24 *
25 * logadm/main.c -- main routines for logadm
26 *
27 * this program is 90% argument processing, 10% actions...
28 */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <strings.h>
34 #include <libintl.h>
35 #include <locale.h>
36 #include <fcntl.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <sys/wait.h>
40 #include <sys/filio.h>
41 #include <sys/sysmacros.h>
42 #include <time.h>
43 #include <utime.h>
44 #include "err.h"
45 #include "lut.h"
46 #include "fn.h"
47 #include "opts.h"
48 #include "conf.h"
49 #include "glob.h"
50 #include "kw.h"
51
52 /* forward declarations for functions in this file */
53 static void usage(const char *msg);
54 static void commajoin(const char *lhs, void *rhs, void *arg);
55 static void doaftercmd(const char *lhs, void *rhs, void *arg);
56 static void dologname(struct fn *fnp, struct opts *clopts);
57 static boolean_t rotatelog(struct fn *fnp, struct opts *opts);
58 static void rotateto(struct fn *fnp, struct opts *opts, int n,
59 struct fn *recentlog, boolean_t isgz);
60 static void do_delayed_gzip(const char *lhs, void *rhs, void *arg);
61 static void expirefiles(struct fn *fnp, struct opts *opts);
62 static void dorm(struct opts *opts, const char *msg, struct fn *fnp);
63 static void docmd(struct opts *opts, const char *msg, const char *cmd,
64 const char *arg1, const char *arg2, const char *arg3);
65 static void docopytruncate(struct opts *opts, const char *file,
66 const char *file_copy);
67
68 /* our configuration file, unless otherwise specified by -f */
69 static char *Default_conffile = "/etc/logadm.conf";
70 /* our timestamps file, unless otherwise specified by -F */
71 static char *Default_timestamps = "/var/logadm/timestamps";
72
73 /* default pathnames to the commands we invoke */
74 static char *Sh = "/bin/sh";
75 static char *Mv = "/bin/mv";
76 static char *Rm = "/bin/rm";
77 static char *Touch = "/bin/touch";
78 static char *Chmod = "/bin/chmod";
79 static char *Chown = "/bin/chown";
80 static char *Gzip = "/bin/gzip";
81 static char *Mkdir = "/bin/mkdir";
82
83 /* return from time(0), gathered early on to avoid slewed timestamps */
84 time_t Now;
85
86 /* list of before commands that have been executed */
87 static struct lut *Beforecmds;
88
89 /* list of after commands to execute before exiting */
90 static struct lut *Aftercmds;
91
92 /* list of conffile entry names that are considered "done" */
93 static struct lut *Donenames;
94
95 /* A list of names of files to be gzipped */
96 static struct lut *Gzipnames = NULL;
97
98 /*
99 * only the "FfhnVv" options are allowed in the first form of this command,
100 * so this defines the list of options that are an error in they appear
101 * in the first form. In other words, it is not allowed to run logadm
102 * with any of these options unless at least one logname is also provided.
103 */
104 #define OPTIONS_NOT_FIRST_FORM "eNrwpPsabcglmoRtzACEST"
105
106 /* text that we spew with the -h flag */
107 #define HELP1 \
108 "Usage: logadm [options]\n"\
109 " (processes all entries in /etc/logadm.conf or conffile given by -f)\n"\
110 " or: logadm [options] logname...\n"\
111 " (processes the given lognames)\n"\
112 "\n"\
113 "General options:\n"\
114 " -e mailaddr mail errors to given address\n"\
115 " -F timestamps use timestamps instead of /var/logadm/timestamps\n"\
116 " -f conffile use conffile instead of /etc/logadm.conf\n"\
117 " -h display help\n"\
118 " -N not an error if log file nonexistent\n"\
119 " -n show actions, don't perform them\n"\
120 " -r remove logname entry from conffile\n"\
121 " -V ensure conffile entries exist, correct\n"\
122 " -v print info about actions happening\n"\
123 " -w entryname write entry to config file\n"\
124 "\n"\
125 "Options which control when a logfile is rotated:\n"\
126 "(default is: -s1b -p1w if no -s or -p)\n"\
127 " -p period only rotate if period passed since last rotate\n"\
128 " -P timestamp used to store rotation date in conffile\n"\
129 " -s size only rotate if given size or greater\n"\
130 "\n"
131 #define HELP2 \
132 "Options which control how a logfile is rotated:\n"\
133 "(default is: -t '$file.$n', owner/group/mode taken from log file)\n"\
134 " -a cmd execute cmd after taking actions\n"\
135 " -b cmd execute cmd before taking actions\n"\
136 " -c copy & truncate logfile, don't rename\n"\
137 " -g group new empty log file group\n"\
138 " -l rotate log file with local time rather than UTC\n"\
139 " -m mode new empty log file mode\n"\
140 " -M cmd execute cmd to rotate the log file\n"\
141 " -o owner new empty log file owner\n"\
142 " -R cmd run cmd on file after rotate\n"\
143 " -t template template for naming old logs\n"\
144 " -z count gzip old logs except most recent count\n"\
145 "\n"\
146 "Options which control the expiration of old logfiles:\n"\
147 "(default is: -C10 if no -A, -C, or -S)\n"\
148 " -A age expire logs older than age\n"\
149 " -C count expire old logs until count remain\n"\
150 " -E cmd run cmd on file to expire\n"\
151 " -S size expire until space used is below size \n"\
152 " -T pattern pattern for finding old logs\n"
153
154 /*
155 * main -- where it all begins
156 */
157 /*ARGSUSED*/
158 int
159 main(int argc, char *argv[])
160 {
161 struct opts *clopts; /* from parsing command line */
162 const char *conffile; /* our configuration file */
163 const char *timestamps; /* our timestamps file */
164 struct fn_list *lognames; /* list of lognames we're processing */
165 struct fn *fnp;
166 char *val;
167 char *buf;
168 int status;
169
170 (void) setlocale(LC_ALL, "");
171
172 #if !defined(TEXT_DOMAIN)
173 #define TEXT_DOMAIN "SYS_TEST" /* only used if Makefiles don't define it */
174 #endif
175
176 (void) textdomain(TEXT_DOMAIN);
177
178 /* we only print times into the timestamps file, so make them uniform */
179 (void) setlocale(LC_TIME, "C");
180
181 /* give our name to error routines & skip it for arg parsing */
182 err_init(*argv++);
183 (void) setlinebuf(stdout);
184
185 if (putenv("PATH=/bin"))
186 err(EF_SYS, "putenv PATH");
187 if (putenv("TZ=UTC"))
188 err(EF_SYS, "putenv TZ");
189 tzset();
190
191 (void) umask(0);
192
193 Now = time(0);
194
195 /* check for (undocumented) debugging environment variables */
196 if (val = getenv("_LOGADM_DEFAULT_CONFFILE"))
197 Default_conffile = val;
198 if (val = getenv("_LOGADM_DEFAULT_TIMESTAMPS"))
199 Default_timestamps = val;
200 if (val = getenv("_LOGADM_DEBUG"))
201 Debug = atoi(val);
202 if (val = getenv("_LOGADM_SH"))
203 Sh = val;
204 if (val = getenv("_LOGADM_MV"))
205 Mv = val;
206 if (val = getenv("_LOGADM_RM"))
207 Rm = val;
208 if (val = getenv("_LOGADM_TOUCH"))
209 Touch = val;
210 if (val = getenv("_LOGADM_CHMOD"))
211 Chmod = val;
212 if (val = getenv("_LOGADM_CHOWN"))
213 Chown = val;
214 if (val = getenv("_LOGADM_GZIP"))
215 Gzip = val;
216 if (val = getenv("_LOGADM_MKDIR"))
217 Mkdir = val;
218
219 opts_init(Opttable, Opttable_cnt);
220
221 /* parse command line arguments */
222 if (SETJMP)
223 usage("bailing out due to command line errors");
224 else
225 clopts = opts_parse(NULL, argv, OPTF_CLI);
226
227 if (Debug) {
228 (void) fprintf(stderr, "command line opts:");
229 opts_print(clopts, stderr, NULL);
230 (void) fprintf(stderr, "\n");
231 }
232
233 /*
234 * There are many moods of logadm:
235 *
236 * 1. "-h" for help was given. We spew a canned help
237 * message and exit, regardless of any other options given.
238 *
239 * 2. "-r" or "-w" asking us to write to the conffile. Lots
240 * of argument checking, then we make the change to conffile
241 * and exit. (-r processing actually happens in dologname().)
242 *
243 * 3. "-V" to search/verify the conffile was given. We do
244 * the appropriate run through the conffile and exit.
245 * (-V processing actually happens in dologname().)
246 *
247 * 4. No lognames were given, so we're being asked to go through
248 * every entry in conffile. We verify that only the options
249 * that make sense for this form of the command are present
250 * and fall into the main processing loop below.
251 *
252 * 5. lognames were given, so we fall into the main processing
253 * loop below to work our way through them.
254 *
255 * The last two cases are where the option processing gets more
256 * complex. Each time around the main processing loop, we're
257 * in one of these cases:
258 *
259 * A. No cmdargs were found (we're in case 4), the entry
260 * in conffile supplies no log file names, so the entry
261 * name itself is the logfile name (or names, if it globs
262 * to multiple file names).
263 *
264 * B. No cmdargs were found (we're in case 4), the entry
265 * in conffile gives log file names that we then loop
266 * through and rotate/expire. In this case, the entry
267 * name is specifically NOT one of the log file names.
268 *
269 * C. We're going through the cmdargs (we're in case 5),
270 * the entry in conffile either doesn't exist or it exists
271 * but supplies no log file names, so the cmdarg itself
272 * is the log file name.
273 *
274 * D. We're going through the cmdargs (we're in case 5),
275 * a matching entry in conffile supplies log file names
276 * that we then loop through and rotate/expire. In this
277 * case the entry name is specifically NOT one of the log
278 * file names.
279 *
280 * As we're doing all this, any options given on the command line
281 * override any found in the conffile, and we apply the defaults
282 * for rotation conditions and expiration conditions, etc. at the
283 * last opportunity, when we're sure they haven't been overridden
284 * by an option somewhere along the way.
285 *
286 */
287
288 /* help option overrides anything else */
289 if (opts_count(clopts, "h")) {
290 (void) fputs(HELP1, stderr);
291 (void) fputs(HELP2, stderr);
292 err_done(0);
293 /*NOTREACHED*/
294 }
295
296 /* detect illegal option combinations */
297 if (opts_count(clopts, "rwV") > 1)
298 usage("Only one of -r, -w, or -V may be used at a time.");
299 if (opts_count(clopts, "cM") > 1)
300 usage("Only one of -c or -M may be used at a time.");
301
302 /* arrange for error output to be mailed if clopts includes -e */
303 if (opts_count(clopts, "e"))
304 err_mailto(opts_optarg(clopts, "e"));
305
306 /* this implements the default conffile and timestamps */
307 if ((conffile = opts_optarg(clopts, "f")) == NULL)
308 conffile = Default_conffile;
309 if ((timestamps = opts_optarg(clopts, "F")) == NULL)
310 timestamps = Default_timestamps;
311 if (opts_count(clopts, "v"))
312 (void) out("# loading %s\n", conffile);
313 status = conf_open(conffile, timestamps, clopts);
314 if (!status && opts_count(clopts, "V"))
315 err_done(0);
316
317 /* handle conffile write option */
318 if (opts_count(clopts, "w")) {
319 if (Debug)
320 (void) fprintf(stderr,
321 "main: add/replace conffile entry: <%s>\n",
322 opts_optarg(clopts, "w"));
323 conf_replace(opts_optarg(clopts, "w"), clopts);
324 conf_close(clopts);
325 err_done(0);
326 /*NOTREACHED*/
327 }
328
329 /*
330 * lognames is either a list supplied on the command line,
331 * or every entry in the conffile if none were supplied.
332 */
333 lognames = opts_cmdargs(clopts);
334 if (fn_list_empty(lognames)) {
335 /*
336 * being asked to do all entries in conffile
337 *
338 * check to see if any options were given that only
339 * make sense when lognames are given specifically
340 * on the command line.
341 */
342 if (opts_count(clopts, OPTIONS_NOT_FIRST_FORM))
343 usage("some options require logname argument");
344 if (Debug)
345 (void) fprintf(stderr,
346 "main: run all entries in conffile\n");
347 lognames = conf_entries();
348 }
349
350 /* foreach logname... */
351 fn_list_rewind(lognames);
352 while ((fnp = fn_list_next(lognames)) != NULL) {
353 buf = fn_s(fnp);
354 if (buf != NULL && lut_lookup(Donenames, buf) != NULL) {
355 if (Debug)
356 (void) fprintf(stderr,
357 "main: logname already done: <%s>\n",
358 buf);
359 continue;
360 }
361 if (buf != NULL && SETJMP)
362 err(EF_FILE, "bailing out on logname \"%s\" "
363 "due to errors", buf);
364 else
365 dologname(fnp, clopts);
366 }
367
368 /* execute any after commands */
369 lut_walk(Aftercmds, doaftercmd, clopts);
370
371 /* execute any gzip commands */
372 lut_walk(Gzipnames, do_delayed_gzip, clopts);
373
374 /* write out any conffile changes */
375 conf_close(clopts);
376
377 err_done(0);
378 /*NOTREACHED*/
379 return (0); /* for lint's little mind */
380 }
381
382 /* spew a message, then a usage message, then exit */
383 static void
384 usage(const char *msg)
385 {
386 if (msg)
387 err(0, "%s\nUse \"logadm -h\" for help.", msg);
388 else
389 err(EF_RAW, "Use \"logadm -h\" for help.\n");
390 }
391
392 /* helper function used by doaftercmd() to join mail addrs with commas */
393 /*ARGSUSED1*/
394 static void
395 commajoin(const char *lhs, void *rhs, void *arg)
396 {
397 struct fn *fnp = (struct fn *)arg;
398 char *buf;
399
400 buf = fn_s(fnp);
401 if (buf != NULL && *buf)
402 fn_putc(fnp, ',');
403 fn_puts(fnp, lhs);
404 }
405
406 /* helper function used by main() to run "after" commands */
407 static void
408 doaftercmd(const char *lhs, void *rhs, void *arg)
409 {
410 struct opts *opts = (struct opts *)arg;
411 struct lut *addrs = (struct lut *)rhs;
412
413 if (addrs) {
414 struct fn *fnp = fn_new(NULL);
415
416 /*
417 * addrs contains list of email addrs that should get
418 * the error output when this after command is executed.
419 */
420 lut_walk(addrs, commajoin, fnp);
421 err_mailto(fn_s(fnp));
422 }
423
424 docmd(opts, "-a cmd", Sh, "-c", lhs, NULL);
425 }
426
427 /* perform delayed gzip */
428
429 static void
430 do_delayed_gzip(const char *lhs, void *rhs, void *arg)
431 {
432 struct opts *opts = (struct opts *)arg;
433
434 if (rhs == NULL) {
435 if (Debug) {
436 (void) fprintf(stderr, "do_delayed_gzip: not gzipping "
437 "expired file <%s>\n", lhs);
438 }
439 return;
440 }
441 docmd(opts, "compress old log (-z flag)", Gzip, "-f", lhs, NULL);
442 }
443
444
445 /* main logname processing */
446 static void
447 dologname(struct fn *fnp, struct opts *clopts)
448 {
449 const char *logname = fn_s(fnp);
450 struct opts *cfopts;
451 struct opts *allopts;
452 struct fn_list *logfiles;
453 struct fn_list *globbedfiles;
454 struct fn *nextfnp;
455
456 /* look up options set by config file */
457 cfopts = conf_opts(logname);
458
459 if (opts_count(clopts, "v"))
460 (void) out("# processing logname: %s\n", logname);
461
462 if (Debug) {
463 if (logname != NULL)
464 (void) fprintf(stderr, "dologname: logname <%s>\n",
465 logname);
466 (void) fprintf(stderr, "conffile opts:");
467 opts_print(cfopts, stderr, NULL);
468 (void) fprintf(stderr, "\n");
469 }
470
471 /* handle conffile lookup option */
472 if (opts_count(clopts, "V")) {
473 /* lookup an entry in conffile */
474 if (Debug)
475 (void) fprintf(stderr,
476 "dologname: lookup conffile entry\n");
477 if (conf_lookup(logname)) {
478 opts_printword(logname, stdout);
479 opts_print(cfopts, stdout, NULL);
480 (void) out("\n");
481 } else
482 err_exitcode(1);
483 return;
484 }
485
486 /* handle conffile removal option */
487 if (opts_count(clopts, "r")) {
488 if (Debug)
489 (void) fprintf(stderr,
490 "dologname: remove conffile entry\n");
491 if (conf_lookup(logname))
492 conf_replace(logname, NULL);
493 else
494 err_exitcode(1);
495 return;
496 }
497
498 /* generate combined options */
499 allopts = opts_merge(cfopts, clopts);
500
501 /* arrange for error output to be mailed if allopts includes -e */
502 if (opts_count(allopts, "e"))
503 err_mailto(opts_optarg(allopts, "e"));
504 else
505 err_mailto(NULL);
506
507 /* this implements the default rotation rules */
508 if (opts_count(allopts, "sp") == 0) {
509 if (opts_count(clopts, "v"))
510 (void) out(
511 "# using default rotate rules: -s1b -p1w\n");
512 (void) opts_set(allopts, "s", "1b");
513 (void) opts_set(allopts, "p", "1w");
514 }
515
516 /* this implements the default expiration rules */
517 if (opts_count(allopts, "ACS") == 0) {
518 if (opts_count(clopts, "v"))
519 (void) out("# using default expire rule: -C10\n");
520 (void) opts_set(allopts, "C", "10");
521 }
522
523 /* this implements the default template */
524 if (opts_count(allopts, "t") == 0) {
525 if (opts_count(clopts, "v"))
526 (void) out("# using default template: $file.$n\n");
527 (void) opts_set(allopts, "t", "$file.$n");
528 }
529
530 if (Debug) {
531 (void) fprintf(stderr, "merged opts:");
532 opts_print(allopts, stderr, NULL);
533 (void) fprintf(stderr, "\n");
534 }
535
536 /*
537 * if the conffile entry supplied log file names, then
538 * logname is NOT one of the log file names (it was just
539 * the entry name in conffile).
540 */
541 logfiles = opts_cmdargs(cfopts);
542 if (Debug) {
543 char *buf;
544 (void) fprintf(stderr, "dologname: logfiles from cfopts:\n");
545 fn_list_rewind(logfiles);
546 while ((nextfnp = fn_list_next(logfiles)) != NULL)
547 buf = fn_s(nextfnp);
548 if (buf != NULL)
549 (void) fprintf(stderr, " <%s>\n", buf);
550 }
551 if (fn_list_empty(logfiles))
552 globbedfiles = glob_glob(fnp);
553 else
554 globbedfiles = glob_glob_list(logfiles);
555
556 /* go through the list produced by glob expansion */
557 fn_list_rewind(globbedfiles);
558 while ((nextfnp = fn_list_next(globbedfiles)) != NULL)
559 if (rotatelog(nextfnp, allopts))
560 expirefiles(nextfnp, allopts);
561
562 fn_list_free(globbedfiles);
563 opts_free(allopts);
564 }
565
566
567 /* absurdly long buffer lengths for holding user/group/mode strings */
568 #define TIMESTRMAX 100
569 #define MAXATTR 100
570
571 /* rotate a log file if necessary, returns true if ok to go on to expire step */
572 static boolean_t
573 rotatelog(struct fn *fnp, struct opts *opts)
574 {
575 char *fname = fn_s(fnp);
576 struct stat stbuf;
577 char nowstr[TIMESTRMAX];
578 struct fn *recentlog = fn_new(NULL); /* for -R cmd */
579 char ownerbuf[MAXATTR];
580 char groupbuf[MAXATTR];
581 char modebuf[MAXATTR];
582 const char *owner;
583 const char *group;
584 const char *mode;
585
586 if (Debug && fname != NULL)
587 (void) fprintf(stderr, "rotatelog: fname <%s>\n", fname);
588
589 if (opts_count(opts, "p") && opts_optarg_int(opts, "p") == OPTP_NEVER)
590 return (B_TRUE); /* "-p never" forced no rotate */
591
592 /* prepare the keywords */
593 kw_init(fnp, NULL);
594 if (Debug > 1) {
595 (void) fprintf(stderr, "rotatelog keywords:\n");
596 kw_print(stderr);
597 }
598
599 if (lstat(fname, &stbuf) < 0) {
600 if (opts_count(opts, "N"))
601 return (1);
602 err(EF_WARN|EF_SYS, "%s", fname);
603 return (B_FALSE);
604 }
605
606 if ((stbuf.st_mode & S_IFMT) == S_IFLNK) {
607 err(EF_WARN, "%s is a symlink", fname);
608 return (B_FALSE);
609 }
610
611 if ((stbuf.st_mode & S_IFMT) != S_IFREG) {
612 err(EF_WARN, "%s is not a regular file", fname);
613 return (B_FALSE);
614 }
615
616 /* even if size condition is not met, this entry is "done" */
617 if (opts_count(opts, "s") &&
618 stbuf.st_size < opts_optarg_int(opts, "s")) {
619 Donenames = lut_add(Donenames, fname, "1");
620 return (B_TRUE);
621 }
622
623 /* see if age condition is present, and return if not met */
624 if (opts_count(opts, "p")) {
625 off_t when = opts_optarg_int(opts, "p");
626 struct opts *cfopts;
627
628 /* unless rotate forced by "-p now", see if period has passed */
629 if (when != OPTP_NOW) {
630 /*
631 * "when" holds the number of seconds that must have
632 * passed since the last time this log was rotated.
633 * of course, running logadm can take a little time
634 * (typically a second or two, but longer if the
635 * conffile has lots of stuff in it) and that amount
636 * of time is variable, depending on system load, etc.
637 * so we want to allow a little "slop" in the value of
638 * "when". this way, if a log should be rotated every
639 * week, and the number of seconds passed is really a
640 * few seconds short of a week, we'll go ahead and
641 * rotate the log as expected.
642 *
643 */
644 if (when >= 60 * 60)
645 when -= 59;
646
647 /*
648 * last rotation is recorded as argument to -P,
649 * but if logname isn't the same as log file name
650 * then the timestamp would be recorded on a
651 * separate line in the timestamp file. so if we
652 * haven't seen a -P already, we check to see if
653 * it is part of a specific entry for the log
654 * file name. this handles the case where the
655 * logname is "apache", it supplies a log file
656 * name like "/var/apache/logs/[a-z]*_log",
657 * which expands to multiple file names. if one
658 * of the file names is "/var/apache/logs/access_log"
659 * the the -P will be attached to a line with that
660 * logname in the timestamp file.
661 */
662 if (opts_count(opts, "P")) {
663 off_t last = opts_optarg_int(opts, "P");
664
665 /* return if not enough time has passed */
666 if (Now - last < when)
667 return (B_TRUE);
668 } else if ((cfopts = conf_opts(fname)) != NULL &&
669 opts_count(cfopts, "P")) {
670 off_t last = opts_optarg_int(cfopts, "P");
671
672 /*
673 * just checking this means this entry
674 * is now "done" if we're going through
675 * the entire conffile
676 */
677 Donenames = lut_add(Donenames, fname, "1");
678
679 /* return if not enough time has passed */
680 if (Now - last < when)
681 return (B_TRUE);
682 }
683 }
684 }
685
686 if (Debug)
687 (void) fprintf(stderr, "rotatelog: conditions met\n");
688 if (opts_count(opts, "l")) {
689 /* Change the time zone to local time zone */
690 if (putenv("TZ="))
691 err(EF_SYS, "putenv TZ");
692 tzset();
693 Now = time(0);
694
695 /* rename the log file */
696 rotateto(fnp, opts, 0, recentlog, B_FALSE);
697
698 /* Change the time zone to UTC */
699 if (putenv("TZ=UTC"))
700 err(EF_SYS, "putenv TZ");
701 tzset();
702 Now = time(0);
703 } else {
704 /* rename the log file */
705 rotateto(fnp, opts, 0, recentlog, B_FALSE);
706 }
707
708 /* determine owner, group, mode for empty log file */
709 if (opts_count(opts, "o"))
710 (void) strlcpy(ownerbuf, opts_optarg(opts, "o"), MAXATTR);
711 else {
712 (void) snprintf(ownerbuf, MAXATTR, "%ld", stbuf.st_uid);
713 }
714 owner = ownerbuf;
715 if (opts_count(opts, "g"))
716 group = opts_optarg(opts, "g");
717 else {
718 (void) snprintf(groupbuf, MAXATTR, "%ld", stbuf.st_gid);
719 group = groupbuf;
720 }
721 (void) strlcat(ownerbuf, ":", MAXATTR - strlen(ownerbuf));
722 (void) strlcat(ownerbuf, group, MAXATTR - strlen(ownerbuf));
723 if (opts_count(opts, "m"))
724 mode = opts_optarg(opts, "m");
725 else {
726 (void) snprintf(modebuf, MAXATTR,
727 "%03lo", stbuf.st_mode & 0777);
728 mode = modebuf;
729 }
730
731 /* create the empty log file */
732 docmd(opts, NULL, Touch, fname, NULL, NULL);
733 docmd(opts, NULL, Chown, owner, fname, NULL);
734 docmd(opts, NULL, Chmod, mode, fname, NULL);
735
736 /* execute post-rotation command */
737 if (opts_count(opts, "R")) {
738 struct fn *rawcmd = fn_new(opts_optarg(opts, "R"));
739 struct fn *cmd = fn_new(NULL);
740
741 kw_init(recentlog, NULL);
742 (void) kw_expand(rawcmd, cmd, 0, B_FALSE);
743 docmd(opts, "-R cmd", Sh, "-c", fn_s(cmd), NULL);
744 fn_free(rawcmd);
745 fn_free(cmd);
746 }
747 fn_free(recentlog);
748
749 /*
750 * add "after" command to list of after commands. we also record
751 * the email address, if any, where the error output of the after
752 * command should be sent. if the after command is already on
753 * our list, add the email addr to the list the email addrs for
754 * that command (the after command will only be executed once,
755 * so the error output gets mailed to every address we've come
756 * across associated with this command).
757 */
758 if (opts_count(opts, "a")) {
759 const char *cmd = opts_optarg(opts, "a");
760 struct lut *addrs = (struct lut *)lut_lookup(Aftercmds, cmd);
761 if (opts_count(opts, "e"))
762 addrs = lut_add(addrs, opts_optarg(opts, "e"), NULL);
763 Aftercmds = lut_add(Aftercmds, opts_optarg(opts, "a"), addrs);
764 }
765
766 /* record the rotation date */
767 (void) strftime(nowstr, sizeof (nowstr),
768 "%a %b %e %T %Y", gmtime(&Now));
769 if (opts_count(opts, "v") && fname != NULL)
770 (void) out("# recording rotation date %s for %s\n",
771 nowstr, fname);
772 conf_set(fname, "P", STRDUP(nowstr));
773 Donenames = lut_add(Donenames, fname, "1");
774 return (B_TRUE);
775 }
776
777 /* rotate files "up" according to current template */
778 static void
779 rotateto(struct fn *fnp, struct opts *opts, int n, struct fn *recentlog,
780 boolean_t isgz)
781 {
782 struct fn *template = fn_new(opts_optarg(opts, "t"));
783 struct fn *newfile = fn_new(NULL);
784 struct fn *dirname;
785 int hasn;
786 struct stat stbuf;
787 char *buf1;
788 char *buf2;
789
790 /* expand template to figure out new filename */
791 hasn = kw_expand(template, newfile, n, isgz);
792
793 buf1 = fn_s(fnp);
794 buf2 = fn_s(newfile);
795
796 if (Debug)
797 if (buf1 != NULL && buf2 != NULL) {
798 (void) fprintf(stderr, "rotateto: %s -> %s (%d)\n",
799 buf1, buf2, n);
800 }
801 /* if filename is there already, rotate "up" */
802 if (hasn && lstat(buf2, &stbuf) != -1)
803 rotateto(newfile, opts, n + 1, recentlog, isgz);
804 else if (hasn && opts_count(opts, "z")) {
805 struct fn *gzfnp = fn_dup(newfile);
806 /*
807 * since we're compressing old files, see if we
808 * about to rotate into one.
809 */
810 fn_puts(gzfnp, ".gz");
811 if (lstat(fn_s(gzfnp), &stbuf) != -1)
812 rotateto(gzfnp, opts, n + 1, recentlog, B_TRUE);
813 fn_free(gzfnp);
814 }
815
816 /* first time through run "before" cmd if not run already */
817 if (n == 0 && opts_count(opts, "b")) {
818 const char *cmd = opts_optarg(opts, "b");
819
820 if (lut_lookup(Beforecmds, cmd) == NULL) {
821 docmd(opts, "-b cmd", Sh, "-c", cmd, NULL);
822 Beforecmds = lut_add(Beforecmds, cmd, "1");
823 }
824 }
825
826 /* ensure destination directory exists */
827 dirname = fn_dirname(newfile);
828 docmd(opts, "verify directory exists", Mkdir, "-p",
829 fn_s(dirname), NULL);
830 fn_free(dirname);
831
832 /* do the rename */
833 if (n == 0 && opts_count(opts, "c") != NULL) {
834 docopytruncate(opts, fn_s(fnp), fn_s(newfile));
835 } else if (n == 0 && opts_count(opts, "M")) {
836 struct fn *rawcmd = fn_new(opts_optarg(opts, "M"));
837 struct fn *cmd = fn_new(NULL);
838
839 /* use specified command to mv the log file */
840 kw_init(fnp, newfile);
841 (void) kw_expand(rawcmd, cmd, 0, B_FALSE);
842 docmd(opts, "-M cmd", Sh, "-c", fn_s(cmd), NULL);
843 fn_free(rawcmd);
844 fn_free(cmd);
845 } else
846 /* common case: we call "mv" to handle the actual rename */
847 docmd(opts, "rotate log file", Mv, "-f",
848 fn_s(fnp), fn_s(newfile));
849
850 /* first time through, gather interesting info for caller */
851 if (n == 0)
852 fn_renew(recentlog, fn_s(newfile));
853 }
854
855 /* expire phase of logname processing */
856 static void
857 expirefiles(struct fn *fnp, struct opts *opts)
858 {
859 char *fname = fn_s(fnp);
860 struct fn *template;
861 struct fn *pattern;
862 struct fn_list *files;
863 struct fn *nextfnp;
864 off_t count;
865 off_t size;
866
867 if (Debug && fname != NULL)
868 (void) fprintf(stderr, "expirefiles: fname <%s>\n", fname);
869
870 /* return if no potential expire conditions */
871 if (opts_count(opts, "zAS") == 0 && opts_optarg_int(opts, "C") == 0)
872 return;
873
874 kw_init(fnp, NULL);
875 if (Debug > 1) {
876 (void) fprintf(stderr, "expirefiles keywords:\n");
877 kw_print(stderr);
878 }
879
880 /* see if pattern was supplied by user */
881 if (opts_count(opts, "T")) {
882 template = fn_new(opts_optarg(opts, "T"));
883 pattern = glob_to_reglob(template);
884 } else {
885 /* nope, generate pattern based on rotation template */
886 template = fn_new(opts_optarg(opts, "t"));
887 pattern = fn_new(NULL);
888 (void) kw_expand(template, pattern, -1,
889 opts_count(opts, "z") != 0);
890 }
891
892 /* match all old log files (hopefully not any others as well!) */
893 files = glob_reglob(pattern);
894
895 if (Debug) {
896 char *buf;
897
898 buf = fn_s(pattern);
899 if (buf != NULL) {
900 (void) fprintf(stderr, "expirefiles: pattern <%s>\n",
901 buf);
902 }
903 fn_list_rewind(files);
904 while ((nextfnp = fn_list_next(files)) != NULL)
905 buf = fn_s(nextfnp);
906 if (buf != NULL)
907 (void) fprintf(stderr, " <%s>\n", buf);
908 }
909
910 /* see if count causes expiration */
911 if ((count = opts_optarg_int(opts, "C")) > 0) {
912 int needexpire = fn_list_count(files) - count;
913
914 if (Debug)
915 (void) fprintf(stderr, "expirefiles: needexpire %d\n",
916 needexpire);
917
918 while (needexpire > 0 &&
919 ((nextfnp = fn_list_popoldest(files)) != NULL)) {
920 dorm(opts, "expire by count rule", nextfnp);
921 fn_free(nextfnp);
922 needexpire--;
923 }
924 }
925
926 /* see if total size causes expiration */
927 if (opts_count(opts, "S") && (size = opts_optarg_int(opts, "S")) > 0) {
928 while (fn_list_totalsize(files) > size &&
929 ((nextfnp = fn_list_popoldest(files)) != NULL)) {
930 dorm(opts, "expire by size rule", nextfnp);
931 fn_free(nextfnp);
932 }
933 }
934
935 /* see if age causes expiration */
936 if (opts_count(opts, "A")) {
937 int mtime = (int)time(0) - (int)opts_optarg_int(opts, "A");
938
939 while ((nextfnp = fn_list_popoldest(files)) != NULL) {
940 if (fn_getstat(nextfnp)->st_mtime < mtime) {
941 dorm(opts, "expire by age rule", nextfnp);
942 fn_free(nextfnp);
943 } else {
944 fn_list_addfn(files, nextfnp);
945 break;
946 }
947 }
948 }
949
950 /* record old log files to be gzip'ed according to -z count */
951 if (opts_count(opts, "z")) {
952 int zcount = (int)opts_optarg_int(opts, "z");
953 int fcount = fn_list_count(files);
954
955 while (fcount > zcount &&
956 (nextfnp = fn_list_popoldest(files)) != NULL) {
957 if (!fn_isgz(nextfnp)) {
958 /*
959 * Don't gzip the old log file yet -
960 * it takes too long. Just remember that we
961 * need to gzip.
962 */
963 if (Debug) {
964 (void) fprintf(stderr,
965 "will compress %s count %d\n",
966 fn_s(nextfnp), fcount);
967 }
968 Gzipnames = lut_add(Gzipnames,
969 fn_s(nextfnp), "1");
970 }
971 fn_free(nextfnp);
972 fcount--;
973 }
974 }
975
976 fn_free(template);
977 fn_list_free(files);
978 }
979
980 /* execute a command to remove an expired log file */
981 static void
982 dorm(struct opts *opts, const char *msg, struct fn *fnp)
983 {
984 if (opts_count(opts, "E")) {
985 struct fn *rawcmd = fn_new(opts_optarg(opts, "E"));
986 struct fn *cmd = fn_new(NULL);
987
988 /* user supplied cmd, expand $file */
989 kw_init(fnp, NULL);
990 (void) kw_expand(rawcmd, cmd, 0, B_FALSE);
991 docmd(opts, msg, Sh, "-c", fn_s(cmd), NULL);
992 fn_free(rawcmd);
993 fn_free(cmd);
994 } else
995 docmd(opts, msg, Rm, "-f", fn_s(fnp), NULL);
996 Gzipnames = lut_add(Gzipnames, fn_s(fnp), NULL);
997 }
998
999 /* execute a command, producing -n and -v output as necessary */
1000 static void
1001 docmd(struct opts *opts, const char *msg, const char *cmd,
1002 const char *arg1, const char *arg2, const char *arg3)
1003 {
1004 int pid;
1005 int errpipe[2];
1006
1007 /* print info about command if necessary */
1008 if (opts_count(opts, "vn")) {
1009 const char *simplecmd;
1010
1011 if ((simplecmd = strrchr(cmd, '/')) == NULL)
1012 simplecmd = cmd;
1013 else
1014 simplecmd++;
1015 (void) out("%s", simplecmd);
1016 if (arg1)
1017 (void) out(" %s", arg1);
1018 if (arg2)
1019 (void) out(" %s", arg2);
1020 if (arg3)
1021 (void) out(" %s", arg3);
1022 if (msg)
1023 (void) out(" # %s", msg);
1024 (void) out("\n");
1025 }
1026
1027 if (opts_count(opts, "n"))
1028 return; /* -n means don't really do it */
1029
1030 /*
1031 * run the cmd and see if it failed. this function is *not* a
1032 * generic command runner -- we depend on some knowledge we
1033 * have about the commands we run. first of all, we expect
1034 * errors to spew something to stderr, and that something is
1035 * typically short enough to fit into a pipe so we can wait()
1036 * for the command to complete and then fetch the error text
1037 * from the pipe. we also expect the exit codes to make sense.
1038 * notice also that we only allow a command name which is an
1039 * absolute pathname, and two args must be supplied (the
1040 * second may be NULL, or they may both be NULL).
1041 */
1042 if (pipe(errpipe) < 0)
1043 err(EF_SYS, "pipe");
1044
1045 if ((pid = fork()) < 0)
1046 err(EF_SYS, "fork");
1047 else if (pid) {
1048 int wstat;
1049 int count;
1050
1051 /* parent */
1052 (void) close(errpipe[1]);
1053 if (waitpid(pid, &wstat, 0) < 0)
1054 err(EF_SYS, "waitpid");
1055
1056 /* check for stderr output */
1057 if (ioctl(errpipe[0], FIONREAD, &count) >= 0 && count) {
1058 err(EF_WARN, "command failed: %s%s%s%s%s%s%s",
1059 cmd,
1060 (arg1) ? " " : "",
1061 (arg1) ? arg1 : "",
1062 (arg2) ? " " : "",
1063 (arg2) ? arg2 : "",
1064 (arg3) ? " " : "",
1065 (arg3) ? arg3 : "");
1066 err_fromfd(errpipe[0]);
1067 } else if (WIFSIGNALED(wstat))
1068 err(EF_WARN,
1069 "command died, signal %d: %s%s%s%s%s%s%s",
1070 WTERMSIG(wstat),
1071 cmd,
1072 (arg1) ? " " : "",
1073 (arg1) ? arg1 : "",
1074 (arg2) ? " " : "",
1075 (arg2) ? arg2 : "",
1076 (arg3) ? " " : "",
1077 (arg3) ? arg3 : "");
1078 else if (WIFEXITED(wstat) && WEXITSTATUS(wstat))
1079 err(EF_WARN,
1080 "command error, exit %d: %s%s%s%s%s%s%s",
1081 WEXITSTATUS(wstat),
1082 cmd,
1083 (arg1) ? " " : "",
1084 (arg1) ? arg1 : "",
1085 (arg2) ? " " : "",
1086 (arg2) ? arg2 : "",
1087 (arg3) ? " " : "",
1088 (arg3) ? arg3 : "");
1089
1090 (void) close(errpipe[0]);
1091 } else {
1092 /* child */
1093 (void) dup2(errpipe[1], fileno(stderr));
1094 (void) close(errpipe[0]);
1095 (void) execl(cmd, cmd, arg1, arg2, arg3, 0);
1096 perror(cmd);
1097 _exit(1);
1098 }
1099 }
1100
1101 /* do internal atomic file copy and truncation */
1102 static void
1103 docopytruncate(struct opts *opts, const char *file, const char *file_copy)
1104 {
1105 int fi, fo;
1106 char buf[128 * 1024];
1107 struct stat s;
1108 struct utimbuf times;
1109 off_t written = 0, rem, last = 0, thresh = 1024 * 1024;
1110 ssize_t len;
1111
1112 /* print info if necessary */
1113 if (opts_count(opts, "vn") != NULL) {
1114 (void) out("# log rotation via atomic copy and truncation"
1115 " (-c flag):\n");
1116 (void) out("# copy %s to %s\n", file, file_copy);
1117 (void) out("# truncate %s\n", file);
1118 }
1119
1120 if (opts_count(opts, "n"))
1121 return; /* -n means don't really do it */
1122
1123 /* open log file to be rotated and remember its chmod mask */
1124 if ((fi = open(file, O_RDWR)) < 0) {
1125 err(EF_SYS, "cannot open file %s", file);
1126 return;
1127 }
1128
1129 if (fstat(fi, &s) < 0) {
1130 err(EF_SYS, "cannot access: %s", file);
1131 (void) close(fi);
1132 return;
1133 }
1134
1135 /* create new file for copy destination with correct attributes */
1136 if ((fo = open(file_copy, O_CREAT|O_TRUNC|O_WRONLY, s.st_mode)) < 0) {
1137 err(EF_SYS, "cannot create file: %s", file_copy);
1138 (void) close(fi);
1139 return;
1140 }
1141
1142 (void) fchown(fo, s.st_uid, s.st_gid);
1143
1144 /*
1145 * Now we'll loop, reading the log file and writing it to our copy
1146 * until the bytes remaining are beneath our atomicity threshold -- at
1147 * which point we'll lock the file and copy the remainder atomically.
1148 * The body of this loop is non-atomic with respect to writers, the
1149 * rationale being that total atomicity (that is, locking the file for
1150 * the entire duration of the copy) comes at too great a cost for a
1151 * large log file, as the writer (i.e., the daemon whose log is being
1152 * rolled) can be blocked for an unacceptable duration. (For one
1153 * particularly loquacious daemon, this period was observed to be
1154 * several minutes in length -- a time so long that it induced
1155 * additional failures in dependent components.) Note that this means
1156 * that if the log file is not always appended to -- if it is opened
1157 * without O_APPEND or otherwise truncated outside of logadm -- this
1158 * will result in our log snapshot being incorrect. But of course, in
1159 * either of these cases, the use of logadm at all is itself
1160 * suspect...
1161 */
1162 do {
1163 if (fstat(fi, &s) < 0) {
1164 err(EF_SYS, "cannot stat: %s", file);
1165 (void) close(fi);
1166 (void) close(fo);
1167 (void) remove(file_copy);
1168 return;
1169 }
1170
1171 if ((rem = s.st_size - written) < thresh) {
1172 if (rem >= 0)
1173 break;
1174
1175 /*
1176 * If the file became smaller, something fishy is going
1177 * on; we'll truncate our copy, reset our seek offset
1178 * and break into the atomic copy.
1179 */
1180 (void) ftruncate(fo, 0);
1181 (void) lseek(fo, 0, SEEK_SET);
1182 (void) lseek(fi, 0, SEEK_SET);
1183 break;
1184 }
1185
1186 if (written != 0 && rem > last) {
1187 /*
1188 * We're falling behind -- this file is getting bigger
1189 * faster than we're able to write it; break out and
1190 * lock the file to block the writer.
1191 */
1192 break;
1193 }
1194
1195 last = rem;
1196
1197 while (rem > 0) {
1198 if ((len = read(fi, buf, MIN(sizeof (buf), rem))) <= 0)
1199 break;
1200
1201 if (write(fo, buf, len) == len) {
1202 rem -= len;
1203 written += len;
1204 continue;
1205 }
1206
1207 err(EF_SYS, "cannot write into file %s", file_copy);
1208 (void) close(fi);
1209 (void) close(fo);
1210 (void) remove(file_copy);
1211 return;
1212 }
1213 } while (len >= 0);
1214
1215 /* lock log file so that nobody can write into it before we are done */
1216 if (fchmod(fi, s.st_mode|S_ISGID) < 0)
1217 err(EF_SYS, "cannot set mandatory lock bit for: %s", file);
1218
1219 if (lockf(fi, F_LOCK, 0) == -1)
1220 err(EF_SYS, "cannot lock file %s", file);
1221
1222 /* do atomic copy and truncation */
1223 while ((len = read(fi, buf, sizeof (buf))) > 0)
1224 if (write(fo, buf, len) != len) {
1225 err(EF_SYS, "cannot write into file %s", file_copy);
1226 (void) lockf(fi, F_ULOCK, 0);
1227 (void) fchmod(fi, s.st_mode);
1228 (void) close(fi);
1229 (void) close(fo);
1230 (void) remove(file_copy);
1231 return;
1232 }
1233
1234 (void) ftruncate(fi, 0);
1235
1236 /* unlock log file */
1237 if (lockf(fi, F_ULOCK, 0) == -1)
1238 err(EF_SYS, "cannot unlock file %s", file);
1239
1240 if (fchmod(fi, s.st_mode) < 0)
1241 err(EF_SYS, "cannot reset mandatory lock bit for: %s", file);
1242
1243 (void) close(fi);
1244 (void) close(fo);
1245
1246 /* keep times from original file */
1247 times.actime = s.st_atime;
1248 times.modtime = s.st_mtime;
1249 (void) utime(file_copy, ×);
1250 }