usr/src/cmd/cron/at_cmd.c

   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 /*
  23  * Copyright (c) 2011 Gary Mills
  24  *
  25  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  26  * Use is subject to license terms.
  27  * Copyright (c) 2016 by Delphix. All rights reserved.
  28  */
  29
  30 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  31 /*        All Rights Reserved   */
  32
  33 #include <sys/resource.h>
  34 #include <sys/stat.h>
  35 #include <sys/types.h>
  36
  37 #include <dirent.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <fcntl.h>
  41 #include <pwd.h>
  42 #include <stdio.h>
  43 #include <ctype.h>
  44 #include <time.h>
  45 #include <signal.h>
  46 #include <errno.h>
  47 #include <limits.h>
  48 #include <ulimit.h>
  49 #include <unistd.h>
  50 #include <locale.h>
  51 #include <libintl.h>
  52 #include <tzfile.h>
  53 #include <project.h>
  54 #include <paths.h>
  55
  56 #include "cron.h"
  57
  58 #define TMPFILE         "_at" /* prefix for temporary files     */
  59 /*
  60  * Mode for creating files in ATDIR.
  61  * Setuid bit on so that if an owner of a file gives that file
  62  * away to someone else, the setuid bit will no longer be set.
  63  * If this happens, atrun will not execute the file
  64  */
  65 #define ATMODE          (S_ISUID | S_IRUSR | S_IRGRP | S_IROTH)
  66 #define ROOT            0       /* user-id of super-user */
  67 #define MAXTRYS         100     /* max trys to create at job file */
  68
  69 #define BADTIME         "bad time specification"
  70 #define BADQUEUE        "queue name must be a single character a-z"
  71 #define NOTCQUEUE       "queue c is reserved for cron entries"
  72 #define BADSHELL        "because your login shell isn't /usr/bin/sh,"\
  73                         "you can't use at"
  74 #define WARNSHELL       "commands will be executed using %s\n"
  75 #define CANTCD          "can't change directory to the at directory"
  76 #define CANTCHOWN       "can't change the owner of your job to you"
  77 #define CANTCHUID       "can't change user identifier"
  78 #define CANTCREATE      "can't create a job for you"
  79 #define INVALIDUSER     "you are not a valid user (no entry in /etc/passwd)"
  80 #define NOOPENDIR       "can't open the at directory"
  81 #define NOTALLOWED      "you are not authorized to use at.  Sorry."
  82 #define USAGE\
  83         "usage: at [-c|-k|-s] [-m] [-f file] [-p project] [-q queuename] "\
  84             "-t time\n"\
  85         "       at [-c|-k|-s] [-m] [-f file] [-p project] [-q queuename] "\
  86             "timespec\n"\
  87         "       at -l [-p project] [-q queuename] [at_job_id...]\n"\
  88         "       at -r at_job_id ...\n"
  89
  90 #define FORMAT          "%a %b %e %H:%M:%S %Y"
  91
  92 static int leap(int);
  93 static int atoi_for2(char *);
  94 static int check_queue(char *, int);
  95 static int list_jobs(int, char **, int, int);
  96 static int remove_jobs(int, char **, char *);
  97 static void usage(void);
  98 static void catch(int);
  99 static void copy(char *, FILE *, int);
 100 static void atime(struct tm *, struct tm *);
 101 static int not_this_project(char *);
 102 static char *mkjobname(time_t);
 103 static time_t parse_time(char *);
 104 static time_t gtime(struct tm *);
 105 static void escapestr(const char *);
 106 void atabort(char *)__NORETURN;
 107 void yyerror(void);
 108 extern int yyparse(void);
 109
 110 extern void     audit_at_delete(char *, char *, int);
 111 extern int      audit_at_create(char *, int);
 112 extern int      audit_cron_is_anc_name(char *);
 113 extern int      audit_cron_delete_anc_file(char *, char *);
 114
 115 /*
 116  * Error in getdate(3G)
 117  */
 118 static char     *errlist[] = {
 119 /* 0 */         "",
 120 /* 1 */ "getdate: The DATEMSK environment variable is not set",
 121 /* 2 */ "getdate: Error on \"open\" of the template file",
 122 /* 3 */ "getdate: Error on \"stat\" of the template file",
 123 /* 4 */ "getdate: The template file is not a regular file",
 124 /* 5 */ "getdate: An error is encountered while reading the template",
 125 /* 6 */ "getdate: Malloc(3C) failed",
 126 /* 7 */ "getdate: There is no line in the template that matches the input",
 127 /* 8 */ "getdate: Invalid input specification"
 128 };
 129
 130 int             gmtflag = 0;
 131 int             mday[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 132 uid_t           user;
 133 struct  tm      *tp, at, rt;
 134 static int      cshflag         = 0;
 135 static int      kshflag         = 0;
 136 static int      shflag          = 0;
 137 static int      mflag           = 0;
 138 static int      pflag           = 0;
 139 static char     *Shell;
 140 static char     *tfname;
 141 static char     pname[80];
 142 static char     pname1[80];
 143 static short    jobtype = ATEVENT;      /* set to 1 if batch job */
 144 extern char     *argp;
 145 extern int      per_errno;
 146 static projid_t project;
 147
 148 int
 149 main(int argc, char **argv)
 150 {
 151         FILE            *inputfile;
 152         int             i, fd;
 153         int             try = 0;
 154         int             fflag = 0;
 155         int             lflag = 0;
 156         int             qflag = 0;
 157         int             rflag = 0;
 158         int             tflag = 0;
 159         int             c;
 160         int             tflen;
 161         char            *file;
 162         char            *login;
 163         char            *job;
 164         char            *jobfile = NULL; /* file containing job to be run */
 165         char            argpbuf[LINE_MAX], timebuf[80];
 166         time_t          now;
 167         time_t          when = 0;
 168         struct  tm      *ct;
 169         char            *proj;
 170         struct project  prj, *pprj;
 171         char            mybuf[PROJECT_BUFSZ];
 172         char            ipbuf[PROJECT_BUFSZ];
 173
 174         (void) setlocale(LC_ALL, "");
 175 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
 176 #define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
 177 #endif
 178         (void) textdomain(TEXT_DOMAIN);
 179
 180         user = getuid();
 181         login = getuser(user);
 182         if (login == NULL) {
 183                 if (per_errno == 2)
 184                         atabort(BADSHELL);
 185                 else
 186                         atabort(INVALIDUSER);
 187         }
 188
 189         if (!allowed(login, ATALLOW, ATDENY))
 190                 atabort(NOTALLOWED);
 191
 192         while ((c = getopt(argc, argv, "cklmsrf:p:q:t:")) != EOF)
 193                 switch (c) {
 194                         case 'c':
 195                                 cshflag++;
 196                                 break;
 197                         case 'f':
 198                                 fflag++;
 199                                 jobfile = optarg;
 200                                 break;
 201                         case 'k':
 202                                 kshflag++;
 203                                 break;
 204                         case 'l':
 205                                 lflag++;
 206                                 break;
 207                         case 'm':
 208                                 mflag++;
 209                                 break;
 210                         case 'p':
 211                                 proj = optarg;
 212                                 pprj = &prj;
 213                                 if ((pprj = getprojbyname(proj, pprj,
 214                                     (void *)&mybuf, sizeof (mybuf))) != NULL) {
 215                                         project = pprj->pj_projid;
 216                                         if (inproj(login, pprj->pj_name,
 217                                             (void *)&ipbuf, sizeof (ipbuf)))
 218                                                 pflag++;
 219                                         else {
 220                                                 (void) fprintf(stderr,
 221                                                     gettext("at: user %s is "
 222                                                     "not a member of "
 223                                                     "project %s (%d)\n"),
 224                                                     login, pprj->pj_name,
 225                                                     project);
 226                                                 exit(2);
 227                                         }
 228                                         break;
 229                                 }
 230                                 pprj = &prj;
 231                                 if (isdigit(proj[0]) &&
 232                                     (pprj = getprojbyid(atoi(proj), pprj,
 233                                     (void *)&mybuf, sizeof (mybuf))) != NULL) {
 234                                         project = pprj->pj_projid;
 235                                         if (inproj(login, pprj->pj_name,
 236                                             (void *)&ipbuf, sizeof (ipbuf)))
 237                                                 pflag++;
 238                                         else {
 239                                                 (void) fprintf(stderr,
 240                                                     gettext("at: user %s is "
 241                                                     "not a member of "
 242                                                     "project %s (%d)\n"),
 243                                                     login, pprj->pj_name,
 244                                                     project);
 245                                                 exit(2);
 246                                         }
 247                                         break;
 248                                 }
 249                                 (void) fprintf(stderr, gettext("at: project "
 250                                     "%s not found.\n"), proj);
 251                                 exit(2);
 252                                 break;
 253                         case 'q':
 254                                 qflag++;
 255                                 if (optarg[1] != '\0')
 256                                         atabort(BADQUEUE);
 257                                 jobtype = *optarg - 'a';
 258                                 if ((jobtype < 0) || (jobtype > 25))
 259                                         atabort(BADQUEUE);
 260                                 if (jobtype == 2)
 261                                         atabort(NOTCQUEUE);
 262                                 break;
 263                         case 'r':
 264                                 rflag++;
 265                                 break;
 266                         case 's':
 267                                 shflag++;
 268                                 break;
 269                         case 't':
 270                                 tflag++;
 271                                 when = parse_time(optarg);
 272                                 break;
 273                         default:
 274                                 usage();
 275                 }
 276
 277         argc -= optind;
 278         argv += optind;
 279
 280         if (lflag + rflag > 1)
 281                 usage();
 282
 283         if (lflag) {
 284                 if (cshflag || kshflag || shflag || mflag ||
 285                     fflag || tflag || rflag)
 286                         usage();
 287                 return (list_jobs(argc, argv, qflag, jobtype));
 288         }
 289
 290         if (rflag) {
 291                 if (cshflag || kshflag || shflag || mflag ||
 292                     fflag || tflag || qflag)
 293                         usage();
 294                 return (remove_jobs(argc, argv, login));
 295         }
 296
 297         if ((argc + tflag == 0) && (jobtype != BATCHEVENT))
 298                 usage();
 299
 300         if (cshflag + kshflag + shflag > 1)
 301                 atabort("ambiguous shell request");
 302
 303         time(&now);
 304
 305         if (jobtype == BATCHEVENT)
 306                 when = now;
 307
 308         if (when == 0) { /* figure out what time to run the job */
 309                 int     argplen = sizeof (argpbuf) - 1;
 310
 311                 argpbuf[0] = '\0';
 312                 argp = argpbuf;
 313                 i = 0;
 314                 while (i < argc) {
 315                         /* guard against buffer overflow */
 316                         argplen -= strlen(argv[i]) + 1;
 317                         if (argplen < 0)
 318                                 atabort(BADTIME);
 319
 320                         strcat(argp, argv[i]);
 321                         strcat(argp, " ");
 322                         i++;
 323                 }
 324                 if ((file = getenv("DATEMSK")) == 0 || file[0] == '\0') {
 325                         tp = localtime(&now);
 326                         /*
 327                          * Fix for 1047182 - we have to let yyparse
 328                          * check bounds on mday[] first, then fixup
 329                          * the leap year case.
 330                          */
 331                         yyparse();
 332
 333                         mday[1] = 28 + leap(at.tm_year);
 334
 335                         if (at.tm_mday > mday[at.tm_mon])
 336                                 atabort("bad date");
 337
 338                         atime(&at, &rt);
 339                         when = gtime(&at);
 340                         if (!gmtflag) {
 341                                 when += timezone;
 342                                 if (localtime(&when)->tm_isdst)
 343                                         when -= (timezone-altzone);
 344                         }
 345                 } else {        /*   DATEMSK is set  */
 346                         if ((ct = getdate(argpbuf)) == NULL)
 347                                 atabort(errlist[getdate_err]);
 348                         else
 349                                 when = mktime(ct);
 350                 }
 351         }
 352
 353         if (when < now) /* time has already past */
 354                 atabort("too late");
 355
 356         tflen = strlen(ATDIR) + 1 + strlen(TMPFILE) +
 357             10 + 1; /* 10 for an INT_MAX pid */
 358         tfname = xmalloc(tflen);
 359         snprintf(tfname, tflen, "%s/%s%d", ATDIR, TMPFILE, getpid());
 360
 361         /* catch INT, HUP, TERM and QUIT signals */
 362         if (signal(SIGINT, catch) == SIG_IGN)
 363                 signal(SIGINT, SIG_IGN);
 364         if (signal(SIGHUP, catch) == SIG_IGN)
 365                 signal(SIGHUP, SIG_IGN);
 366         if (signal(SIGQUIT, catch) == SIG_IGN)
 367                 signal(SIGQUIT, SIG_IGN);
 368         if (signal(SIGTERM, catch) == SIG_IGN)
 369                 signal(SIGTERM, SIG_IGN);
 370         if ((fd = open(tfname, O_CREAT|O_EXCL|O_WRONLY, ATMODE)) < 0)
 371                 atabort(CANTCREATE);
 372         if (chown(tfname, user, getgid()) == -1) {
 373                 unlink(tfname);
 374                 atabort(CANTCHOWN);
 375         }
 376         close(1);
 377         dup(fd);
 378         close(fd);
 379         sprintf(pname, "%s", PROTO);
 380         sprintf(pname1, "%s.%c", PROTO, 'a'+jobtype);
 381
 382         /*
 383          * Open the input file with the user's permissions.
 384          */
 385         if (jobfile != NULL) {
 386                 if ((seteuid(user) < 0) ||
 387                     (inputfile = fopen(jobfile, "r")) == NULL) {
 388                         unlink(tfname);
 389                         fprintf(stderr, "at: %s: %s\n", jobfile, errmsg(errno));
 390                         exit(1);
 391                 }
 392                 else
 393                         seteuid(0);
 394         } else
 395                 inputfile = stdin;
 396
 397         copy(jobfile, inputfile, when);
 398         while (rename(tfname, job = mkjobname(when)) == -1) {
 399                 sleep(1);
 400                 if (++try > MAXTRYS / 10) {
 401                         unlink(tfname);
 402                         atabort(CANTCREATE);
 403                 }
 404         }
 405         unlink(tfname);
 406         if (audit_at_create(job, 0))
 407                 atabort(CANTCREATE);
 408
 409         cron_sendmsg(ADD, login, strrchr(job, '/')+1, AT);
 410         if (per_errno == 2)
 411                 fprintf(stderr, gettext(WARNSHELL), Shell);
 412         cftime(timebuf, FORMAT, &when);
 413         fprintf(stderr, gettext("job %s at %s\n"),
 414             strrchr(job, '/')+1, timebuf);
 415         if (when - MINUTE < HOUR)
 416                 fprintf(stderr, gettext(
 417                     "at: this job may not be executed at the proper time.\n"));
 418         return (0);
 419 }
 420
 421
 422 static char *
 423 mkjobname(t)
 424 time_t t;
 425 {
 426         int i, fd;
 427         char *name;
 428
 429         name = xmalloc(200);
 430         for (i = 0; i < MAXTRYS; i++) {
 431                 sprintf(name, "%s/%ld.%c", ATDIR, t, 'a'+jobtype);
 432                 /* fix for 1099183, 1116833 - create file here, avoid race */
 433                 if ((fd = open(name, O_CREAT | O_EXCL, ATMODE)) > 0) {
 434                         close(fd);
 435                         return (name);
 436                 }
 437                 t += 1;
 438         }
 439         atabort("queue full");
 440         /* NOTREACHED */
 441 }
 442
 443
 444 static void
 445 catch(int x)
 446 {
 447         unlink(tfname);
 448         exit(1);
 449 }
 450
 451
 452 void
 453 atabort(msg)
 454 char *msg;
 455 {
 456         fprintf(stderr, "at: %s\n", gettext(msg));
 457
 458         exit(1);
 459 }
 460
 461 int
 462 yywrap(void)
 463 {
 464         return (1);
 465 }
 466
 467 void
 468 yyerror(void)
 469 {
 470         atabort(BADTIME);
 471 }
 472
 473 /*
 474  * add time structures logically
 475  */
 476 static void
 477 atime(struct tm *a, struct tm *b)
 478 {
 479         if ((a->tm_sec += b->tm_sec) >= 60) {
 480                 b->tm_min += a->tm_sec / 60;
 481                 a->tm_sec %= 60;
 482         }
 483         if ((a->tm_min += b->tm_min) >= 60) {
 484                 b->tm_hour += a->tm_min / 60;
 485                 a->tm_min %= 60;
 486         }
 487         if ((a->tm_hour += b->tm_hour) >= 24) {
 488                 b->tm_mday += a->tm_hour / 24;
 489                 a->tm_hour %= 24;
 490         }
 491         a->tm_year += b->tm_year;
 492         if ((a->tm_mon += b->tm_mon) >= 12) {
 493                 a->tm_year += a->tm_mon / 12;
 494                 a->tm_mon %= 12;
 495         }
 496         a->tm_mday += b->tm_mday;
 497         mday[1] = 28 + leap(a->tm_year);
 498         while (a->tm_mday > mday[a->tm_mon]) {
 499                 a->tm_mday -= mday[a->tm_mon++];
 500                 if (a->tm_mon > 11) {
 501                         a->tm_mon = 0;
 502                         mday[1] = 28 + leap(++a->tm_year);
 503                 }
 504         }
 505
 506 }
 507
 508 static int
 509 leap(int year)
 510 {
 511         return (isleap(year + TM_YEAR_BASE));
 512 }
 513
 514 /*
 515  * return time from time structure
 516  */
 517 static time_t
 518 gtime(tptr)
 519 struct  tm *tptr;
 520 {
 521         int i;
 522         long    tv;
 523         int     dmsize[12] =
 524             {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 525
 526
 527         tv = 0;
 528         for (i = 1970; i != tptr->tm_year+TM_YEAR_BASE; i++)
 529                 tv += (365 + isleap(i));
 530                 /*
 531                  * We call isleap since leap() adds
 532                  * 1900 onto any value passed
 533                  */
 534
 535         if (!leap(tptr->tm_year) && at.tm_mday == 29 && at.tm_mon == 1)
 536                 atabort("bad date - not a leap year");
 537
 538         if ((leap(tptr->tm_year)) && tptr->tm_mon >= 2)
 539                 ++tv;
 540
 541         for (i = 0; i < tptr->tm_mon; ++i)
 542                 tv += dmsize[i];
 543         tv += tptr->tm_mday - 1;
 544         tv = 24 * tv + tptr->tm_hour;
 545         tv = 60 * tv + tptr->tm_min;
 546         tv = 60 * tv + tptr->tm_sec;
 547         return (tv);
 548 }
 549
 550 /*
 551  * Escape a string to be used inside the job shell script.
 552  */
 553 static void
 554 escapestr(const char *str)
 555 {
 556         char c;
 557         (void) putchar('\'');
 558         while ((c = *str++) != '\0') {
 559                 if (c != '\'')
 560                         (void) putchar(c);
 561                 else
 562                         (void) fputs("'\\''", stdout); /* ' -> '\'' */
 563         }
 564         (void) putchar('\'');
 565 }
 566
 567 /*
 568  * make job file from proto + stdin
 569  */
 570 static void
 571 copy(char *jobfile, FILE *inputfile, int when)
 572 {
 573         int c;
 574         FILE *pfp;
 575         char *shell;
 576         char    dirbuf[PATH_MAX + 1];
 577         char    line[LINE_MAX];
 578         char **ep;
 579         mode_t um;
 580         char *val;
 581         extern char **environ;
 582         uid_t realusr, effeusr;
 583         int ttyinput;
 584         int ulimit_flag = 0;
 585         struct rlimit rlp;
 586         struct project prj, *pprj;
 587         char pbuf[PROJECT_BUFSZ];
 588         char pbuf2[PROJECT_BUFSZ];
 589         char *user;
 590
 591         /*
 592          * Fix for 1099381:
 593          * If the inputfile is from a tty, then turn on prompting, and
 594          * put out a prompt now, instead of waiting for a lot of file
 595          * activity to complete.
 596          */
 597         ttyinput = isatty(fileno(inputfile));
 598         if (ttyinput) {
 599                 fputs("at> ", stderr);
 600                 fflush(stderr);
 601         }
 602
 603         /*
 604          * Fix for 1053807:
 605          * Determine what shell we should use to run the job. If the user
 606          * didn't explicitly request that their current shell be over-
 607          * ridden (shflag or cshflag), then we use the current shell.
 608          */
 609         if (cshflag)
 610                 Shell = shell = "/bin/csh";
 611         else if (kshflag) {
 612                 Shell = shell = "/bin/ksh";
 613                 ulimit_flag = 1;
 614         } else if (shflag) {
 615                 Shell = shell = "/bin/sh";
 616                 ulimit_flag = 1;
 617         } else if (((Shell = val = getenv("SHELL")) != NULL) &&
 618             (*val != '\0')) {
 619                 shell = "$SHELL";
 620                 if ((strstr(val, "/sh") != NULL) ||
 621                     (strstr(val, "/ksh") != NULL))
 622                         ulimit_flag = 1;
 623         } else {
 624                 /* SHELL is NULL or unset, therefore use default */
 625                 Shell = shell = _PATH_BSHELL;
 626                 ulimit_flag = 1;
 627         }
 628
 629         printf(": %s job\n", jobtype ? "batch" : "at");
 630         printf(": jobname: %.127s\n", (jobfile == NULL) ? "stdin" : jobfile);
 631         printf(": notify by mail: %s\n", (mflag) ? "yes" : "no");
 632
 633         if (pflag) {
 634                 (void) printf(": project: %d\n", project);
 635         } else {
 636                 /*
 637                  * Check if current user is a member of current project.
 638                  * This check is done here to avoid setproject() failure
 639                  * later when the job gets executed.  If current user does
 640                  * not belong to current project, user's default project
 641                  * will be used instead.  This is achieved by not specifying
 642                  * the project (": project: <project>\n") in the job file.
 643                  */
 644                 if ((user = getuser(getuid())) == NULL)
 645                         atabort(INVALIDUSER);
 646                 project = getprojid();
 647                 pprj = getprojbyid(project, &prj, pbuf, sizeof (pbuf));
 648                 if (pprj != NULL) {
 649                         if (inproj(user, pprj->pj_name, pbuf2, sizeof (pbuf2)))
 650                                 (void) printf(": project: %d\n", project);
 651                 }
 652         }
 653
 654         for (ep = environ; *ep; ep++) {
 655                 if ((val = strchr(*ep, '=')) == NULL)
 656                         continue;
 657                 *val++ = '\0';
 658                 (void) printf("export %s; %s=", *ep, *ep);
 659                 escapestr(val);
 660                 (void) putchar('\n');
 661                 *--val = '=';
 662         }
 663         if ((pfp = fopen(pname1, "r")) == NULL &&
 664             (pfp = fopen(pname, "r")) == NULL)
 665                 atabort("no prototype");
 666         /*
 667          * Put in a line to run the proper shell using the rest of
 668          * the file as input.  Note that 'exec'ing the shell will
 669          * cause sh() to leave a /tmp/sh### file around. (1053807)
 670          */
 671         printf("%s << '...the rest of this file is shell input'\n", shell);
 672
 673         um = umask(0);
 674         while ((c = getc(pfp)) != EOF) {
 675                 if (c != '$')
 676                         putchar(c);
 677                 else switch (c =  getc(pfp)) {
 678                 case EOF:
 679                         goto out;
 680                 case 'd':
 681                         /*
 682                          * Must obtain current working directory as the user
 683                          */
 684
 685                         dirbuf[0] = '\0';
 686                         realusr = getuid();
 687                         effeusr = geteuid();
 688                         /* change euid for getcwd */
 689                         if (seteuid(realusr) < 0) {
 690                                 atabort(CANTCHUID);
 691                         }
 692                         if (getcwd(dirbuf, sizeof (dirbuf)) == NULL) {
 693                                 atabort(
 694                                     "can't obtain current working directory");
 695                         }
 696                         /* change back afterwards */
 697                         if (seteuid(effeusr) < 0) {
 698                                 atabort(CANTCHUID);
 699                         }
 700                         escapestr(dirbuf);
 701                         break;
 702                 case 'm':
 703                         printf("%o", um);
 704                         break;
 705                 case '<':
 706                         if (ulimit_flag) {
 707                                 if (getrlimit(RLIMIT_FSIZE, &rlp) == 0) {
 708                                         if (rlp.rlim_cur == RLIM_INFINITY)
 709                                                 printf("ulimit unlimited\n");
 710                                         else
 711                                                 printf("ulimit %lld\n",
 712                                                     rlp.rlim_cur / 512);
 713                                 }
 714                         }
 715                         /*
 716                          * fix for 1113572 - use fputs() so that a
 717                          * newline isn't appended to the one returned
 718                          * with fgets(); 1099381 - prompt for input.
 719                          */
 720                         while (fgets(line, LINE_MAX, inputfile) != NULL) {
 721                                 fputs(line, stdout);
 722                                 if (ttyinput)
 723                                         fputs("at> ", stderr);
 724                         }
 725                         if (ttyinput) /* clean up the final output */
 726                                 fputs("<EOT>\n", stderr);
 727                         break;
 728                 case 't':
 729                         printf(":%lu", when);
 730                         break;
 731                 default:
 732                         putchar(c);
 733                 }
 734         }
 735 out:
 736         fclose(pfp);
 737         fflush(NULL);
 738 }
 739
 740 static int
 741 remove_jobs(int argc, char **argv, char *login)
 742 /* remove jobs that are specified */
 743 {
 744         int             i, r;
 745         int             error = 0;
 746         struct stat     buf;
 747         struct passwd *pw;
 748
 749         pw = getpwuid(user);
 750         if (pw == NULL) {
 751                 atabort("Invalid user.\n");
 752         }
 753
 754         if (argc == 0)
 755                 usage();
 756         if (chdir(ATDIR) == -1)
 757                 atabort(CANTCD);
 758         for (i = 0; i < argc; i++)
 759                 if (strchr(argv[i], '/') != NULL) {
 760                         fprintf(stderr, "at: %s: not a valid job-id\n",
 761                                         argv[i]);
 762                 } else if (stat(argv[i], &buf)) {
 763                         fprintf(stderr, "at: %s: ", argv[i]);
 764                         perror("");
 765                 } else if ((user != buf.st_uid) &&
 766                     (!cron_admin(pw->pw_name))) {
 767                         fprintf(stderr, "at: you don't own %s\n",
 768                             argv[i]);
 769                         error = 1;
 770                 } else {
 771                         if (cron_admin(pw->pw_name)) {
 772                                 login = getuser((uid_t)buf.st_uid);
 773                                 if (login == NULL) {
 774                                         if (per_errno == 2)
 775                                                 atabort(BADSHELL);
 776                                         else
 777                                                 atabort(INVALIDUSER);
 778                                         }
 779                         }
 780                         cron_sendmsg(DELETE, login, argv[i], AT);
 781                         r = unlink(argv[i]);
 782                         audit_at_delete(argv[i], ATDIR, r);
 783                 }
 784         return (error);
 785 }
 786
 787
 788
 789 static int
 790 list_jobs(int argc, char **argv, int qflag, int queue)
 791 {
 792         DIR             *dir;
 793         int             i;
 794         int             error = 0;
 795         char            *patdir, *atdir, *ptr;
 796         char            timebuf[80];
 797         time_t          t;
 798         struct stat     buf, st1, st2;
 799         struct dirent   *dentry;
 800         struct passwd   *pw;
 801         unsigned int    atdirlen;
 802         int r;
 803         struct passwd   *pwd, pwds;
 804         char buf_pwd[1024];
 805         char job_file[PATH_MAX];
 806
 807         getpwuid_r(user, &pwds, buf_pwd, sizeof (buf_pwd), &pwd);
 808         if (pwd == NULL) {
 809                 atabort("Invalid user.\n");
 810         }
 811
 812         /* list jobs for user */
 813         if (chdir(ATDIR) == -1)
 814                 atabort(CANTCD);
 815
 816         atdirlen = strlen(ATDIR);
 817         atdir = xmalloc(atdirlen + 1);
 818         strcpy(atdir, ATDIR);
 819         patdir = strrchr(atdir, '/');
 820         *patdir = '\0';
 821         if (argc == 0) {
 822                 /* list all jobs for a user */
 823                 if (stat(ATDIR, &st1) != 0 || stat(atdir, &st2) != 0)
 824                         atabort("Can not get status of spooling"
 825                             "directory for at");
 826                 if ((dir = opendir(ATDIR)) == NULL)
 827                         atabort(NOOPENDIR);
 828                 while (1) {
 829                         if ((dentry = readdir(dir)) == NULL)
 830                                 break;
 831                         if ((dentry->d_ino == st1.st_ino) ||
 832                             (dentry->d_ino == st2.st_ino))
 833                                 continue;
 834                         if ((r = audit_cron_is_anc_name(dentry->d_name)) == 1)
 835                                 continue;
 836                         if (stat(dentry->d_name, &buf)) {
 837                                 unlink(dentry->d_name);
 838                                 audit_cron_delete_anc_file(dentry->d_name,
 839                                     NULL);
 840                                 continue;
 841                         }
 842                         if ((!cron_admin(pwd->pw_name)) &&
 843                             (buf.st_uid != user))
 844                                 continue;
 845                         ptr = dentry->d_name;
 846                         if (((t = num(&ptr)) == 0) || (*ptr != '.'))
 847                                 continue;
 848                         strcpy(job_file, patdir);
 849                         strcat(job_file, dentry->d_name);
 850                         if (pflag && not_this_project(job_file))
 851                                 continue;
 852                         ascftime(timebuf, FORMAT, localtime(&t));
 853                         if ((cron_admin(pwd->pw_name)) &&
 854                             ((pw = getpwuid(buf.st_uid)) != NULL)) {
 855                                 if (!qflag || (qflag &&
 856                                     check_queue(ptr, queue)))
 857                                         printf("user = %s\t%s\t%s\n",
 858                                             pw->pw_name, dentry->d_name,
 859                                             timebuf);
 860                         } else
 861                                 if (!qflag || (qflag &&
 862                                     check_queue(ptr, queue)))
 863                                         printf("%s\t%s\n",
 864                                             dentry->d_name, timebuf);
 865                 }
 866                 (void) closedir(dir);
 867         } else  /* list particular jobs for user */
 868                 for (i = 0; i < argc; i++) {
 869                         ptr = argv[i];
 870                         strlcpy(job_file, patdir, PATH_MAX);
 871                         strlcat(job_file, ptr, PATH_MAX);
 872                         if (((t = num(&ptr)) == 0) || (*ptr != '.')) {
 873                                 fprintf(stderr, gettext(
 874                                     "at: invalid job name %s\n"), argv[i]);
 875                                 error = 1;
 876                         } else if (stat(argv[i], &buf)) {
 877                                 fprintf(stderr, "at: %s: ", argv[i]);
 878                                 perror("");
 879                                 error = 1;
 880                         } else if ((user != buf.st_uid) &&
 881                             (!cron_admin(pwd->pw_name))) {
 882                                 fprintf(stderr, gettext(
 883                                     "at: you don't own %s\n"), argv[i]);
 884                                 error = 1;
 885                         } else if (pflag && not_this_project(job_file)) {
 886                                 continue;
 887                         } else {
 888                                 if (!qflag || (qflag &&
 889                                     check_queue(ptr, queue))) {
 890                                         ascftime(timebuf, FORMAT,
 891                                             localtime(&t));
 892                                         printf("%s\t%s\n", argv[i], timebuf);
 893                                 }
 894                         }
 895                 }
 896         return (error);
 897 }
 898
 899 /*
 900  * open the command file and read the project id line
 901  * compare to the project number provided via -p on the command line
 902  * return 0 if they match, 1 if they don't match or an error occurs.
 903  */
 904 #define SKIPCOUNT 3     /* lines to skip to get to project line in file */
 905
 906 static int
 907 not_this_project(char *filename)
 908 {
 909         FILE *fp;
 910         projid_t sproj;
 911         int i;
 912
 913         if ((fp = fopen(filename, "r")) == NULL)
 914                 return (1);
 915
 916         for (i = 0; i < SKIPCOUNT; i++)
 917                 fscanf(fp, "%*[^\n]\n");
 918
 919         fscanf(fp, ": project: %d\n", &sproj);
 920         fclose(fp);
 921
 922         return (sproj == project ? 0 : 1);
 923 }
 924
 925 static int
 926 check_queue(char *name, int queue)
 927 {
 928         if ((name[strlen(name) - 1] - 'a') == queue)
 929                 return (1);
 930         else
 931                 return (0);
 932 }
 933
 934 static time_t
 935 parse_time(char *t)
 936 {
 937         int             century = 0;
 938         int             seconds = 0;
 939         char            *p;
 940         time_t          when    = 0;
 941         struct tm       tm;
 942
 943         /*
 944          * time in the following format (defined by the touch(1) spec):
 945          *      [[CC]YY]MMDDhhmm[.SS]
 946          */
 947         if ((p = strchr(t, '.')) != NULL) {
 948                 if (strchr(p+1, '.') != NULL)
 949                         atabort(BADTIME);
 950                 seconds = atoi_for2(p+1);
 951                 *p = '\0';
 952         }
 953
 954         memset(&tm, 0, sizeof (struct tm));
 955         when = time(0);
 956         tm.tm_year = localtime(&when)->tm_year;
 957
 958         switch (strlen(t)) {
 959                 case 12:        /* CCYYMMDDhhmm */
 960                         century = atoi_for2(t);
 961                         t += 2;
 962                 case 10:        /* YYMMDDhhmm */
 963                         tm.tm_year = atoi_for2(t);
 964                         t += 2;
 965                         if (century == 0) {
 966                                 if (tm.tm_year < 69)
 967                                         tm.tm_year += 100;
 968                         } else
 969                                 tm.tm_year += (century - 19) * 100;
 970                 case 8:         /* MMDDhhmm */
 971                         tm.tm_mon = atoi_for2(t) - 1;
 972                         t += 2;
 973                         tm.tm_mday = atoi_for2(t);
 974                         t += 2;
 975                         tm.tm_hour = atoi_for2(t);
 976                         t += 2;
 977                         tm.tm_min = atoi_for2(t);
 978                         t += 2;
 979                         tm.tm_sec = seconds;
 980                         break;
 981                 default:
 982                         atabort(BADTIME);
 983         }
 984
 985         if ((when = mktime(&tm)) == -1)
 986                 atabort(BADTIME);
 987         if (tm.tm_isdst)
 988                 when -= (timezone-altzone);
 989         return (when);
 990 }
 991
 992 static int
 993 atoi_for2(char *p) {
 994         int value;
 995
 996         value = (*p - '0') * 10 + *(p+1) - '0';
 997         if ((value < 0) || (value > 99))
 998                 atabort(BADTIME);
 999         return (value);
1000 }
1001
1002 static void
1003 usage(void)
1004 {
1005         fprintf(stderr, USAGE);
1006         exit(1);
1007 }