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, &times);
1250 }