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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * 25 * Copyright 2013 Joshua M. Clulow <josh@sysmgr.org> 26 * 27 * Copyright (c) 2014 Gary Mills 28 */ 29 30 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 31 /* All Rights Reserved */ 32 33 /* Copyright (c) 1987, 1988 Microsoft Corporation */ 34 /* All Rights Reserved */ 35 36 #ifdef lint 37 /* make lint happy */ 38 #define __EXTENSIONS__ 39 #endif 40 41 #include <sys/contract/process.h> 42 #include <sys/ctfs.h> 43 #include <sys/param.h> 44 #include <sys/resource.h> 45 #include <sys/stat.h> 46 #include <sys/task.h> 47 #include <sys/time.h> 48 #include <sys/types.h> 49 #include <sys/utsname.h> 50 #include <sys/wait.h> 51 52 #include <security/pam_appl.h> 53 54 #include <alloca.h> 55 #include <ctype.h> 56 #include <deflt.h> 57 #include <dirent.h> 58 #include <errno.h> 59 #include <fcntl.h> 60 #include <grp.h> 61 #include <libcontract.h> 62 #include <libcontract_priv.h> 63 #include <limits.h> 64 #include <locale.h> 65 #include <poll.h> 66 #include <project.h> 67 #include <pwd.h> 68 #include <signal.h> 69 #include <stdarg.h> 70 #include <stdio.h> 71 #include <stdlib.h> 72 #include <string.h> 73 #include <stropts.h> 74 #include <time.h> 75 #include <unistd.h> 76 #include <libzoneinfo.h> 77 78 #include "cron.h" 79 80 /* 81 * #define DEBUG 82 */ 83 84 #define MAIL "/usr/bin/mail" /* mail program to use */ 85 #define CONSOLE "/dev/console" /* where messages go when cron dies */ 86 87 #define TMPINFILE "/tmp/crinXXXXXX" /* file to put stdin in for cmd */ 88 #define TMPDIR "/tmp" 89 #define PFX "crout" 90 #define TMPOUTFILE "/tmp/croutXXXXXX" /* file to place stdout, stderr */ 91 92 #define INMODE 00400 /* mode for stdin file */ 93 #define OUTMODE 00600 /* mode for stdout file */ 94 #define ISUID S_ISUID /* mode for verifing at jobs */ 95 96 #define INFINITY 2147483647L /* upper bound on time */ 97 #define CUSHION 180L 98 #define ZOMB 100 /* proc slot used for mailing output */ 99 100 #define JOBF 'j' 101 #define NICEF 'n' 102 #define USERF 'u' 103 #define WAITF 'w' 104 105 #define BCHAR '>' 106 #define ECHAR '<' 107 108 #define DEFAULT 0 109 #define LOAD 1 110 #define QBUFSIZ 80 111 112 /* Defined actions for crabort() routine */ 113 #define NO_ACTION 000 114 #define REMOVE_FIFO 001 115 #define CONSOLE_MSG 002 116 117 #define BADCD "can't change directory to the crontab directory." 118 #define NOREADDIR "can't read the crontab directory." 119 120 #define BADJOBOPEN "unable to read your at job." 121 #define BADSHELL "because your login shell \ 122 isn't /usr/bin/sh, you can't use cron." 123 124 #define BADSTAT "can't access your crontab or at-job file. Resubmit it." 125 #define BADPROJID "can't set project id for your job." 126 #define CANTCDHOME "can't change directory to %s.\ 127 \nYour commands will not be executed." 128 #define CANTEXECSH "unable to exec the shell, %s, for one of your \ 129 commands." 130 #define CANT_STR_LEN (sizeof (CANTEXECSH) > sizeof (CANTCDHOME) ? \ 131 sizeof (CANTEXECSH) : sizeof (CANTCDHOME)) 132 #define NOREAD "can't read your crontab file. Resubmit it." 133 #define BADTYPE "crontab or at-job file is not a regular file.\n" 134 #define NOSTDIN "unable to create a standard input file for \ 135 one of your crontab commands. \ 136 \nThat command was not executed." 137 138 #define NOTALLOWED "you are not authorized to use cron. Sorry." 139 #define STDERRMSG "\n\n********************************************\ 140 *****\nCron: The previous message is the \ 141 standard output and standard error \ 142 \nof one of your cron commands.\n" 143 144 #define STDOUTERR "one of your commands generated output or errors, \ 145 but cron was unable to mail you this output.\ 146 \nRemember to redirect standard output and standard \ 147 error for each of your commands." 148 149 #define CLOCK_DRIFT "clock time drifted backwards after event!\n" 150 #define PIDERR "unexpected pid returned %d (ignored)" 151 #define CRONTABERR "Subject: Your crontab file has an error in it\n\n" 152 #define MALLOCERR "out of space, cannot create new string\n" 153 154 #define DIDFORK didfork 155 #define NOFORK !didfork 156 157 #define MAILBUFLEN (8*1024) 158 #define LINELIMIT 80 159 #define MAILBINITFREE (MAILBUFLEN - (sizeof (cte_intro) - 1) \ 160 - (sizeof (cte_trail1) - 1) - (sizeof (cte_trail2) - 1) - 1) 161 162 #define ERR_CRONTABENT 0 /* error in crontab file entry */ 163 #define ERR_UNIXERR 1 /* error in some system call */ 164 #define ERR_CANTEXECCRON 2 /* error setting up "cron" job environment */ 165 #define ERR_CANTEXECAT 3 /* error setting up "at" job environment */ 166 #define ERR_NOTREG 4 /* error not a regular file */ 167 168 #define PROJECT "project=" 169 170 #define MAX_LOST_CONTRACTS 2048 /* reset if this many failed abandons */ 171 172 #define FORMAT "%a %b %e %H:%M:%S %Y" 173 static char timebuf[80]; 174 175 static struct message msgbuf; 176 177 struct shared { 178 int count; /* usage count */ 179 void (*free)(void *obj); /* routine that will free obj */ 180 void *obj; /* object */ 181 }; 182 183 struct event { 184 time_t time; /* time of the event */ 185 short etype; /* what type of event; 0=cron, 1=at */ 186 char *cmd; /* command for cron, job name for at */ 187 struct usr *u; /* ptr to the owner (usr) of this event */ 188 struct event *link; /* ptr to another event for this user */ 189 union { 190 struct { /* for crontab events */ 191 char *minute; /* (these */ 192 char *hour; /* fields */ 193 char *daymon; /* are */ 194 char *month; /* from */ 195 char *dayweek; /* crontab) */ 196 char *input; /* ptr to stdin */ 197 struct shared *tz; /* timezone of this event */ 198 struct shared *home; /* directory for this event */ 199 struct shared *shell; /* shell for this event */ 200 } ct; 201 struct { /* for at events */ 202 short exists; /* for revising at events */ 203 int eventid; /* for el_remove-ing at events */ 204 } at; 205 } of; 206 }; 207 208 struct usr { 209 char *name; /* name of user (e.g. "root") */ 210 char *home; /* home directory for user */ 211 uid_t uid; /* user id */ 212 gid_t gid; /* group id */ 213 int aruncnt; /* counter for running jobs per uid */ 214 int cruncnt; /* counter for running cron jobs per uid */ 215 int ctid; /* for el_remove-ing crontab events */ 216 short ctexists; /* for revising crontab events */ 217 struct event *ctevents; /* list of this usr's crontab events */ 218 struct event *atevents; /* list of this usr's at events */ 219 struct usr *nextusr; 220 }; /* ptr to next user */ 221 222 static struct queue 223 { 224 int njob; /* limit */ 225 int nice; /* nice for execution */ 226 int nwait; /* wait time to next execution attempt */ 227 int nrun; /* number running */ 228 } 229 qd = {100, 2, 60}, /* default values for queue defs */ 230 qt[NQUEUE]; 231 static struct queue qq; 232 233 static struct runinfo 234 { 235 pid_t pid; 236 short que; 237 struct usr *rusr; /* pointer to usr struct */ 238 char *outfile; /* file where stdout & stderr are trapped */ 239 short jobtype; /* what type of event: 0=cron, 1=at */ 240 char *jobname; /* command for "cron", jobname for "at" */ 241 int mailwhendone; /* 1 = send mail even if no ouptut */ 242 struct runinfo *next; 243 } *rthead; 244 245 static struct miscpid { 246 pid_t pid; 247 struct miscpid *next; 248 } *miscpid_head; 249 250 static pid_t cron_pid; /* own pid */ 251 static char didfork = 0; /* flag to see if I'm process group leader */ 252 static int msgfd; /* file descriptor for fifo queue */ 253 static int ecid = 1; /* event class id for el_remove(); MUST be set to 1 */ 254 static int delayed; /* is job being rescheduled or did it run first time */ 255 static int cwd; /* current working directory */ 256 static struct event *next_event; /* the next event to execute */ 257 static struct usr *uhead; /* ptr to the list of users */ 258 259 /* Variables for error handling at reading crontabs. */ 260 static char cte_intro[] = "Line(s) with errors:\n\n"; 261 static char cte_trail1[] = "\nMax number of errors encountered."; 262 static char cte_trail2[] = " Evaluation of crontab aborted.\n"; 263 static int cte_free = MAILBINITFREE; /* Free buffer space */ 264 static char *cte_text = NULL; /* Text buffer pointer */ 265 static char *cte_lp; /* Next free line in cte_text */ 266 static int cte_nvalid; /* Valid lines found */ 267 268 /* user's default environment for the shell */ 269 #define ROOTPATH "PATH=/usr/sbin:/usr/bin" 270 #define NONROOTPATH "PATH=/usr/bin:" 271 272 static char *Def_supath = NULL; 273 static char *Def_path = NULL; 274 static char path[LINE_MAX] = "PATH="; 275 static char supath[LINE_MAX] = "PATH="; 276 static char homedir[LINE_MAX] = ENV_HOME; 277 static char logname[LINE_MAX] = "LOGNAME="; 278 static char tzone[LINE_MAX] = ENV_TZ; 279 static char *envinit[] = { 280 homedir, 281 logname, 282 ROOTPATH, 283 "SHELL=/usr/bin/sh", 284 tzone, 285 NULL 286 }; 287 288 extern char **environ; 289 290 #define DEFTZ "GMT" 291 static int log = 0; 292 static char hzname[10]; 293 294 static void cronend(int); 295 static void thaw_handler(int); 296 static void child_handler(int); 297 static void child_sigreset(void); 298 299 static void mod_ctab(char *, time_t); 300 static void mod_atjob(char *, time_t); 301 static void add_atevent(struct usr *, char *, time_t, int); 302 static void rm_ctevents(struct usr *); 303 static void cleanup(struct runinfo *rn, int r); 304 static void crabort(char *, int); 305 static void msg(char *fmt, ...); 306 static void ignore_msg(char *, char *, struct event *); 307 static void logit(int, struct runinfo *, int); 308 static void parsqdef(char *); 309 static void defaults(); 310 static void initialize(int); 311 static void quedefs(int); 312 static int idle(long); 313 static struct usr *find_usr(char *); 314 static int ex(struct event *e); 315 static void read_dirs(int); 316 static void mail(char *, char *, int); 317 static char *next_field(int, int); 318 static void readcron(struct usr *, time_t); 319 static int next_ge(int, char *); 320 static void free_if_unused(struct usr *); 321 static void del_atjob(char *, char *); 322 static void del_ctab(char *); 323 static void resched(int); 324 static int msg_wait(long); 325 static struct runinfo *rinfo_get(pid_t); 326 static void rinfo_free(struct runinfo *rp); 327 static void mail_result(struct usr *p, struct runinfo *pr, size_t filesize); 328 static time_t next_time(struct event *, time_t); 329 static time_t get_switching_time(int, time_t); 330 static time_t xmktime(struct tm *); 331 static void process_msg(struct message *, time_t); 332 static void reap_child(void); 333 static void miscpid_insert(pid_t); 334 static int miscpid_delete(pid_t); 335 static void contract_set_template(void); 336 static void contract_clear_template(void); 337 static void contract_abandon_latest(pid_t); 338 339 static void cte_init(void); 340 static void cte_add(int, char *); 341 static void cte_valid(void); 342 static int cte_istoomany(void); 343 static void cte_sendmail(char *); 344 345 static int set_user_cred(const struct usr *, struct project *); 346 347 static struct shared *create_shared_str(char *str); 348 static struct shared *dup_shared(struct shared *obj); 349 static void rel_shared(struct shared *obj); 350 static void *get_obj(struct shared *obj); 351 /* 352 * last_time is set immediately prior to exection of an event (via ex()) 353 * to indicate the last time an event was executed. This was (surely) 354 * it's original intended use. 355 */ 356 static time_t last_time, init_time, t_old; 357 static int reset_needed; /* set to 1 when cron(1M) needs to re-initialize */ 358 359 static int refresh; 360 static sigset_t defmask, sigmask; 361 362 /* 363 * BSM hooks 364 */ 365 extern int audit_cron_session(char *, char *, uid_t, gid_t, char *); 366 extern void audit_cron_new_job(char *, int, void *); 367 extern void audit_cron_bad_user(char *); 368 extern void audit_cron_user_acct_expired(char *); 369 extern int audit_cron_create_anc_file(char *, char *, char *, uid_t); 370 extern int audit_cron_delete_anc_file(char *, char *); 371 extern int audit_cron_is_anc_name(char *); 372 extern int audit_cron_mode(); 373 374 static int cron_conv(int, struct pam_message **, 375 struct pam_response **, void *); 376 377 static struct pam_conv pam_conv = {cron_conv, NULL}; 378 static pam_handle_t *pamh; /* Authentication handle */ 379 380 /* 381 * Function to help check a user's credentials. 382 */ 383 384 static int verify_user_cred(struct usr *u); 385 386 /* 387 * Values returned by verify_user_cred and set_user_cred: 388 */ 389 390 #define VUC_OK 0 391 #define VUC_BADUSER 1 392 #define VUC_NOTINGROUP 2 393 #define VUC_EXPIRED 3 394 #define VUC_NEW_AUTH 4 395 396 /* 397 * Modes of process_anc_files function 398 */ 399 #define CRON_ANC_DELETE 1 400 #define CRON_ANC_CREATE 0 401 402 /* 403 * Functions to remove a user or job completely from the running database. 404 */ 405 static void clean_out_atjobs(struct usr *u); 406 static void clean_out_ctab(struct usr *u); 407 static void clean_out_user(struct usr *u); 408 static void cron_unlink(char *name); 409 static void process_anc_files(int); 410 411 /* 412 * functions in elm.c 413 */ 414 extern void el_init(int, time_t, time_t, int); 415 extern int el_add(void *, time_t, int); 416 extern void el_remove(int, int); 417 extern int el_empty(void); 418 extern void *el_first(void); 419 extern void el_delete(void); 420 421 static int valid_entry(char *, int); 422 static struct usr *create_ulist(char *, int); 423 static void init_cronevent(char *, int); 424 static void init_atevent(char *, time_t, int, int); 425 static void update_atevent(struct usr *, char *, time_t, int); 426 427 int 428 main(int argc, char *argv[]) 429 { 430 time_t t; 431 time_t ne_time; /* amt of time until next event execution */ 432 time_t newtime, lastmtime = 0L; 433 struct usr *u; 434 struct event *e, *e2, *eprev; 435 struct stat buf; 436 pid_t rfork; 437 struct sigaction act; 438 439 /* 440 * reset_needed is set to 1 whenever el_add() finds out that a cron 441 * job is scheduled to be run before the time when cron(1M) daemon 442 * initialized. 443 * Other cases where a reset is needed is when ex() finds that the 444 * event to be executed is being run at the wrong time, or when idle() 445 * determines that time was reset. 446 * We immediately return to the top of the while (TRUE) loop in 447 * main() where the event list is cleared and rebuilt, and reset_needed 448 * is set back to 0. 449 */ 450 reset_needed = 0; 451 452 /* 453 * Only the privileged user can run this command. 454 */ 455 if (getuid() != 0) 456 crabort(NOTALLOWED, 0); 457 458 begin: 459 (void) setlocale(LC_ALL, ""); 460 /* fork unless 'nofork' is specified */ 461 if ((argc <= 1) || (strcmp(argv[1], "nofork"))) { 462 if (rfork = fork()) { 463 if (rfork == (pid_t)-1) { 464 (void) sleep(30); 465 goto begin; 466 } 467 return (0); 468 } 469 didfork++; 470 (void) setpgrp(); /* detach cron from console */ 471 } 472 473 (void) umask(022); 474 (void) signal(SIGHUP, SIG_IGN); 475 (void) signal(SIGINT, SIG_IGN); 476 (void) signal(SIGQUIT, SIG_IGN); 477 (void) signal(SIGTERM, cronend); 478 479 defaults(); 480 initialize(1); 481 quedefs(DEFAULT); /* load default queue definitions */ 482 cron_pid = getpid(); 483 msg("*** cron started *** pid = %d", cron_pid); 484 485 /* setup THAW handler */ 486 act.sa_handler = thaw_handler; 487 act.sa_flags = 0; 488 (void) sigemptyset(&act.sa_mask); 489 (void) sigaction(SIGTHAW, &act, NULL); 490 491 /* setup CHLD handler */ 492 act.sa_handler = child_handler; 493 act.sa_flags = 0; 494 (void) sigemptyset(&act.sa_mask); 495 (void) sigaddset(&act.sa_mask, SIGCLD); 496 (void) sigaction(SIGCLD, &act, NULL); 497 498 (void) sigemptyset(&defmask); 499 (void) sigemptyset(&sigmask); 500 (void) sigaddset(&sigmask, SIGCLD); 501 (void) sigaddset(&sigmask, SIGTHAW); 502 (void) sigprocmask(SIG_BLOCK, &sigmask, NULL); 503 504 t_old = init_time; 505 last_time = t_old; 506 for (;;) { /* MAIN LOOP */ 507 t = time(NULL); 508 if ((t_old > t) || (t-last_time > CUSHION) || reset_needed) { 509 reset_needed = 0; 510 /* 511 * the time was set backwards or forward or 512 * refresh is requested. 513 */ 514 if (refresh) 515 msg("re-scheduling jobs"); 516 else 517 msg("time was reset, re-initializing"); 518 el_delete(); 519 u = uhead; 520 while (u != NULL) { 521 rm_ctevents(u); 522 e = u->atevents; 523 while (e != NULL) { 524 free(e->cmd); 525 e2 = e->link; 526 free(e); 527 e = e2; 528 } 529 u->atevents = NULL; 530 u = u->nextusr; 531 } 532 (void) close(msgfd); 533 initialize(0); 534 t = time(NULL); 535 last_time = t; 536 /* 537 * reset_needed might have been set in the functions 538 * call path from initialize() 539 */ 540 if (reset_needed) { 541 continue; 542 } 543 } 544 t_old = t; 545 546 if (next_event == NULL && !el_empty()) { 547 next_event = (struct event *)el_first(); 548 } 549 if (next_event == NULL) { 550 ne_time = INFINITY; 551 } else { 552 ne_time = next_event->time - t; 553 #ifdef DEBUG 554 cftime(timebuf, "%+", &next_event->time); 555 (void) fprintf(stderr, "next_time=%ld %s\n", 556 next_event->time, timebuf); 557 #endif 558 } 559 if (ne_time > 0) { 560 /* 561 * reset_needed may be set in the functions call path 562 * from idle() 563 */ 564 if (idle(ne_time) || reset_needed) { 565 reset_needed = 1; 566 continue; 567 } 568 } 569 570 if (stat(QUEDEFS, &buf)) { 571 msg("cannot stat QUEDEFS file"); 572 } else if (lastmtime != buf.st_mtime) { 573 quedefs(LOAD); 574 lastmtime = buf.st_mtime; 575 } 576 577 last_time = next_event->time; /* save execution time */ 578 579 /* 580 * reset_needed may be set in the functions call path 581 * from ex() 582 */ 583 if (ex(next_event) || reset_needed) { 584 reset_needed = 1; 585 continue; 586 } 587 588 switch (next_event->etype) { 589 case CRONEVENT: 590 /* add cronevent back into the main event list */ 591 if (delayed) { 592 delayed = 0; 593 break; 594 } 595 596 /* 597 * check if time(0)< last_time. if so, then the 598 * system clock has gone backwards. to prevent this 599 * job from being started twice, we reschedule this 600 * job for the >>next time after last_time<<, and 601 * then set next_event->time to this. note that 602 * crontab's resolution is 1 minute. 603 */ 604 605 if (last_time > time(NULL)) { 606 msg(CLOCK_DRIFT); 607 /* 608 * bump up to next 30 second 609 * increment 610 * 1 <= newtime <= 30 611 */ 612 newtime = 30 - (last_time % 30); 613 newtime += last_time; 614 615 /* 616 * get the next scheduled event, 617 * not the one that we just 618 * kicked off! 619 */ 620 next_event->time = 621 next_time(next_event, newtime); 622 t_old = time(NULL); 623 } else { 624 next_event->time = 625 next_time(next_event, (time_t)0); 626 } 627 #ifdef DEBUG 628 cftime(timebuf, "%+", &next_event->time); 629 (void) fprintf(stderr, 630 "pushing back cron event %s at %ld (%s)\n", 631 next_event->cmd, next_event->time, timebuf); 632 #endif 633 634 switch (el_add(next_event, next_event->time, 635 (next_event->u)->ctid)) { 636 case -1: 637 ignore_msg("main", "cron", next_event); 638 break; 639 case -2: /* event time lower than init time */ 640 reset_needed = 1; 641 break; 642 } 643 break; 644 default: 645 /* remove at or batch job from system */ 646 if (delayed) { 647 delayed = 0; 648 break; 649 } 650 eprev = NULL; 651 e = (next_event->u)->atevents; 652 while (e != NULL) { 653 if (e == next_event) { 654 if (eprev == NULL) 655 (e->u)->atevents = e->link; 656 else 657 eprev->link = e->link; 658 free(e->cmd); 659 free(e); 660 break; 661 } else { 662 eprev = e; 663 e = e->link; 664 } 665 } 666 break; 667 } 668 next_event = NULL; 669 } 670 671 /*NOTREACHED*/ 672 } 673 674 static void 675 initialize(int firstpass) 676 { 677 #ifdef DEBUG 678 (void) fprintf(stderr, "in initialize\n"); 679 #endif 680 if (firstpass) { 681 /* for mail(1), make sure messages come from root */ 682 if (putenv("LOGNAME=root") != 0) { 683 crabort("cannot expand env variable", 684 REMOVE_FIFO|CONSOLE_MSG); 685 } 686 if (access(FIFO, R_OK) == -1) { 687 if (errno == ENOENT) { 688 if (mknod(FIFO, S_IFIFO|0600, 0) != 0) 689 crabort("cannot create fifo queue", 690 REMOVE_FIFO|CONSOLE_MSG); 691 } else { 692 if (NOFORK) { 693 /* didn't fork... init(1M) is waiting */ 694 (void) sleep(60); 695 } 696 perror("FIFO"); 697 crabort("cannot access fifo queue", 698 REMOVE_FIFO|CONSOLE_MSG); 699 } 700 } else { 701 if (NOFORK) { 702 /* didn't fork... init(1M) is waiting */ 703 (void) sleep(60); 704 /* 705 * the wait is painful, but we don't want 706 * init respawning this quickly 707 */ 708 } 709 crabort("cannot start cron; FIFO exists", CONSOLE_MSG); 710 } 711 } 712 713 if ((msgfd = open(FIFO, O_RDWR)) < 0) { 714 perror("! open"); 715 crabort("cannot open fifo queue", REMOVE_FIFO|CONSOLE_MSG); 716 } 717 718 init_time = time(NULL); 719 el_init(8, init_time, (time_t)(60*60*24), 10); 720 721 init_time = time(NULL); 722 el_init(8, init_time, (time_t)(60*60*24), 10); 723 724 /* 725 * read directories, create users list, and add events to the 726 * main event list. Only zero user list on firstpass. 727 */ 728 if (firstpass) 729 uhead = NULL; 730 read_dirs(firstpass); 731 next_event = NULL; 732 733 if (!firstpass) 734 return; 735 736 /* stdout is log file */ 737 if (freopen(ACCTFILE, "a", stdout) == NULL) 738 (void) fprintf(stderr, "cannot open %s\n", ACCTFILE); 739 740 /* log should be root-only */ 741 (void) fchmod(1, S_IRUSR|S_IWUSR); 742 743 /* stderr also goes to ACCTFILE */ 744 (void) close(fileno(stderr)); 745 (void) dup(1); 746 /* null for stdin */ 747 (void) freopen("/dev/null", "r", stdin); 748 749 contract_set_template(); 750 } 751 752 static void 753 read_dirs(int first) 754 { 755 DIR *dir; 756 struct dirent *dp; 757 char *ptr; 758 int jobtype; 759 time_t tim; 760 761 762 if (chdir(CRONDIR) == -1) 763 crabort(BADCD, REMOVE_FIFO|CONSOLE_MSG); 764 cwd = CRON; 765 if ((dir = opendir(".")) == NULL) 766 crabort(NOREADDIR, REMOVE_FIFO|CONSOLE_MSG); 767 while ((dp = readdir(dir)) != NULL) { 768 if (!valid_entry(dp->d_name, CRONEVENT)) 769 continue; 770 init_cronevent(dp->d_name, first); 771 } 772 (void) closedir(dir); 773 774 if (chdir(ATDIR) == -1) { 775 msg("cannot chdir to at directory"); 776 return; 777 } 778 if ((dir = opendir(".")) == NULL) { 779 msg("cannot read at at directory"); 780 return; 781 } 782 cwd = AT; 783 while ((dp = readdir(dir)) != NULL) { 784 if (!valid_entry(dp->d_name, ATEVENT)) 785 continue; 786 ptr = dp->d_name; 787 if (((tim = num(&ptr)) == 0) || (*ptr != '.')) 788 continue; 789 ptr++; 790 if (!isalpha(*ptr)) 791 continue; 792 jobtype = *ptr - 'a'; 793 if (jobtype >= NQUEUE) { 794 cron_unlink(dp->d_name); 795 continue; 796 } 797 init_atevent(dp->d_name, tim, jobtype, first); 798 } 799 (void) closedir(dir); 800 } 801 802 static int 803 valid_entry(char *name, int type) 804 { 805 struct stat buf; 806 807 if (strcmp(name, ".") == 0 || 808 strcmp(name, "..") == 0) 809 return (0); 810 811 /* skip over ancillary file names */ 812 if (audit_cron_is_anc_name(name)) 813 return (0); 814 815 if (stat(name, &buf)) { 816 mail(name, BADSTAT, ERR_UNIXERR); 817 cron_unlink(name); 818 return (0); 819 } 820 if (!S_ISREG(buf.st_mode)) { 821 mail(name, BADTYPE, ERR_NOTREG); 822 cron_unlink(name); 823 return (0); 824 } 825 if (type == ATEVENT) { 826 if (!(buf.st_mode & ISUID)) { 827 cron_unlink(name); 828 return (0); 829 } 830 } 831 return (1); 832 } 833 834 struct usr * 835 create_ulist(char *name, int type) 836 { 837 struct usr *u; 838 839 u = xcalloc(1, sizeof (struct usr)); 840 u->name = xstrdup(name); 841 if (type == CRONEVENT) { 842 u->ctexists = TRUE; 843 u->ctid = ecid++; 844 } else { 845 u->ctexists = FALSE; 846 u->ctid = 0; 847 } 848 u->uid = (uid_t)-1; 849 u->gid = (uid_t)-1; 850 u->nextusr = uhead; 851 uhead = u; 852 return (u); 853 } 854 855 void 856 init_cronevent(char *name, int first) 857 { 858 struct usr *u; 859 860 if (first) { 861 u = create_ulist(name, CRONEVENT); 862 readcron(u, 0); 863 } else { 864 if ((u = find_usr(name)) == NULL) { 865 u = create_ulist(name, CRONEVENT); 866 readcron(u, 0); 867 } else { 868 u->ctexists = TRUE; 869 rm_ctevents(u); 870 el_remove(u->ctid, 0); 871 readcron(u, 0); 872 } 873 } 874 } 875 876 void 877 init_atevent(char *name, time_t tim, int jobtype, int first) 878 { 879 struct usr *u; 880 881 if (first) { 882 u = create_ulist(name, ATEVENT); 883 add_atevent(u, name, tim, jobtype); 884 } else { 885 if ((u = find_usr(name)) == NULL) { 886 u = create_ulist(name, ATEVENT); 887 add_atevent(u, name, tim, jobtype); 888 } else { 889 update_atevent(u, name, tim, jobtype); 890 } 891 } 892 } 893 894 static void 895 mod_ctab(char *name, time_t reftime) 896 { 897 struct passwd *pw; 898 struct stat buf; 899 struct usr *u; 900 char namebuf[LINE_MAX]; 901 char *pname; 902 903 /* skip over ancillary file names */ 904 if (audit_cron_is_anc_name(name)) 905 return; 906 907 if ((pw = getpwnam(name)) == NULL) { 908 msg("No such user as %s - cron entries not created", name); 909 return; 910 } 911 if (cwd != CRON) { 912 if (snprintf(namebuf, sizeof (namebuf), "%s/%s", 913 CRONDIR, name) >= sizeof (namebuf)) { 914 msg("Too long path name %s - cron entries not created", 915 namebuf); 916 return; 917 } 918 pname = namebuf; 919 } else { 920 pname = name; 921 } 922 /* 923 * a warning message is given by the crontab command so there is 924 * no need to give one here...... use this code if you only want 925 * users with a login shell of /usr/bin/sh to use cron 926 */ 927 #ifdef BOURNESHELLONLY 928 if ((strcmp(pw->pw_shell, "") != 0) && 929 (strcmp(pw->pw_shell, SHELL) != 0)) { 930 mail(name, BADSHELL, ERR_CANTEXECCRON); 931 cron_unlink(pname); 932 return; 933 } 934 #endif 935 if (stat(pname, &buf)) { 936 mail(name, BADSTAT, ERR_UNIXERR); 937 cron_unlink(pname); 938 return; 939 } 940 if (!S_ISREG(buf.st_mode)) { 941 mail(name, BADTYPE, ERR_CRONTABENT); 942 return; 943 } 944 if ((u = find_usr(name)) == NULL) { 945 #ifdef DEBUG 946 (void) fprintf(stderr, "new user (%s) with a crontab\n", name); 947 #endif 948 u = create_ulist(name, CRONEVENT); 949 u->home = xmalloc(strlen(pw->pw_dir) + 1); 950 (void) strcpy(u->home, pw->pw_dir); 951 u->uid = pw->pw_uid; 952 u->gid = pw->pw_gid; 953 readcron(u, reftime); 954 } else { 955 u->uid = pw->pw_uid; 956 u->gid = pw->pw_gid; 957 if (u->home != NULL) { 958 if (strcmp(u->home, pw->pw_dir) != 0) { 959 free(u->home); 960 u->home = xmalloc(strlen(pw->pw_dir) + 1); 961 (void) strcpy(u->home, pw->pw_dir); 962 } 963 } else { 964 u->home = xmalloc(strlen(pw->pw_dir) + 1); 965 (void) strcpy(u->home, pw->pw_dir); 966 } 967 u->ctexists = TRUE; 968 if (u->ctid == 0) { 969 #ifdef DEBUG 970 (void) fprintf(stderr, "%s now has a crontab\n", 971 u->name); 972 #endif 973 /* user didnt have a crontab last time */ 974 u->ctid = ecid++; 975 u->ctevents = NULL; 976 readcron(u, reftime); 977 return; 978 } 979 #ifdef DEBUG 980 (void) fprintf(stderr, "%s has revised his crontab\n", u->name); 981 #endif 982 rm_ctevents(u); 983 el_remove(u->ctid, 0); 984 readcron(u, reftime); 985 } 986 } 987 988 /* ARGSUSED */ 989 static void 990 mod_atjob(char *name, time_t reftime) 991 { 992 char *ptr; 993 time_t tim; 994 struct passwd *pw; 995 struct stat buf; 996 struct usr *u; 997 char namebuf[PATH_MAX]; 998 char *pname; 999 int jobtype; 1000 1001 ptr = name; 1002 if (((tim = num(&ptr)) == 0) || (*ptr != '.')) 1003 return; 1004 ptr++; 1005 if (!isalpha(*ptr)) 1006 return; 1007 jobtype = *ptr - 'a'; 1008 1009 /* check for audit ancillary file */ 1010 if (audit_cron_is_anc_name(name)) 1011 return; 1012 1013 if (cwd != AT) { 1014 if (snprintf(namebuf, sizeof (namebuf), "%s/%s", ATDIR, name) 1015 >= sizeof (namebuf)) { 1016 return; 1017 } 1018 pname = namebuf; 1019 } else { 1020 pname = name; 1021 } 1022 if (stat(pname, &buf) || jobtype >= NQUEUE) { 1023 cron_unlink(pname); 1024 return; 1025 } 1026 if (!(buf.st_mode & ISUID) || !S_ISREG(buf.st_mode)) { 1027 cron_unlink(pname); 1028 return; 1029 } 1030 if ((pw = getpwuid(buf.st_uid)) == NULL) { 1031 cron_unlink(pname); 1032 return; 1033 } 1034 /* 1035 * a warning message is given by the at command so there is no 1036 * need to give one here......use this code if you only want 1037 * users with a login shell of /usr/bin/sh to use cron 1038 */ 1039 #ifdef BOURNESHELLONLY 1040 if ((strcmp(pw->pw_shell, "") != 0) && 1041 (strcmp(pw->pw_shell, SHELL) != 0)) { 1042 mail(pw->pw_name, BADSHELL, ERR_CANTEXECAT); 1043 cron_unlink(pname); 1044 return; 1045 } 1046 #endif 1047 if ((u = find_usr(pw->pw_name)) == NULL) { 1048 #ifdef DEBUG 1049 (void) fprintf(stderr, "new user (%s) with an at job = %s\n", 1050 pw->pw_name, name); 1051 #endif 1052 u = create_ulist(pw->pw_name, ATEVENT); 1053 u->home = xstrdup(pw->pw_dir); 1054 u->uid = pw->pw_uid; 1055 u->gid = pw->pw_gid; 1056 add_atevent(u, name, tim, jobtype); 1057 } else { 1058 u->uid = pw->pw_uid; 1059 u->gid = pw->pw_gid; 1060 free(u->home); 1061 u->home = xstrdup(pw->pw_dir); 1062 update_atevent(u, name, tim, jobtype); 1063 } 1064 } 1065 1066 static void 1067 add_atevent(struct usr *u, char *job, time_t tim, int jobtype) 1068 { 1069 struct event *e; 1070 1071 e = xmalloc(sizeof (struct event)); 1072 e->etype = jobtype; 1073 e->cmd = xmalloc(strlen(job) + 1); 1074 (void) strcpy(e->cmd, job); 1075 e->u = u; 1076 e->link = u->atevents; 1077 u->atevents = e; 1078 e->of.at.exists = TRUE; 1079 e->of.at.eventid = ecid++; 1080 if (tim < init_time) /* old job */ 1081 e->time = init_time; 1082 else 1083 e->time = tim; 1084 #ifdef DEBUG 1085 (void) fprintf(stderr, "add_atevent: user=%s, job=%s, time=%ld\n", 1086 u->name, e->cmd, e->time); 1087 #endif 1088 if (el_add(e, e->time, e->of.at.eventid) < 0) { 1089 ignore_msg("add_atevent", "at", e); 1090 } 1091 } 1092 1093 void 1094 update_atevent(struct usr *u, char *name, time_t tim, int jobtype) 1095 { 1096 struct event *e; 1097 1098 e = u->atevents; 1099 while (e != NULL) { 1100 if (strcmp(e->cmd, name) == 0) { 1101 e->of.at.exists = TRUE; 1102 break; 1103 } else { 1104 e = e->link; 1105 } 1106 } 1107 if (e == NULL) { 1108 #ifdef DEBUG 1109 (void) fprintf(stderr, "%s has a new at job = %s\n", 1110 u->name, name); 1111 #endif 1112 add_atevent(u, name, tim, jobtype); 1113 } 1114 } 1115 1116 static char line[CTLINESIZE]; /* holds a line from a crontab file */ 1117 static int cursor; /* cursor for the above line */ 1118 1119 static void 1120 readcron(struct usr *u, time_t reftime) 1121 { 1122 /* 1123 * readcron reads in a crontab file for a user (u). The list of 1124 * events for user u is built, and u->events is made to point to 1125 * this list. Each event is also entered into the main event 1126 * list. 1127 */ 1128 FILE *cf; /* cf will be a user's crontab file */ 1129 struct event *e; 1130 int start; 1131 unsigned int i; 1132 char namebuf[PATH_MAX]; 1133 char *pname; 1134 struct shared *tz = NULL; 1135 struct shared *home = NULL; 1136 struct shared *shell = NULL; 1137 int lineno = 0; 1138 1139 /* read the crontab file */ 1140 cte_init(); /* Init error handling */ 1141 if (cwd != CRON) { 1142 if (snprintf(namebuf, sizeof (namebuf), "%s/%s", 1143 CRONDIR, u->name) >= sizeof (namebuf)) { 1144 return; 1145 } 1146 pname = namebuf; 1147 } else { 1148 pname = u->name; 1149 } 1150 if ((cf = fopen(pname, "r")) == NULL) { 1151 mail(u->name, NOREAD, ERR_UNIXERR); 1152 return; 1153 } 1154 while (fgets(line, CTLINESIZE, cf) != NULL) { 1155 char *tmp; 1156 /* process a line of a crontab file */ 1157 lineno++; 1158 if (cte_istoomany()) 1159 break; 1160 cursor = 0; 1161 while (line[cursor] == ' ' || line[cursor] == '\t') 1162 cursor++; 1163 if (line[cursor] == '#' || line[cursor] == '\n') 1164 continue; 1165 1166 if (strncmp(&line[cursor], ENV_TZ, 1167 strlen(ENV_TZ)) == 0) { 1168 if ((tmp = strchr(&line[cursor], '\n')) != NULL) { 1169 *tmp = NULL; 1170 } 1171 1172 if (!isvalid_tz(&line[cursor + strlen(ENV_TZ)], NULL, 1173 _VTZ_ALL)) { 1174 cte_add(lineno, line); 1175 break; 1176 } 1177 if (tz == NULL || strcmp(&line[cursor], get_obj(tz))) { 1178 rel_shared(tz); 1179 tz = create_shared_str(&line[cursor]); 1180 } 1181 continue; 1182 } 1183 1184 if (strncmp(&line[cursor], ENV_HOME, 1185 strlen(ENV_HOME)) == 0) { 1186 if ((tmp = strchr(&line[cursor], '\n')) != NULL) { 1187 *tmp = NULL; 1188 } 1189 if (home == NULL || 1190 strcmp(&line[cursor], get_obj(home))) { 1191 rel_shared(home); 1192 home = create_shared_str( 1193 &line[cursor + strlen(ENV_HOME)]); 1194 } 1195 continue; 1196 } 1197 1198 if (strncmp(&line[cursor], ENV_SHELL, 1199 strlen(ENV_SHELL)) == 0) { 1200 if ((tmp = strchr(&line[cursor], '\n')) != NULL) { 1201 *tmp = NULL; 1202 } 1203 if (shell == NULL || 1204 strcmp(&line[cursor], get_obj(shell))) { 1205 rel_shared(shell); 1206 shell = create_shared_str(&line[cursor]); 1207 } 1208 continue; 1209 } 1210 1211 e = xmalloc(sizeof (struct event)); 1212 e->etype = CRONEVENT; 1213 if (!(((e->of.ct.minute = next_field(0, 59)) != NULL) && 1214 ((e->of.ct.hour = next_field(0, 23)) != NULL) && 1215 ((e->of.ct.daymon = next_field(1, 31)) != NULL) && 1216 ((e->of.ct.month = next_field(1, 12)) != NULL) && 1217 ((e->of.ct.dayweek = next_field(0, 6)) != NULL))) { 1218 free(e); 1219 cte_add(lineno, line); 1220 continue; 1221 } 1222 while (line[cursor] == ' ' || line[cursor] == '\t') 1223 cursor++; 1224 if (line[cursor] == '\n' || line[cursor] == '\0') 1225 continue; 1226 /* get the command to execute */ 1227 start = cursor; 1228 again: 1229 while ((line[cursor] != '%') && 1230 (line[cursor] != '\n') && 1231 (line[cursor] != '\0') && 1232 (line[cursor] != '\\')) 1233 cursor++; 1234 if (line[cursor] == '\\') { 1235 cursor += 2; 1236 goto again; 1237 } 1238 e->cmd = xmalloc(cursor-start + 1); 1239 (void) strncpy(e->cmd, line + start, cursor-start); 1240 e->cmd[cursor-start] = '\0'; 1241 /* see if there is any standard input */ 1242 if (line[cursor] == '%') { 1243 e->of.ct.input = xmalloc(strlen(line)-cursor + 1); 1244 (void) strcpy(e->of.ct.input, line + cursor + 1); 1245 for (i = 0; i < strlen(e->of.ct.input); i++) { 1246 if (e->of.ct.input[i] == '%') 1247 e->of.ct.input[i] = '\n'; 1248 } 1249 } else { 1250 e->of.ct.input = NULL; 1251 } 1252 /* set the timezone of this entry */ 1253 e->of.ct.tz = dup_shared(tz); 1254 /* set the shell of this entry */ 1255 e->of.ct.shell = dup_shared(shell); 1256 /* set the home of this entry */ 1257 e->of.ct.home = dup_shared(home); 1258 /* have the event point to it's owner */ 1259 e->u = u; 1260 /* insert this event at the front of this user's event list */ 1261 e->link = u->ctevents; 1262 u->ctevents = e; 1263 /* set the time for the first occurance of this event */ 1264 e->time = next_time(e, reftime); 1265 /* finally, add this event to the main event list */ 1266 switch (el_add(e, e->time, u->ctid)) { 1267 case -1: 1268 ignore_msg("readcron", "cron", e); 1269 break; 1270 case -2: /* event time lower than init time */ 1271 reset_needed = 1; 1272 break; 1273 } 1274 cte_valid(); 1275 #ifdef DEBUG 1276 cftime(timebuf, "%+", &e->time); 1277 (void) fprintf(stderr, "inserting cron event %s at %ld (%s)\n", 1278 e->cmd, e->time, timebuf); 1279 #endif 1280 } 1281 cte_sendmail(u->name); /* mail errors if any to user */ 1282 (void) fclose(cf); 1283 rel_shared(tz); 1284 rel_shared(shell); 1285 rel_shared(home); 1286 } 1287 1288 /* 1289 * Below are the functions for handling of errors in crontabs. Concept is to 1290 * collect faulty lines and send one email at the end of the crontab 1291 * evaluation. If there are erroneous lines only ((cte_nvalid == 0), evaluation 1292 * of crontab is aborted. Otherwise reading of crontab is continued to the end 1293 * of the file but no further error logging appears. 1294 */ 1295 static void 1296 cte_init() 1297 { 1298 if (cte_text == NULL) 1299 cte_text = xmalloc(MAILBUFLEN); 1300 (void) strlcpy(cte_text, cte_intro, MAILBUFLEN); 1301 cte_lp = cte_text + sizeof (cte_intro) - 1; 1302 cte_free = MAILBINITFREE; 1303 cte_nvalid = 0; 1304 } 1305 1306 static void 1307 cte_add(int lineno, char *ctline) 1308 { 1309 int len; 1310 char *p; 1311 1312 if (cte_free >= LINELIMIT) { 1313 (void) sprintf(cte_lp, "%4d: ", lineno); 1314 (void) strlcat(cte_lp, ctline, LINELIMIT - 1); 1315 len = strlen(cte_lp); 1316 if (cte_lp[len - 1] != '\n') { 1317 cte_lp[len++] = '\n'; 1318 cte_lp[len] = '\0'; 1319 } 1320 for (p = cte_lp; *p; p++) { 1321 if (isprint(*p) || *p == '\n' || *p == '\t') 1322 continue; 1323 *p = '.'; 1324 } 1325 cte_lp += len; 1326 cte_free -= len; 1327 if (cte_free < LINELIMIT) { 1328 size_t buflen = MAILBUFLEN - (cte_lp - cte_text); 1329 (void) strlcpy(cte_lp, cte_trail1, buflen); 1330 if (cte_nvalid == 0) 1331 (void) strlcat(cte_lp, cte_trail2, buflen); 1332 } 1333 } 1334 } 1335 1336 static void 1337 cte_valid() 1338 { 1339 cte_nvalid++; 1340 } 1341 1342 static int 1343 cte_istoomany() 1344 { 1345 /* 1346 * Return TRUE only if all lines are faulty. So evaluation of 1347 * a crontab is not aborted if at least one valid line was found. 1348 */ 1349 return (cte_nvalid == 0 && cte_free < LINELIMIT); 1350 } 1351 1352 static void 1353 cte_sendmail(char *username) 1354 { 1355 if (cte_free < MAILBINITFREE) 1356 mail(username, cte_text, ERR_CRONTABENT); 1357 } 1358 1359 /* 1360 * Send mail with error message to a user 1361 */ 1362 static void 1363 mail(char *usrname, char *mesg, int format) 1364 { 1365 /* mail mails a user a message. */ 1366 FILE *pipe; 1367 char *temp; 1368 struct passwd *ruser_ids; 1369 pid_t fork_val; 1370 int saveerrno = errno; 1371 struct utsname name; 1372 1373 #ifdef TESTING 1374 return; 1375 #endif 1376 (void) uname(&name); 1377 if ((fork_val = fork()) == (pid_t)-1) { 1378 msg("cron cannot fork\n"); 1379 return; 1380 } 1381 if (fork_val == 0) { 1382 child_sigreset(); 1383 contract_clear_template(); 1384 if ((ruser_ids = getpwnam(usrname)) == NULL) 1385 exit(0); 1386 (void) setuid(ruser_ids->pw_uid); 1387 temp = xmalloc(strlen(MAIL) + strlen(usrname) + 2); 1388 (void) sprintf(temp, "%s %s", MAIL, usrname); 1389 pipe = popen(temp, "w"); 1390 if (pipe != NULL) { 1391 (void) fprintf(pipe, "To: %s\n", usrname); 1392 switch (format) { 1393 case ERR_CRONTABENT: 1394 (void) fprintf(pipe, CRONTABERR); 1395 (void) fprintf(pipe, "Your \"crontab\" on %s\n", 1396 name.nodename); 1397 (void) fprintf(pipe, mesg); 1398 (void) fprintf(pipe, 1399 "\nEntries or crontab have been ignored\n"); 1400 break; 1401 case ERR_UNIXERR: 1402 (void) fprintf(pipe, "Subject: %s\n\n", mesg); 1403 (void) fprintf(pipe, 1404 "The error on %s was \"%s\"\n", 1405 name.nodename, errmsg(saveerrno)); 1406 break; 1407 1408 case ERR_CANTEXECCRON: 1409 (void) fprintf(pipe, 1410 "Subject: Couldn't run your \"cron\" job\n\n"); 1411 (void) fprintf(pipe, 1412 "Your \"cron\" job on %s ", name.nodename); 1413 (void) fprintf(pipe, "couldn't be run\n"); 1414 (void) fprintf(pipe, "%s\n", mesg); 1415 (void) fprintf(pipe, 1416 "The error was \"%s\"\n", errmsg(saveerrno)); 1417 break; 1418 1419 case ERR_CANTEXECAT: 1420 (void) fprintf(pipe, 1421 "Subject: Couldn't run your \"at\" job\n\n"); 1422 (void) fprintf(pipe, "Your \"at\" job on %s ", 1423 name.nodename); 1424 (void) fprintf(pipe, "couldn't be run\n"); 1425 (void) fprintf(pipe, "%s\n", mesg); 1426 (void) fprintf(pipe, 1427 "The error was \"%s\"\n", errmsg(saveerrno)); 1428 break; 1429 1430 default: 1431 break; 1432 } 1433 (void) pclose(pipe); 1434 } 1435 free(temp); 1436 exit(0); 1437 } 1438 1439 contract_abandon_latest(fork_val); 1440 1441 if (cron_pid == getpid()) { 1442 miscpid_insert(fork_val); 1443 } 1444 } 1445 1446 static char * 1447 next_field(int lower, int upper) 1448 { 1449 /* 1450 * next_field returns a pointer to a string which holds the next 1451 * field of a line of a crontab file. 1452 * if (numbers in this field are out of range (lower..upper), 1453 * or there is a syntax error) then 1454 * NULL is returned, and a mail message is sent to the 1455 * user telling him which line the error was in. 1456 */ 1457 1458 char *s; 1459 int num, num2, start; 1460 1461 while ((line[cursor] == ' ') || (line[cursor] == '\t')) 1462 cursor++; 1463 start = cursor; 1464 if (line[cursor] == '\0') { 1465 return (NULL); 1466 } 1467 if (line[cursor] == '*') { 1468 cursor++; 1469 if ((line[cursor] != ' ') && (line[cursor] != '\t')) 1470 return (NULL); 1471 s = xmalloc(2); 1472 (void) strcpy(s, "*"); 1473 return (s); 1474 } 1475 for (;;) { 1476 if (!isdigit(line[cursor])) 1477 return (NULL); 1478 num = 0; 1479 do { 1480 num = num*10 + (line[cursor]-'0'); 1481 } while (isdigit(line[++cursor])); 1482 if ((num < lower) || (num > upper)) 1483 return (NULL); 1484 if (line[cursor] == '-') { 1485 if (!isdigit(line[++cursor])) 1486 return (NULL); 1487 num2 = 0; 1488 do { 1489 num2 = num2*10 + (line[cursor]-'0'); 1490 } while (isdigit(line[++cursor])); 1491 if ((num2 < lower) || (num2 > upper)) 1492 return (NULL); 1493 } 1494 if ((line[cursor] == ' ') || (line[cursor] == '\t')) 1495 break; 1496 if (line[cursor] == '\0') 1497 return (NULL); 1498 if (line[cursor++] != ',') 1499 return (NULL); 1500 } 1501 s = xmalloc(cursor-start + 1); 1502 (void) strncpy(s, line + start, cursor-start); 1503 s[cursor-start] = '\0'; 1504 return (s); 1505 } 1506 1507 #define tm_cmp(t1, t2) (\ 1508 (t1)->tm_year == (t2)->tm_year && \ 1509 (t1)->tm_mon == (t2)->tm_mon && \ 1510 (t1)->tm_mday == (t2)->tm_mday && \ 1511 (t1)->tm_hour == (t2)->tm_hour && \ 1512 (t1)->tm_min == (t2)->tm_min) 1513 1514 #define tm_setup(tp, yr, mon, dy, hr, min, dst) \ 1515 (tp)->tm_year = yr; \ 1516 (tp)->tm_mon = mon; \ 1517 (tp)->tm_mday = dy; \ 1518 (tp)->tm_hour = hr; \ 1519 (tp)->tm_min = min; \ 1520 (tp)->tm_isdst = dst; \ 1521 (tp)->tm_sec = 0; \ 1522 (tp)->tm_wday = 0; \ 1523 (tp)->tm_yday = 0; 1524 1525 /* 1526 * modification for bugid 1104537. the second argument to next_time is 1527 * now the value of time(2) to be used. if this is 0, then use the 1528 * current time. otherwise, the second argument is the time from which to 1529 * calculate things. this is useful to correct situations where you've 1530 * gone backwards in time (I.e. the system's internal clock is correcting 1531 * itself backwards). 1532 */ 1533 1534 1535 1536 static time_t 1537 tz_next_time(struct event *e, time_t tflag) 1538 { 1539 /* 1540 * returns the integer time for the next occurance of event e. 1541 * the following fields have ranges as indicated: 1542 * PRGM | min hour day of month mon day of week 1543 * ------|------------------------------------------------------- 1544 * cron | 0-59 0-23 1-31 1-12 0-6 (0=sunday) 1545 * time | 0-59 0-23 1-31 0-11 0-6 (0=sunday) 1546 * NOTE: this routine is hard to understand. 1547 */ 1548 1549 struct tm *tm, ref_tm, tmp, tmp1, tmp2; 1550 int tm_mon, tm_mday, tm_wday, wday, m, min, h, hr, carry, day, days; 1551 int d1, day1, carry1, d2, day2, carry2, daysahead, mon, yr, db, wd; 1552 int today; 1553 time_t t, ref_t, t1, t2, zone_start; 1554 int fallback; 1555 extern int days_btwn(int, int, int, int, int, int); 1556 1557 if (tflag == 0) { 1558 t = time(NULL); /* original way of doing things */ 1559 } else { 1560 t = tflag; 1561 } 1562 1563 tm = &ref_tm; /* use a local variable and call localtime_r() */ 1564 ref_t = t; /* keep a copy of the reference time */ 1565 1566 recalc: 1567 fallback = 0; 1568 1569 (void) localtime_r(&t, tm); 1570 1571 if (daylight) { 1572 tmp = *tm; 1573 tmp.tm_isdst = (tm->tm_isdst > 0 ? 0 : 1); 1574 t1 = xmktime(&tmp); 1575 /* 1576 * see if we will have timezone switch over, and clock will 1577 * fall back. zone_start will hold the time when it happens 1578 * (ie time of PST -> PDT switch over). 1579 */ 1580 if (tm->tm_isdst != tmp.tm_isdst && 1581 (t1 - t) == (timezone - altzone) && 1582 tm_cmp(tm, &tmp)) { 1583 zone_start = get_switching_time(tmp.tm_isdst, t); 1584 fallback = 1; 1585 } 1586 } 1587 1588 tm_mon = next_ge(tm->tm_mon + 1, e->of.ct.month) - 1; /* 0-11 */ 1589 tm_mday = next_ge(tm->tm_mday, e->of.ct.daymon); /* 1-31 */ 1590 tm_wday = next_ge(tm->tm_wday, e->of.ct.dayweek); /* 0-6 */ 1591 today = TRUE; 1592 if ((strcmp(e->of.ct.daymon, "*") == 0 && tm->tm_wday != tm_wday) || 1593 (strcmp(e->of.ct.dayweek, "*") == 0 && tm->tm_mday != tm_mday) || 1594 (tm->tm_mday != tm_mday && tm->tm_wday != tm_wday) || 1595 (tm->tm_mon != tm_mon)) { 1596 today = FALSE; 1597 } 1598 m = tm->tm_min + (t == ref_t ? 1 : 0); 1599 if ((tm->tm_hour + 1) <= next_ge(tm->tm_hour, e->of.ct.hour)) { 1600 m = 0; 1601 } 1602 min = next_ge(m%60, e->of.ct.minute); 1603 carry = (min < m) ? 1 : 0; 1604 h = tm->tm_hour + carry; 1605 hr = next_ge(h%24, e->of.ct.hour); 1606 carry = (hr < h) ? 1 : 0; 1607 1608 if (carry == 0 && today) { 1609 /* this event must occur today */ 1610 tm_setup(&tmp, tm->tm_year, tm->tm_mon, tm->tm_mday, 1611 hr, min, tm->tm_isdst); 1612 tmp1 = tmp; 1613 if ((t1 = xmktime(&tmp1)) == (time_t)-1) { 1614 return (0); 1615 } 1616 if (daylight && tmp.tm_isdst != tmp1.tm_isdst) { 1617 /* In case we are falling back */ 1618 if (fallback) { 1619 /* we may need to run the job once more. */ 1620 t = zone_start; 1621 goto recalc; 1622 } 1623 1624 /* 1625 * In case we are not in falling back period, 1626 * calculate the time assuming the DST. If the 1627 * date/time is not altered by mktime, it is the 1628 * time to execute the job. 1629 */ 1630 tmp2 = tmp; 1631 tmp2.tm_isdst = tmp1.tm_isdst; 1632 if ((t1 = xmktime(&tmp2)) == (time_t)-1) { 1633 return (0); 1634 } 1635 if (tmp1.tm_isdst == tmp2.tm_isdst && 1636 tm_cmp(&tmp, &tmp2)) { 1637 /* 1638 * We got a valid time. 1639 */ 1640 return (t1); 1641 } else { 1642 /* 1643 * If the date does not match even if 1644 * we assume the alternate timezone, then 1645 * it must be the invalid time. eg 1646 * 2am while switching 1:59am to 3am. 1647 * t1 should point the time before the 1648 * switching over as we've calculate the 1649 * time with assuming alternate zone. 1650 */ 1651 if (tmp1.tm_isdst != tmp2.tm_isdst) { 1652 t = get_switching_time(tmp1.tm_isdst, 1653 t1); 1654 } else { 1655 /* does this really happen? */ 1656 t = get_switching_time(tmp1.tm_isdst, 1657 t1 - abs(timezone - altzone)); 1658 } 1659 if (t == (time_t)-1) { 1660 return (0); 1661 } 1662 } 1663 goto recalc; 1664 } 1665 if (tm_cmp(&tmp, &tmp1)) { 1666 /* got valid time */ 1667 return (t1); 1668 } else { 1669 /* 1670 * This should never happen, but just in 1671 * case, we fall back to the old code. 1672 */ 1673 if (tm->tm_min > min) { 1674 t += (time_t)(hr-tm->tm_hour-1) * HOUR + 1675 (time_t)(60-tm->tm_min + min) * MINUTE; 1676 } else { 1677 t += (time_t)(hr-tm->tm_hour) * HOUR + 1678 (time_t)(min-tm->tm_min) * MINUTE; 1679 } 1680 t1 = t; 1681 t -= (time_t)tm->tm_sec; 1682 (void) localtime_r(&t, &tmp); 1683 if ((tm->tm_isdst == 0) && (tmp.tm_isdst > 0)) 1684 t -= (timezone - altzone); 1685 return ((t <= ref_t) ? t1 : t); 1686 } 1687 } 1688 1689 /* 1690 * Job won't run today, however if we have a switch over within 1691 * one hour and we will have one hour time drifting back in this 1692 * period, we may need to run the job one more time if the job was 1693 * set to run on this hour of clock. 1694 */ 1695 if (fallback) { 1696 t = zone_start; 1697 goto recalc; 1698 } 1699 1700 min = next_ge(0, e->of.ct.minute); 1701 hr = next_ge(0, e->of.ct.hour); 1702 1703 /* 1704 * calculate the date of the next occurance of this event, which 1705 * will be on a different day than the current 1706 */ 1707 1708 /* check monthly day specification */ 1709 d1 = tm->tm_mday + 1; 1710 day1 = next_ge((d1-1)%days_in_mon(tm->tm_mon, tm->tm_year) + 1, 1711 e->of.ct.daymon); 1712 carry1 = (day1 < d1) ? 1 : 0; 1713 1714 /* check weekly day specification */ 1715 d2 = tm->tm_wday + 1; 1716 wday = next_ge(d2%7, e->of.ct.dayweek); 1717 if (wday < d2) 1718 daysahead = 7 - d2 + wday; 1719 else 1720 daysahead = wday - d2; 1721 day2 = (d1 + daysahead-1)%days_in_mon(tm->tm_mon, tm->tm_year) + 1; 1722 carry2 = (day2 < d1) ? 1 : 0; 1723 1724 /* 1725 * based on their respective specifications, day1, and day2 give 1726 * the day of the month for the next occurance of this event. 1727 */ 1728 if ((strcmp(e->of.ct.daymon, "*") == 0) && 1729 (strcmp(e->of.ct.dayweek, "*") != 0)) { 1730 day1 = day2; 1731 carry1 = carry2; 1732 } 1733 if ((strcmp(e->of.ct.daymon, "*") != 0) && 1734 (strcmp(e->of.ct.dayweek, "*") == 0)) { 1735 day2 = day1; 1736 carry2 = carry1; 1737 } 1738 1739 yr = tm->tm_year; 1740 if ((carry1 && carry2) || (tm->tm_mon != tm_mon)) { 1741 /* event does not occur in this month */ 1742 m = tm->tm_mon + 1; 1743 mon = next_ge(m%12 + 1, e->of.ct.month) - 1; /* 0..11 */ 1744 carry = (mon < m) ? 1 : 0; 1745 yr += carry; 1746 /* recompute day1 and day2 */ 1747 day1 = next_ge(1, e->of.ct.daymon); 1748 db = days_btwn(tm->tm_mon, tm->tm_mday, tm->tm_year, mon, 1749 1, yr) + 1; 1750 wd = (tm->tm_wday + db)%7; 1751 /* wd is the day of the week of the first of month mon */ 1752 wday = next_ge(wd, e->of.ct.dayweek); 1753 if (wday < wd) 1754 day2 = 1 + 7 - wd + wday; 1755 else 1756 day2 = 1 + wday - wd; 1757 if ((strcmp(e->of.ct.daymon, "*") != 0) && 1758 (strcmp(e->of.ct.dayweek, "*") == 0)) 1759 day2 = day1; 1760 if ((strcmp(e->of.ct.daymon, "*") == 0) && 1761 (strcmp(e->of.ct.dayweek, "*") != 0)) 1762 day1 = day2; 1763 day = (day1 < day2) ? day1 : day2; 1764 } else { /* event occurs in this month */ 1765 mon = tm->tm_mon; 1766 if (!carry1 && !carry2) 1767 day = (day1 < day2) ? day1 : day2; 1768 else if (!carry1) 1769 day = day1; 1770 else 1771 day = day2; 1772 } 1773 1774 /* 1775 * now that we have the min, hr, day, mon, yr of the next event, 1776 * figure out what time that turns out to be. 1777 */ 1778 tm_setup(&tmp, yr, mon, day, hr, min, -1); 1779 tmp2 = tmp; 1780 if ((t1 = xmktime(&tmp2)) == (time_t)-1) { 1781 return (0); 1782 } 1783 if (tm_cmp(&tmp, &tmp2)) { 1784 /* 1785 * mktime returns clock for the current time zone. If the 1786 * target date was in fallback period, it needs to be adjusted 1787 * to the time comes first. 1788 * Suppose, we are at Jan and scheduling job at 1:30am10/26/03. 1789 * mktime returns the time in PST, but 1:30am in PDT comes 1790 * first. So reverse the tm_isdst, and see if we have such 1791 * time/date. 1792 */ 1793 if (daylight) { 1794 int dst = tmp2.tm_isdst; 1795 1796 tmp2 = tmp; 1797 tmp2.tm_isdst = (dst > 0 ? 0 : 1); 1798 if ((t2 = xmktime(&tmp2)) == (time_t)-1) { 1799 return (0); 1800 } 1801 if (tm_cmp(&tmp, &tmp2)) { 1802 /* 1803 * same time/date found in the opposite zone. 1804 * check the clock to see which comes early. 1805 */ 1806 if (t2 > ref_t && t2 < t1) { 1807 t1 = t2; 1808 } 1809 } 1810 } 1811 return (t1); 1812 } else { 1813 /* 1814 * mktime has set different time/date for the given date. 1815 * This means that the next job is scheduled to be run on the 1816 * invalid time. There are three possible invalid date/time. 1817 * 1. Non existing day of the month. such as April 31th. 1818 * 2. Feb 29th in the non-leap year. 1819 * 3. Time gap during the DST switch over. 1820 */ 1821 d1 = days_in_mon(mon, yr); 1822 if ((mon != 1 && day > d1) || (mon == 1 && day > 29)) { 1823 /* 1824 * see if we have got a specific date which 1825 * is invalid. 1826 */ 1827 if (strcmp(e->of.ct.dayweek, "*") == 0 && 1828 mon == (next_ge((mon + 1)%12 + 1, 1829 e->of.ct.month) - 1) && 1830 day <= next_ge(1, e->of.ct.daymon)) { 1831 /* job never run */ 1832 return (0); 1833 } 1834 /* 1835 * Since the day has gone invalid, we need to go to 1836 * next month, and recalcuate the first occurrence. 1837 * eg the cron tab such as: 1838 * 0 0 1,15,31 1,2,3,4,5 * /usr/bin.... 1839 * 2/31 is invalid, so the next job is 3/1. 1840 */ 1841 tmp2 = tmp; 1842 tmp2.tm_min = 0; 1843 tmp2.tm_hour = 0; 1844 tmp2.tm_mday = 1; /* 1st day of the month */ 1845 if (mon == 11) { 1846 tmp2.tm_mon = 0; 1847 tmp2.tm_year = yr + 1; 1848 } else { 1849 tmp2.tm_mon = mon + 1; 1850 } 1851 if ((t = xmktime(&tmp2)) == (time_t)-1) { 1852 return (0); 1853 } 1854 } else if (mon == 1 && day > d1) { 1855 /* 1856 * ie 29th in the non-leap year. Forwarding the 1857 * clock to Feb 29th 00:00 (March 1st), and recalculate 1858 * the next time. 1859 */ 1860 tmp2 = tmp; 1861 tmp2.tm_min = 0; 1862 tmp2.tm_hour = 0; 1863 if ((t = xmktime(&tmp2)) == (time_t)-1) { 1864 return (0); 1865 } 1866 } else if (daylight) { 1867 /* 1868 * Non existing time, eg 2am PST during summer time 1869 * switch. 1870 * We need to get the correct isdst which we are 1871 * swithing to, by adding time difference to make sure 1872 * that t2 is in the zone being switched. 1873 */ 1874 t2 = t1; 1875 t2 += abs(timezone - altzone); 1876 (void) localtime_r(&t2, &tmp2); 1877 zone_start = get_switching_time(tmp2.tm_isdst, 1878 t1 - abs(timezone - altzone)); 1879 if (zone_start == (time_t)-1) { 1880 return (0); 1881 } 1882 t = zone_start; 1883 } else { 1884 /* 1885 * This should never happen, but fall back to the 1886 * old code. 1887 */ 1888 days = days_btwn(tm->tm_mon, 1889 tm->tm_mday, tm->tm_year, mon, day, yr); 1890 t += (time_t)(23-tm->tm_hour)*HOUR 1891 + (time_t)(60-tm->tm_min)*MINUTE 1892 + (time_t)hr*HOUR + (time_t)min*MINUTE 1893 + (time_t)days*DAY; 1894 t1 = t; 1895 t -= (time_t)tm->tm_sec; 1896 (void) localtime_r(&t, &tmp); 1897 if ((tm->tm_isdst == 0) && (tmp.tm_isdst > 0)) 1898 t -= (timezone - altzone); 1899 return (t <= ref_t ? t1 : t); 1900 } 1901 goto recalc; 1902 } 1903 /*NOTREACHED*/ 1904 } 1905 1906 static time_t 1907 next_time(struct event *e, time_t tflag) 1908 { 1909 if (e->of.ct.tz != NULL) { 1910 time_t ret; 1911 1912 (void) putenv((char *)get_obj(e->of.ct.tz)); 1913 tzset(); 1914 ret = tz_next_time(e, tflag); 1915 (void) putenv(tzone); 1916 tzset(); 1917 return (ret); 1918 } else { 1919 return (tz_next_time(e, tflag)); 1920 } 1921 } 1922 1923 /* 1924 * This returns TOD in time_t that zone switch will happen, and this 1925 * will be called when clock fallback is about to happen. 1926 * (ie 30minutes before the time of PST -> PDT switch. 2:00 AM PST 1927 * will fall back to 1:00 PDT. So this function will be called only 1928 * for the time between 1:00 AM PST and 2:00 PST(1:00 PST)). 1929 * First goes through the common time differences to see if zone 1930 * switch happens at those minutes later. If not, check every minutes 1931 * until 6 hours ahead see if it happens(We might have 45minutes 1932 * fallback). 1933 */ 1934 static time_t 1935 get_switching_time(int to_dst, time_t t_ref) 1936 { 1937 time_t t, t1; 1938 struct tm tmp, tmp1; 1939 int hints[] = { 60, 120, 30, 90, 0}; /* minutes */ 1940 int i; 1941 1942 (void) localtime_r(&t_ref, &tmp); 1943 tmp1 = tmp; 1944 tmp1.tm_sec = 0; 1945 tmp1.tm_min = 0; 1946 if ((t = xmktime(&tmp1)) == (time_t)-1) 1947 return ((time_t)-1); 1948 1949 /* fast path */ 1950 for (i = 0; hints[i] != 0; i++) { 1951 t1 = t + hints[i] * 60; 1952 (void) localtime_r(&t1, &tmp1); 1953 if (tmp1.tm_isdst == to_dst) { 1954 t1--; 1955 (void) localtime_r(&t1, &tmp1); 1956 if (tmp1.tm_isdst != to_dst) { 1957 return (t1 + 1); 1958 } 1959 } 1960 } 1961 1962 /* ugly, but don't know other than this. */ 1963 tmp1 = tmp; 1964 tmp1.tm_sec = 0; 1965 if ((t = xmktime(&tmp1)) == (time_t)-1) 1966 return ((time_t)-1); 1967 while (t < (t_ref + 6*60*60)) { /* 6 hours should be enough */ 1968 t += 60; /* at least one minute, I assume */ 1969 (void) localtime_r(&t, &tmp); 1970 if (tmp.tm_isdst == to_dst) 1971 return (t); 1972 } 1973 return ((time_t)-1); 1974 } 1975 1976 static time_t 1977 xmktime(struct tm *tmp) 1978 { 1979 time_t ret; 1980 1981 if ((ret = mktime(tmp)) == (time_t)-1) { 1982 if (errno == EOVERFLOW) { 1983 return ((time_t)-1); 1984 } 1985 crabort("internal error: mktime failed", 1986 REMOVE_FIFO|CONSOLE_MSG); 1987 } 1988 return (ret); 1989 } 1990 1991 #define DUMMY 100 1992 1993 static int 1994 next_ge(int current, char *list) 1995 { 1996 /* 1997 * list is a character field as in a crontab file; 1998 * for example: "40, 20, 50-10" 1999 * next_ge returns the next number in the list that is 2000 * greater than or equal to current. if no numbers of list 2001 * are >= current, the smallest element of list is returned. 2002 * NOTE: current must be in the appropriate range. 2003 */ 2004 2005 char *ptr; 2006 int n, n2, min, min_gt; 2007 2008 if (strcmp(list, "*") == 0) 2009 return (current); 2010 ptr = list; 2011 min = DUMMY; 2012 min_gt = DUMMY; 2013 for (;;) { 2014 if ((n = (int)num(&ptr)) == current) 2015 return (current); 2016 if (n < min) 2017 min = n; 2018 if ((n > current) && (n < min_gt)) 2019 min_gt = n; 2020 if (*ptr == '-') { 2021 ptr++; 2022 if ((n2 = (int)num(&ptr)) > n) { 2023 if ((current > n) && (current <= n2)) 2024 return (current); 2025 } else { /* range that wraps around */ 2026 if (current > n) 2027 return (current); 2028 if (current <= n2) 2029 return (current); 2030 } 2031 } 2032 if (*ptr == '\0') 2033 break; 2034 ptr += 1; 2035 } 2036 if (min_gt != DUMMY) 2037 return (min_gt); 2038 else 2039 return (min); 2040 } 2041 2042 static void 2043 free_if_unused(struct usr *u) 2044 { 2045 struct usr *cur, *prev; 2046 /* 2047 * To make sure a usr structure is idle we must check that 2048 * there are no at jobs queued for the user; the user does 2049 * not have a crontab, and also that there are no running at 2050 * or cron jobs (since the runinfo structure also has a 2051 * pointer to the usr structure). 2052 */ 2053 if (!u->ctexists && u->atevents == NULL && 2054 u->cruncnt == 0 && u->aruncnt == 0) { 2055 #ifdef DEBUG 2056 (void) fprintf(stderr, "%s removed from usr list\n", u->name); 2057 #endif 2058 for (cur = uhead, prev = NULL; 2059 cur != u; 2060 prev = cur, cur = cur->nextusr) { 2061 if (cur == NULL) { 2062 return; 2063 } 2064 } 2065 2066 if (prev == NULL) 2067 uhead = u->nextusr; 2068 else 2069 prev->nextusr = u->nextusr; 2070 free(u->name); 2071 free(u->home); 2072 free(u); 2073 } 2074 } 2075 2076 static void 2077 del_atjob(char *name, char *usrname) 2078 { 2079 2080 struct event *e, *eprev; 2081 struct usr *u; 2082 2083 if ((u = find_usr(usrname)) == NULL) 2084 return; 2085 e = u->atevents; 2086 eprev = NULL; 2087 while (e != NULL) { 2088 if (strcmp(name, e->cmd) == 0) { 2089 if (next_event == e) 2090 next_event = NULL; 2091 if (eprev == NULL) 2092 u->atevents = e->link; 2093 else 2094 eprev->link = e->link; 2095 el_remove(e->of.at.eventid, 1); 2096 free(e->cmd); 2097 free(e); 2098 break; 2099 } else { 2100 eprev = e; 2101 e = e->link; 2102 } 2103 } 2104 2105 free_if_unused(u); 2106 } 2107 2108 static void 2109 del_ctab(char *name) 2110 { 2111 2112 struct usr *u; 2113 2114 if ((u = find_usr(name)) == NULL) 2115 return; 2116 rm_ctevents(u); 2117 el_remove(u->ctid, 0); 2118 u->ctid = 0; 2119 u->ctexists = 0; 2120 2121 free_if_unused(u); 2122 } 2123 2124 static void 2125 rm_ctevents(struct usr *u) 2126 { 2127 struct event *e2, *e3; 2128 2129 /* 2130 * see if the next event (to be run by cron) is a cronevent 2131 * owned by this user. 2132 */ 2133 2134 if ((next_event != NULL) && 2135 (next_event->etype == CRONEVENT) && 2136 (next_event->u == u)) { 2137 next_event = NULL; 2138 } 2139 e2 = u->ctevents; 2140 while (e2 != NULL) { 2141 free(e2->cmd); 2142 rel_shared(e2->of.ct.tz); 2143 rel_shared(e2->of.ct.shell); 2144 rel_shared(e2->of.ct.home); 2145 free(e2->of.ct.minute); 2146 free(e2->of.ct.hour); 2147 free(e2->of.ct.daymon); 2148 free(e2->of.ct.month); 2149 free(e2->of.ct.dayweek); 2150 if (e2->of.ct.input != NULL) 2151 free(e2->of.ct.input); 2152 e3 = e2->link; 2153 free(e2); 2154 e2 = e3; 2155 } 2156 u->ctevents = NULL; 2157 } 2158 2159 2160 static struct usr * 2161 find_usr(char *uname) 2162 { 2163 struct usr *u; 2164 2165 u = uhead; 2166 while (u != NULL) { 2167 if (strcmp(u->name, uname) == 0) 2168 return (u); 2169 u = u->nextusr; 2170 } 2171 return (NULL); 2172 } 2173 2174 /* 2175 * Execute cron command or at/batch job. 2176 * If ever a premature return is added to this function pay attention to 2177 * free at_cmdfile and outfile plus jobname buffers of the runinfo structure. 2178 */ 2179 static int 2180 ex(struct event *e) 2181 { 2182 int r; 2183 int fd; 2184 pid_t rfork; 2185 FILE *atcmdfp; 2186 char mailvar[4]; 2187 char *at_cmdfile = NULL; 2188 struct stat buf; 2189 struct queue *qp; 2190 struct runinfo *rp; 2191 struct project proj, *pproj = NULL; 2192 union { 2193 struct { 2194 char buf[PROJECT_BUFSZ]; 2195 char buf2[PROJECT_BUFSZ]; 2196 } p; 2197 char error[CANT_STR_LEN + PATH_MAX]; 2198 } bufs; 2199 char *tmpfile; 2200 FILE *fptr; 2201 time_t dhltime; 2202 projid_t projid; 2203 int projflag = 0; 2204 char *home; 2205 char *sh; 2206 2207 qp = &qt[e->etype]; /* set pointer to queue defs */ 2208 if (qp->nrun >= qp->njob) { 2209 msg("%c queue max run limit reached", e->etype + 'a'); 2210 resched(qp->nwait); 2211 return (0); 2212 } 2213 2214 rp = rinfo_get(0); /* allocating a new runinfo struct */ 2215 2216 /* 2217 * the tempnam() function uses malloc(3C) to allocate space for the 2218 * constructed file name, and returns a pointer to this area, which 2219 * is assigned to rp->outfile. Here rp->outfile is not overwritten. 2220 */ 2221 2222 rp->outfile = tempnam(TMPDIR, PFX); 2223 rp->jobtype = e->etype; 2224 if (e->etype == CRONEVENT) { 2225 rp->jobname = xmalloc(strlen(e->cmd) + 1); 2226 (void) strcpy(rp->jobname, e->cmd); 2227 /* "cron" jobs only produce mail if there's output */ 2228 rp->mailwhendone = 0; 2229 } else { 2230 at_cmdfile = xmalloc(strlen(ATDIR) + strlen(e->cmd) + 2); 2231 (void) sprintf(at_cmdfile, "%s/%s", ATDIR, e->cmd); 2232 if ((atcmdfp = fopen(at_cmdfile, "r")) == NULL) { 2233 if (errno == ENAMETOOLONG) { 2234 if (chdir(ATDIR) == 0) 2235 cron_unlink(e->cmd); 2236 } else { 2237 cron_unlink(at_cmdfile); 2238 } 2239 mail((e->u)->name, BADJOBOPEN, ERR_CANTEXECAT); 2240 free(at_cmdfile); 2241 rinfo_free(rp); 2242 return (0); 2243 } 2244 rp->jobname = xmalloc(strlen(at_cmdfile) + 1); 2245 (void) strcpy(rp->jobname, at_cmdfile); 2246 2247 /* 2248 * Skip over the first two lines. 2249 */ 2250 (void) fscanf(atcmdfp, "%*[^\n]\n"); 2251 (void) fscanf(atcmdfp, "%*[^\n]\n"); 2252 if (fscanf(atcmdfp, ": notify by mail: %3s%*[^\n]\n", 2253 mailvar) == 1) { 2254 /* 2255 * Check to see if we should always send mail 2256 * to the owner. 2257 */ 2258 rp->mailwhendone = (strcmp(mailvar, "yes") == 0); 2259 } else { 2260 rp->mailwhendone = 0; 2261 } 2262 2263 if (fscanf(atcmdfp, "\n: project: %d\n", &projid) == 1) { 2264 projflag = 1; 2265 } 2266 (void) fclose(atcmdfp); 2267 } 2268 2269 /* 2270 * we make sure that the system time 2271 * hasn't drifted backwards. if it has, el_add() is now 2272 * called, to make sure that the event queue is back in order, 2273 * and we set the delayed flag. cron will pick up the request 2274 * later on at the proper time. 2275 */ 2276 dhltime = time(NULL); 2277 if ((dhltime - e->time) < 0) { 2278 msg("clock time drifted backwards!\n"); 2279 if (next_event->etype == CRONEVENT) { 2280 msg("correcting cron event\n"); 2281 next_event->time = next_time(next_event, dhltime); 2282 switch (el_add(next_event, next_event->time, 2283 (next_event->u)->ctid)) { 2284 case -1: 2285 ignore_msg("ex", "cron", next_event); 2286 break; 2287 case -2: /* event time lower than init time */ 2288 reset_needed = 1; 2289 break; 2290 } 2291 } else { /* etype == ATEVENT */ 2292 msg("correcting batch event\n"); 2293 if (el_add(next_event, next_event->time, 2294 next_event->of.at.eventid) < 0) { 2295 ignore_msg("ex", "at", next_event); 2296 } 2297 } 2298 delayed++; 2299 t_old = time(NULL); 2300 free(at_cmdfile); 2301 rinfo_free(rp); 2302 return (0); 2303 } 2304 2305 if ((rfork = fork()) == (pid_t)-1) { 2306 reap_child(); 2307 if ((rfork = fork()) == (pid_t)-1) { 2308 msg("cannot fork"); 2309 free(at_cmdfile); 2310 rinfo_free(rp); 2311 resched(60); 2312 (void) sleep(30); 2313 return (0); 2314 } 2315 } 2316 if (rfork) { /* parent process */ 2317 contract_abandon_latest(rfork); 2318 2319 ++qp->nrun; 2320 rp->pid = rfork; 2321 rp->que = e->etype; 2322 if (e->etype != CRONEVENT) 2323 (e->u)->aruncnt++; 2324 else 2325 (e->u)->cruncnt++; 2326 rp->rusr = (e->u); 2327 logit(BCHAR, rp, 0); 2328 free(at_cmdfile); 2329 2330 return (0); 2331 } 2332 2333 child_sigreset(); 2334 contract_clear_template(); 2335 2336 if (e->etype != CRONEVENT) { 2337 /* open jobfile as stdin to shell */ 2338 if (stat(at_cmdfile, &buf)) { 2339 if (errno == ENAMETOOLONG) { 2340 if (chdir(ATDIR) == 0) 2341 cron_unlink(e->cmd); 2342 } else 2343 cron_unlink(at_cmdfile); 2344 mail((e->u)->name, BADJOBOPEN, ERR_CANTEXECCRON); 2345 exit(1); 2346 } 2347 if (!(buf.st_mode&ISUID)) { 2348 /* 2349 * if setuid bit off, original owner has 2350 * given this file to someone else 2351 */ 2352 cron_unlink(at_cmdfile); 2353 exit(1); 2354 } 2355 if ((fd = open(at_cmdfile, O_RDONLY)) == -1) { 2356 mail((e->u)->name, BADJOBOPEN, ERR_CANTEXECCRON); 2357 cron_unlink(at_cmdfile); 2358 exit(1); 2359 } 2360 if (fd != 0) { 2361 (void) dup2(fd, 0); 2362 (void) close(fd); 2363 } 2364 /* 2365 * retrieve the project id of the at job and convert it 2366 * to a project name. fail if it's not a valid project 2367 * or if the user isn't a member of the project. 2368 */ 2369 if (projflag == 1) { 2370 if ((pproj = getprojbyid(projid, &proj, 2371 (void *)&bufs.p.buf, 2372 sizeof (bufs.p.buf))) == NULL || 2373 !inproj(e->u->name, pproj->pj_name, 2374 bufs.p.buf2, sizeof (bufs.p.buf2))) { 2375 cron_unlink(at_cmdfile); 2376 mail((e->u)->name, BADPROJID, ERR_CANTEXECAT); 2377 exit(1); 2378 } 2379 } 2380 } 2381 2382 /* 2383 * Put process in a new session, and create a new task. 2384 */ 2385 if (setsid() < 0) { 2386 msg("setsid failed with errno = %d. job failed (%s)" 2387 " for user %s", errno, e->cmd, e->u->name); 2388 if (e->etype != CRONEVENT) 2389 cron_unlink(at_cmdfile); 2390 exit(1); 2391 } 2392 2393 /* 2394 * set correct user identification and check his account 2395 */ 2396 r = set_user_cred(e->u, pproj); 2397 if (r == VUC_EXPIRED) { 2398 msg("user (%s) account is expired", e->u->name); 2399 audit_cron_user_acct_expired(e->u->name); 2400 clean_out_user(e->u); 2401 exit(1); 2402 } 2403 if (r == VUC_NEW_AUTH) { 2404 msg("user (%s) password has expired", e->u->name); 2405 audit_cron_user_acct_expired(e->u->name); 2406 clean_out_user(e->u); 2407 exit(1); 2408 } 2409 if (r != VUC_OK) { 2410 msg("bad user (%s)", e->u->name); 2411 audit_cron_bad_user(e->u->name); 2412 clean_out_user(e->u); 2413 exit(1); 2414 } 2415 /* 2416 * check user and initialize the supplementary group access list. 2417 * bugid 1230784: deleted from parent to avoid cron hang. Now 2418 * only child handles the call. 2419 */ 2420 2421 if (verify_user_cred(e->u) != VUC_OK || 2422 setgid(e->u->gid) == -1 || 2423 initgroups(e->u->name, e->u->gid) == -1) { 2424 msg("bad user (%s) or setgid failed (%s)", 2425 e->u->name, e->u->name); 2426 audit_cron_bad_user(e->u->name); 2427 clean_out_user(e->u); 2428 exit(1); 2429 } 2430 2431 if ((e->u)->uid == 0) { /* set default path */ 2432 /* path settable in defaults file */ 2433 envinit[2] = supath; 2434 } else { 2435 envinit[2] = path; 2436 } 2437 2438 if (e->etype != CRONEVENT) { 2439 r = audit_cron_session(e->u->name, NULL, 2440 e->u->uid, e->u->gid, at_cmdfile); 2441 cron_unlink(at_cmdfile); 2442 } else { 2443 r = audit_cron_session(e->u->name, CRONDIR, 2444 e->u->uid, e->u->gid, NULL); 2445 } 2446 if (r != 0) { 2447 msg("cron audit problem. job failed (%s) for user %s", 2448 e->cmd, e->u->name); 2449 exit(1); 2450 } 2451 2452 audit_cron_new_job(e->cmd, e->etype, (void *)e); 2453 2454 if (setuid(e->u->uid) == -1) { 2455 msg("setuid failed (%s)", e->u->name); 2456 clean_out_user(e->u); 2457 exit(1); 2458 } 2459 2460 if (e->etype == CRONEVENT) { 2461 /* check for standard input to command */ 2462 if (e->of.ct.input != NULL) { 2463 if ((tmpfile = strdup(TMPINFILE)) == NULL) { 2464 mail((e->u)->name, MALLOCERR, 2465 ERR_CANTEXECCRON); 2466 exit(1); 2467 } 2468 if ((fd = mkstemp(tmpfile)) == -1 || 2469 (fptr = fdopen(fd, "w")) == NULL) { 2470 mail((e->u)->name, NOSTDIN, 2471 ERR_CANTEXECCRON); 2472 cron_unlink(tmpfile); 2473 free(tmpfile); 2474 exit(1); 2475 } 2476 if ((fwrite(e->of.ct.input, sizeof (char), 2477 strlen(e->of.ct.input), fptr)) != 2478 strlen(e->of.ct.input)) { 2479 mail((e->u)->name, NOSTDIN, ERR_CANTEXECCRON); 2480 cron_unlink(tmpfile); 2481 free(tmpfile); 2482 (void) close(fd); 2483 (void) fclose(fptr); 2484 exit(1); 2485 } 2486 if (fseek(fptr, (off_t)0, SEEK_SET) != -1) { 2487 if (fd != 0) { 2488 (void) dup2(fd, 0); 2489 (void) close(fd); 2490 } 2491 } 2492 cron_unlink(tmpfile); 2493 free(tmpfile); 2494 (void) fclose(fptr); 2495 } else if ((fd = open("/dev/null", O_RDONLY)) > 0) { 2496 (void) dup2(fd, 0); 2497 (void) close(fd); 2498 } 2499 } 2500 2501 /* redirect stdout and stderr for the shell */ 2502 if ((fd = open(rp->outfile, O_WRONLY|O_CREAT|O_EXCL, OUTMODE)) == 1) 2503 fd = open("/dev/null", O_WRONLY); 2504 2505 if (fd >= 0 && fd != 1) 2506 (void) dup2(fd, 1); 2507 2508 if (fd >= 0 && fd != 2) { 2509 (void) dup2(fd, 2); 2510 if (fd != 1) 2511 (void) close(fd); 2512 } 2513 2514 if (e->etype == CRONEVENT && e->of.ct.home != NULL) { 2515 home = (char *)get_obj(e->of.ct.home); 2516 } else { 2517 home = (e->u)->home; 2518 } 2519 (void) strlcat(homedir, home, sizeof (homedir)); 2520 (void) strlcat(logname, (e->u)->name, sizeof (logname)); 2521 environ = envinit; 2522 if (chdir(home) == -1) { 2523 snprintf(bufs.error, sizeof (bufs.error), CANTCDHOME, home); 2524 mail((e->u)->name, bufs.error, 2525 e->etype == CRONEVENT ? ERR_CANTEXECCRON : 2526 ERR_CANTEXECAT); 2527 exit(1); 2528 } 2529 #ifdef TESTING 2530 exit(1); 2531 #endif 2532 /* 2533 * make sure that all file descriptors EXCEPT 0, 1 and 2 2534 * will be closed. 2535 */ 2536 closefrom(3); 2537 2538 if ((e->u)->uid != 0) 2539 (void) nice(qp->nice); 2540 if (e->etype == CRONEVENT) { 2541 if (e->of.ct.tz) { 2542 (void) putenv((char *)get_obj(e->of.ct.tz)); 2543 } 2544 if (e->of.ct.shell) { 2545 char *name; 2546 2547 sh = (char *)get_obj(e->of.ct.shell); 2548 name = strrchr(sh, '/'); 2549 if (name == NULL) 2550 name = sh; 2551 else 2552 name++; 2553 2554 (void) putenv(sh); 2555 sh += strlen(ENV_SHELL); 2556 (void) execl(sh, name, "-c", e->cmd, 0); 2557 } else { 2558 (void) execl(SHELL, "sh", "-c", e->cmd, 0); 2559 sh = SHELL; 2560 } 2561 } else { /* type == ATEVENT */ 2562 (void) execl(SHELL, "sh", 0); 2563 sh = SHELL; 2564 } 2565 snprintf(bufs.error, sizeof (bufs.error), CANTEXECSH, sh); 2566 mail((e->u)->name, bufs.error, 2567 e->etype == CRONEVENT ? ERR_CANTEXECCRON : ERR_CANTEXECAT); 2568 exit(1); 2569 /*NOTREACHED*/ 2570 } 2571 2572 /* 2573 * Main idle loop. 2574 * When timed out to run the job, return 0. 2575 * If for some reasons we need to reschedule jobs, return 1. 2576 */ 2577 static int 2578 idle(long t) 2579 { 2580 time_t now; 2581 2582 refresh = 0; 2583 2584 while (t > 0L) { 2585 if (msg_wait(t) != 0) { 2586 /* we need to run next job immediately */ 2587 return (0); 2588 } 2589 2590 reap_child(); 2591 2592 if (refresh) { 2593 /* We got THAW or REFRESH message */ 2594 return (1); 2595 } 2596 2597 now = time(NULL); 2598 if (last_time > now) { 2599 /* clock has been reset to backward */ 2600 return (1); 2601 } 2602 2603 if (next_event == NULL && !el_empty()) { 2604 next_event = (struct event *)el_first(); 2605 } 2606 2607 if (next_event == NULL) 2608 t = INFINITY; 2609 else 2610 t = (long)next_event->time - now; 2611 } 2612 return (0); 2613 } 2614 2615 /* 2616 * This used to be in the idle(), but moved to the separate function. 2617 * This called from various place when cron needs to reap the 2618 * child. It includes the situation that cron hit maxrun, and needs 2619 * to reschedule the job. 2620 */ 2621 static void 2622 reap_child() 2623 { 2624 pid_t pid; 2625 int prc; 2626 struct runinfo *rp; 2627 2628 for (;;) { 2629 pid = waitpid((pid_t)-1, &prc, WNOHANG); 2630 if (pid <= 0) 2631 break; 2632 #ifdef DEBUG 2633 fprintf(stderr, 2634 "wait returned %x for process %d\n", prc, pid); 2635 #endif 2636 if ((rp = rinfo_get(pid)) == NULL) { 2637 if (miscpid_delete(pid) == 0) { 2638 /* not found in anywhere */ 2639 msg(PIDERR, pid); 2640 } 2641 } else if (rp->que == ZOMB) { 2642 (void) unlink(rp->outfile); 2643 rinfo_free(rp); 2644 } else { 2645 cleanup(rp, prc); 2646 } 2647 } 2648 } 2649 2650 static void 2651 cleanup(struct runinfo *pr, int rc) 2652 { 2653 int nextfork = 1; 2654 struct usr *p; 2655 struct stat buf; 2656 2657 logit(ECHAR, pr, rc); 2658 --qt[pr->que].nrun; 2659 p = pr->rusr; 2660 if (pr->que != CRONEVENT) 2661 --p->aruncnt; 2662 else 2663 --p->cruncnt; 2664 2665 if (lstat(pr->outfile, &buf) == 0) { 2666 if (!S_ISLNK(buf.st_mode) && 2667 (buf.st_size > 0 || pr->mailwhendone)) { 2668 /* mail user stdout and stderr */ 2669 for (;;) { 2670 if ((pr->pid = fork()) < 0) { 2671 /* 2672 * if fork fails try forever in doubling 2673 * retry times, up to 16 seconds 2674 */ 2675 (void) sleep(nextfork); 2676 if (nextfork < 16) 2677 nextfork += nextfork; 2678 continue; 2679 } else if (pr->pid == 0) { 2680 child_sigreset(); 2681 contract_clear_template(); 2682 2683 mail_result(p, pr, buf.st_size); 2684 /* NOTREACHED */ 2685 } else { 2686 contract_abandon_latest(pr->pid); 2687 pr->que = ZOMB; 2688 break; 2689 } 2690 } 2691 } else { 2692 (void) unlink(pr->outfile); 2693 rinfo_free(pr); 2694 } 2695 } else { 2696 rinfo_free(pr); 2697 } 2698 2699 free_if_unused(p); 2700 } 2701 2702 /* 2703 * Mail stdout and stderr of a job to user. Get uid for real user and become 2704 * that person. We do this so that mail won't come from root since this 2705 * could be a security hole. If failure, quit - don't send mail as root. 2706 */ 2707 static void 2708 mail_result(struct usr *p, struct runinfo *pr, size_t filesize) 2709 { 2710 struct passwd *ruser_ids; 2711 FILE *mailpipe; 2712 FILE *st; 2713 struct utsname name; 2714 int nbytes; 2715 char iobuf[BUFSIZ]; 2716 char *cmd; 2717 char *lowname = (pr->jobtype == CRONEVENT ? "cron" : "at"); 2718 2719 (void) uname(&name); 2720 if ((ruser_ids = getpwnam(p->name)) == NULL) 2721 exit(0); 2722 (void) setuid(ruser_ids->pw_uid); 2723 2724 cmd = xmalloc(strlen(MAIL) + strlen(p->name)+2); 2725 (void) sprintf(cmd, "%s %s", MAIL, p->name); 2726 mailpipe = popen(cmd, "w"); 2727 free(cmd); 2728 if (mailpipe == NULL) 2729 exit(127); 2730 (void) fprintf(mailpipe, "To: %s\n", p->name); 2731 (void) fprintf(mailpipe, "Subject: %s <%s@%s> %s\n", 2732 (pr->jobtype == CRONEVENT ? "Cron" : "At"), 2733 p->name, name.nodename, pr->jobname); 2734 2735 /* 2736 * RFC3834 (Section 5) defines the Auto-Submitted header to prevent 2737 * vacation replies, et al, from being sent in response to 2738 * machine-generated mail. 2739 */ 2740 (void) fprintf(mailpipe, "Auto-Submitted: auto-generated\n"); 2741 2742 /* 2743 * Additional headers for mail filtering and diagnostics: 2744 */ 2745 (void) fprintf(mailpipe, "X-Mailer: cron (%s %s)\n", name.sysname, 2746 name.release); 2747 (void) fprintf(mailpipe, "X-Cron-User: %s\n", p->name); 2748 (void) fprintf(mailpipe, "X-Cron-Host: %s\n", name.nodename); 2749 (void) fprintf(mailpipe, "X-Cron-Job-Name: %s\n", pr->jobname); 2750 (void) fprintf(mailpipe, "X-Cron-Job-Type: %s\n", lowname); 2751 2752 /* 2753 * Message Body: 2754 * 2755 * (Temporary file is fopen'ed with "r", secure open.) 2756 */ 2757 (void) fprintf(mailpipe, "\n"); 2758 if (filesize > 0 && 2759 (st = fopen(pr->outfile, "r")) != NULL) { 2760 while ((nbytes = fread(iobuf, sizeof (char), BUFSIZ, st)) != 0) 2761 (void) fwrite(iobuf, sizeof (char), nbytes, mailpipe); 2762 (void) fclose(st); 2763 } else { 2764 (void) fprintf(mailpipe, "Job completed with no output.\n"); 2765 } 2766 (void) pclose(mailpipe); 2767 exit(0); 2768 } 2769 2770 static int 2771 msg_wait(long tim) 2772 { 2773 struct message msg; 2774 int cnt; 2775 time_t reftime; 2776 fd_set fds; 2777 struct timespec tout, *toutp; 2778 static int pending_msg; 2779 static time_t pending_reftime; 2780 2781 if (pending_msg) { 2782 process_msg(&msgbuf, pending_reftime); 2783 pending_msg = 0; 2784 return (0); 2785 } 2786 2787 FD_ZERO(&fds); 2788 FD_SET(msgfd, &fds); 2789 2790 toutp = NULL; 2791 if (tim != INFINITY) { 2792 #ifdef CRON_MAXSLEEP 2793 /* 2794 * CRON_MAXSLEEP can be defined to have cron periodically wake 2795 * up, so that cron can detect a change of TOD and adjust the 2796 * sleep time more frequently. 2797 */ 2798 tim = (tim > CRON_MAXSLEEP) ? CRON_MAXSLEEP : tim; 2799 #endif 2800 tout.tv_nsec = 0; 2801 tout.tv_sec = tim; 2802 toutp = &tout; 2803 } 2804 2805 cnt = pselect(msgfd + 1, &fds, NULL, NULL, toutp, &defmask); 2806 if (cnt == -1 && errno != EINTR) 2807 perror("! pselect"); 2808 2809 /* pselect timeout or interrupted */ 2810 if (cnt <= 0) 2811 return (0); 2812 2813 errno = 0; 2814 if ((cnt = read(msgfd, &msg, sizeof (msg))) != sizeof (msg)) { 2815 if (cnt != -1 || errno != EAGAIN) 2816 perror("! read"); 2817 return (0); 2818 } 2819 reftime = time(NULL); 2820 if (next_event != NULL && reftime >= next_event->time) { 2821 /* 2822 * we need to run the job before reloading crontab. 2823 */ 2824 (void) memcpy(&msgbuf, &msg, sizeof (msg)); 2825 pending_msg = 1; 2826 pending_reftime = reftime; 2827 return (1); 2828 } 2829 process_msg(&msg, reftime); 2830 return (0); 2831 } 2832 2833 /* 2834 * process the message supplied via pipe. This will be called either 2835 * immediately after cron read the message from pipe, or idle time 2836 * if the message was pending due to the job execution. 2837 */ 2838 static void 2839 process_msg(struct message *pmsg, time_t reftime) 2840 { 2841 if (pmsg->etype == NULL) 2842 return; 2843 2844 switch (pmsg->etype) { 2845 case AT: 2846 if (pmsg->action == DELETE) 2847 del_atjob(pmsg->fname, pmsg->logname); 2848 else 2849 mod_atjob(pmsg->fname, (time_t)0); 2850 break; 2851 case CRON: 2852 if (pmsg->action == DELETE) 2853 del_ctab(pmsg->fname); 2854 else 2855 mod_ctab(pmsg->fname, reftime); 2856 break; 2857 case REFRESH: 2858 refresh = 1; 2859 pmsg->etype = 0; 2860 return; 2861 default: 2862 msg("message received - bad format"); 2863 break; 2864 } 2865 if (next_event != NULL) { 2866 if (next_event->etype == CRONEVENT) { 2867 switch (el_add(next_event, next_event->time, 2868 (next_event->u)->ctid)) { 2869 case -1: 2870 ignore_msg("process_msg", "cron", next_event); 2871 break; 2872 case -2: /* event time lower than init time */ 2873 reset_needed = 1; 2874 break; 2875 } 2876 } else { /* etype == ATEVENT */ 2877 if (el_add(next_event, next_event->time, 2878 next_event->of.at.eventid) < 0) { 2879 ignore_msg("process_msg", "at", next_event); 2880 } 2881 } 2882 next_event = NULL; 2883 } 2884 (void) fflush(stdout); 2885 pmsg->etype = 0; 2886 } 2887 2888 /* 2889 * Allocate a new or find an existing runinfo structure 2890 */ 2891 static struct runinfo * 2892 rinfo_get(pid_t pid) 2893 { 2894 struct runinfo *rp; 2895 2896 if (pid == 0) { /* allocate a new entry */ 2897 rp = xcalloc(1, sizeof (struct runinfo)); 2898 rp->next = rthead; /* link the entry into the list */ 2899 rthead = rp; 2900 return (rp); 2901 } 2902 /* search the list for an existing entry */ 2903 for (rp = rthead; rp != NULL; rp = rp->next) { 2904 if (rp->pid == pid) 2905 break; 2906 } 2907 return (rp); 2908 } 2909 2910 /* 2911 * Free a runinfo structure and its associated memory 2912 */ 2913 static void 2914 rinfo_free(struct runinfo *entry) 2915 { 2916 struct runinfo **rpp; 2917 struct runinfo *rp; 2918 2919 #ifdef DEBUG 2920 (void) fprintf(stderr, "freeing job %s\n", entry->jobname); 2921 #endif 2922 for (rpp = &rthead; (rp = *rpp) != NULL; rpp = &rp->next) { 2923 if (rp == entry) { 2924 *rpp = rp->next; /* unlink the entry */ 2925 free(rp->outfile); 2926 free(rp->jobname); 2927 free(rp); 2928 break; 2929 } 2930 } 2931 } 2932 2933 /* ARGSUSED */ 2934 static void 2935 thaw_handler(int sig) 2936 { 2937 refresh = 1; 2938 } 2939 2940 2941 /* ARGSUSED */ 2942 static void 2943 cronend(int sig) 2944 { 2945 crabort("SIGTERM", REMOVE_FIFO); 2946 } 2947 2948 /*ARGSUSED*/ 2949 static void 2950 child_handler(int sig) 2951 { 2952 ; 2953 } 2954 2955 static void 2956 child_sigreset(void) 2957 { 2958 (void) signal(SIGCLD, SIG_DFL); 2959 (void) sigprocmask(SIG_SETMASK, &defmask, NULL); 2960 } 2961 2962 /* 2963 * crabort() - handle exits out of cron 2964 */ 2965 static void 2966 crabort(char *mssg, int action) 2967 { 2968 int c; 2969 2970 if (action & REMOVE_FIFO) { 2971 /* FIFO vanishes when cron finishes */ 2972 if (unlink(FIFO) < 0) 2973 perror("cron could not unlink FIFO"); 2974 } 2975 2976 if (action & CONSOLE_MSG) { 2977 /* write error msg to console */ 2978 if ((c = open(CONSOLE, O_WRONLY)) >= 0) { 2979 (void) write(c, "cron aborted: ", 14); 2980 (void) write(c, mssg, strlen(mssg)); 2981 (void) write(c, "\n", 1); 2982 (void) close(c); 2983 } 2984 } 2985 2986 /* always log the message */ 2987 msg(mssg); 2988 msg("******* CRON ABORTED ********"); 2989 exit(1); 2990 } 2991 2992 /* 2993 * msg() - time-stamped error reporting function 2994 */ 2995 /*PRINTFLIKE1*/ 2996 static void 2997 msg(char *fmt, ...) 2998 { 2999 va_list args; 3000 time_t t; 3001 3002 t = time(NULL); 3003 3004 (void) fflush(stdout); 3005 3006 (void) fprintf(stderr, "! "); 3007 3008 va_start(args, fmt); 3009 (void) vfprintf(stderr, fmt, args); 3010 va_end(args); 3011 3012 (void) strftime(timebuf, sizeof (timebuf), FORMAT, localtime(&t)); 3013 (void) fprintf(stderr, " %s\n", timebuf); 3014 3015 (void) fflush(stderr); 3016 } 3017 3018 static void 3019 ignore_msg(char *func_name, char *job_type, struct event *event) 3020 { 3021 msg("%s: ignoring %s job (user: %s, cmd: %s, time: %ld)", 3022 func_name, job_type, 3023 event->u->name ? event->u->name : "unknown", 3024 event->cmd ? event->cmd : "unknown", 3025 event->time); 3026 } 3027 3028 static void 3029 logit(int cc, struct runinfo *rp, int rc) 3030 { 3031 time_t t; 3032 int ret; 3033 3034 if (!log) 3035 return; 3036 3037 t = time(NULL); 3038 if (cc == BCHAR) 3039 (void) printf("%c CMD: %s\n", cc, next_event->cmd); 3040 (void) strftime(timebuf, sizeof (timebuf), FORMAT, localtime(&t)); 3041 (void) printf("%c %s %u %c %s", 3042 cc, (rp->rusr)->name, rp->pid, QUE(rp->que), timebuf); 3043 if ((ret = TSTAT(rc)) != 0) 3044 (void) printf(" ts=%d", ret); 3045 if ((ret = RCODE(rc)) != 0) 3046 (void) printf(" rc=%d", ret); 3047 (void) putchar('\n'); 3048 (void) fflush(stdout); 3049 } 3050 3051 static void 3052 resched(int delay) 3053 { 3054 time_t nt; 3055 3056 /* run job at a later time */ 3057 nt = next_event->time + delay; 3058 if (next_event->etype == CRONEVENT) { 3059 next_event->time = next_time(next_event, (time_t)0); 3060 if (nt < next_event->time) 3061 next_event->time = nt; 3062 switch (el_add(next_event, next_event->time, 3063 (next_event->u)->ctid)) { 3064 case -1: 3065 ignore_msg("resched", "cron", next_event); 3066 break; 3067 case -2: /* event time lower than init time */ 3068 reset_needed = 1; 3069 break; 3070 } 3071 delayed = 1; 3072 msg("rescheduling a cron job"); 3073 return; 3074 } 3075 add_atevent(next_event->u, next_event->cmd, nt, next_event->etype); 3076 msg("rescheduling at job"); 3077 } 3078 3079 static void 3080 quedefs(int action) 3081 { 3082 int i; 3083 int j; 3084 char qbuf[QBUFSIZ]; 3085 FILE *fd; 3086 3087 /* set up default queue definitions */ 3088 for (i = 0; i < NQUEUE; i++) { 3089 qt[i].njob = qd.njob; 3090 qt[i].nice = qd.nice; 3091 qt[i].nwait = qd.nwait; 3092 } 3093 if (action == DEFAULT) 3094 return; 3095 if ((fd = fopen(QUEDEFS, "r")) == NULL) { 3096 msg("cannot open quedefs file"); 3097 msg("using default queue definitions"); 3098 return; 3099 } 3100 while (fgets(qbuf, QBUFSIZ, fd) != NULL) { 3101 if ((j = qbuf[0]-'a') < 0 || j >= NQUEUE || qbuf[1] != '.') 3102 continue; 3103 parsqdef(&qbuf[2]); 3104 qt[j].njob = qq.njob; 3105 qt[j].nice = qq.nice; 3106 qt[j].nwait = qq.nwait; 3107 } 3108 (void) fclose(fd); 3109 } 3110 3111 static void 3112 parsqdef(char *name) 3113 { 3114 int i; 3115 3116 qq = qd; 3117 while (*name) { 3118 i = 0; 3119 while (isdigit(*name)) { 3120 i *= 10; 3121 i += *name++ - '0'; 3122 } 3123 switch (*name++) { 3124 case JOBF: 3125 qq.njob = i; 3126 break; 3127 case NICEF: 3128 qq.nice = i; 3129 break; 3130 case WAITF: 3131 qq.nwait = i; 3132 break; 3133 } 3134 } 3135 } 3136 3137 /* 3138 * defaults - read defaults from /etc/default/cron 3139 */ 3140 static void 3141 defaults() 3142 { 3143 int flags; 3144 char *deflog; 3145 char *hz, *tz; 3146 3147 /* 3148 * get HZ value for environment 3149 */ 3150 if ((hz = getenv("HZ")) == (char *)NULL) 3151 (void) sprintf(hzname, "HZ=%d", HZ); 3152 else 3153 (void) snprintf(hzname, sizeof (hzname), "HZ=%s", hz); 3154 /* 3155 * get TZ value for environment 3156 */ 3157 (void) snprintf(tzone, sizeof (tzone), "TZ=%s", 3158 ((tz = getenv("TZ")) != NULL) ? tz : DEFTZ); 3159 3160 if (defopen(DEFFILE) == 0) { 3161 /* ignore case */ 3162 flags = defcntl(DC_GETFLAGS, 0); 3163 TURNOFF(flags, DC_CASE); 3164 (void) defcntl(DC_SETFLAGS, flags); 3165 3166 if (((deflog = defread("CRONLOG=")) == NULL) || 3167 (*deflog == 'N') || (*deflog == 'n')) 3168 log = 0; 3169 else 3170 log = 1; 3171 /* fix for 1087611 - allow paths to be set in defaults file */ 3172 if ((Def_path = defread("PATH=")) != NULL) { 3173 (void) strlcat(path, Def_path, LINE_MAX); 3174 } else { 3175 (void) strlcpy(path, NONROOTPATH, LINE_MAX); 3176 } 3177 if ((Def_supath = defread("SUPATH=")) != NULL) { 3178 (void) strlcat(supath, Def_supath, LINE_MAX); 3179 } else { 3180 (void) strlcpy(supath, ROOTPATH, LINE_MAX); 3181 } 3182 (void) defopen(NULL); 3183 } 3184 } 3185 3186 /* 3187 * Determine if a user entry for a job is still ok. The method used here 3188 * is a lot (about 75x) faster than using setgrent() / getgrent() 3189 * endgrent(). It should be safe because we use the sysconf to determine 3190 * the max, and it tolerates the max being 0. 3191 */ 3192 3193 static int 3194 verify_user_cred(struct usr *u) 3195 { 3196 struct passwd *pw; 3197 size_t numUsrGrps = 0; 3198 size_t numOrigGrps = 0; 3199 size_t i; 3200 int retval; 3201 3202 /* 3203 * Maximum number of groups a user may be in concurrently. This 3204 * is a value which we obtain at runtime through a sysconf() 3205 * call. 3206 */ 3207 3208 static size_t nGroupsMax = (size_t)-1; 3209 3210 /* 3211 * Arrays for cron user's group list, constructed at startup to 3212 * be nGroupsMax elements long, used for verifying user 3213 * credentials prior to execution. 3214 */ 3215 3216 static gid_t *UsrGrps; 3217 static gid_t *OrigGrps; 3218 3219 if ((pw = getpwnam(u->name)) == NULL) 3220 return (VUC_BADUSER); 3221 if (u->home != NULL) { 3222 if (strcmp(u->home, pw->pw_dir) != 0) { 3223 free(u->home); 3224 u->home = xmalloc(strlen(pw->pw_dir) + 1); 3225 (void) strcpy(u->home, pw->pw_dir); 3226 } 3227 } else { 3228 u->home = xmalloc(strlen(pw->pw_dir) + 1); 3229 (void) strcpy(u->home, pw->pw_dir); 3230 } 3231 if (u->uid != pw->pw_uid) 3232 u->uid = pw->pw_uid; 3233 if (u->gid != pw->pw_gid) 3234 u->gid = pw->pw_gid; 3235 3236 /* 3237 * Create the group id lists needed for job credential 3238 * verification. 3239 */ 3240 3241 if (nGroupsMax == (size_t)-1) { 3242 if ((nGroupsMax = sysconf(_SC_NGROUPS_MAX)) > 0) { 3243 UsrGrps = xcalloc(nGroupsMax, sizeof (gid_t)); 3244 OrigGrps = xcalloc(nGroupsMax, sizeof (gid_t)); 3245 } 3246 3247 #ifdef DEBUG 3248 (void) fprintf(stderr, "nGroupsMax = %ld\n", nGroupsMax); 3249 #endif 3250 } 3251 3252 #ifdef DEBUG 3253 (void) fprintf(stderr, "verify_user_cred (%s-%d)\n", pw->pw_name, 3254 pw->pw_uid); 3255 (void) fprintf(stderr, "verify_user_cred: pw->pw_gid = %d, " 3256 "u->gid = %d\n", pw->pw_gid, u->gid); 3257 #endif 3258 3259 retval = (u->gid == pw->pw_gid) ? VUC_OK : VUC_NOTINGROUP; 3260 3261 if (nGroupsMax > 0) { 3262 numOrigGrps = getgroups(nGroupsMax, OrigGrps); 3263 3264 (void) initgroups(pw->pw_name, pw->pw_gid); 3265 numUsrGrps = getgroups(nGroupsMax, UsrGrps); 3266 3267 for (i = 0; i < numUsrGrps; i++) { 3268 if (UsrGrps[i] == u->gid) { 3269 retval = VUC_OK; 3270 break; 3271 } 3272 } 3273 3274 if (OrigGrps) { 3275 (void) setgroups(numOrigGrps, OrigGrps); 3276 } 3277 } 3278 3279 #ifdef DEBUG 3280 (void) fprintf(stderr, "verify_user_cred: VUC = %d\n", retval); 3281 #endif 3282 3283 return (retval); 3284 } 3285 3286 static int 3287 set_user_cred(const struct usr *u, struct project *pproj) 3288 { 3289 static char *progname = "cron"; 3290 int r = 0, rval = 0; 3291 3292 if ((r = pam_start(progname, u->name, &pam_conv, &pamh)) 3293 != PAM_SUCCESS) { 3294 #ifdef DEBUG 3295 msg("pam_start returns %d\n", r); 3296 #endif 3297 rval = VUC_BADUSER; 3298 goto set_eser_cred_exit; 3299 } 3300 3301 r = pam_acct_mgmt(pamh, 0); 3302 #ifdef DEBUG 3303 msg("pam_acc_mgmt returns %d\n", r); 3304 #endif 3305 if (r == PAM_ACCT_EXPIRED) { 3306 rval = VUC_EXPIRED; 3307 goto set_eser_cred_exit; 3308 } 3309 if (r == PAM_NEW_AUTHTOK_REQD) { 3310 rval = VUC_NEW_AUTH; 3311 goto set_eser_cred_exit; 3312 } 3313 if (r != PAM_SUCCESS) { 3314 rval = VUC_BADUSER; 3315 goto set_eser_cred_exit; 3316 } 3317 3318 if (pproj != NULL) { 3319 size_t sz = sizeof (PROJECT) + strlen(pproj->pj_name); 3320 char *buf = alloca(sz); 3321 3322 (void) snprintf(buf, sz, PROJECT "%s", pproj->pj_name); 3323 (void) pam_set_item(pamh, PAM_RESOURCE, buf); 3324 } 3325 3326 r = pam_setcred(pamh, PAM_ESTABLISH_CRED); 3327 if (r != PAM_SUCCESS) 3328 rval = VUC_BADUSER; 3329 3330 set_eser_cred_exit: 3331 (void) pam_end(pamh, r); 3332 return (rval); 3333 } 3334 3335 static void 3336 clean_out_user(struct usr *u) 3337 { 3338 if (next_event->u == u) { 3339 next_event = NULL; 3340 } 3341 3342 clean_out_ctab(u); 3343 clean_out_atjobs(u); 3344 free_if_unused(u); 3345 } 3346 3347 static void 3348 clean_out_atjobs(struct usr *u) 3349 { 3350 struct event *ev, *pv; 3351 3352 for (pv = NULL, ev = u->atevents; 3353 ev != NULL; 3354 pv = ev, ev = ev->link, free(pv)) { 3355 el_remove(ev->of.at.eventid, 1); 3356 if (cwd == AT) 3357 cron_unlink(ev->cmd); 3358 else { 3359 char buf[PATH_MAX]; 3360 if (strlen(ATDIR) + strlen(ev->cmd) + 2 3361 < PATH_MAX) { 3362 (void) sprintf(buf, "%s/%s", ATDIR, ev->cmd); 3363 cron_unlink(buf); 3364 } 3365 } 3366 free(ev->cmd); 3367 } 3368 3369 u->atevents = NULL; 3370 } 3371 3372 static void 3373 clean_out_ctab(struct usr *u) 3374 { 3375 rm_ctevents(u); 3376 el_remove(u->ctid, 0); 3377 u->ctid = 0; 3378 u->ctexists = 0; 3379 } 3380 3381 static void 3382 cron_unlink(char *name) 3383 { 3384 int r; 3385 3386 r = unlink(name); 3387 if (r == 0 || (r == -1 && errno == ENOENT)) { 3388 (void) audit_cron_delete_anc_file(name, NULL); 3389 } 3390 } 3391 3392 static void 3393 create_anc_ctab(struct event *e) 3394 { 3395 if (audit_cron_create_anc_file(e->u->name, 3396 (cwd == CRON) ? NULL:CRONDIR, 3397 e->u->name, e->u->uid) == -1) { 3398 process_anc_files(CRON_ANC_DELETE); 3399 crabort("cannot create ancillary files for crontabs", 3400 REMOVE_FIFO|CONSOLE_MSG); 3401 } 3402 } 3403 3404 static void 3405 delete_anc_ctab(struct event *e) 3406 { 3407 (void) audit_cron_delete_anc_file(e->u->name, 3408 (cwd == CRON) ? NULL:CRONDIR); 3409 } 3410 3411 static void 3412 create_anc_atjob(struct event *e) 3413 { 3414 if (!e->of.at.exists) 3415 return; 3416 3417 if (audit_cron_create_anc_file(e->cmd, 3418 (cwd == AT) ? NULL:ATDIR, 3419 e->u->name, e->u->uid) == -1) { 3420 process_anc_files(CRON_ANC_DELETE); 3421 crabort("cannot create ancillary files for atjobs", 3422 REMOVE_FIFO|CONSOLE_MSG); 3423 } 3424 } 3425 3426 static void 3427 delete_anc_atjob(struct event *e) 3428 { 3429 if (!e->of.at.exists) 3430 return; 3431 3432 (void) audit_cron_delete_anc_file(e->cmd, 3433 (cwd == AT) ? NULL:ATDIR); 3434 } 3435 3436 3437 static void 3438 process_anc_files(int del) 3439 { 3440 struct usr *u = uhead; 3441 struct event *e; 3442 3443 if (!audit_cron_mode()) 3444 return; 3445 3446 for (;;) { 3447 if (u->ctexists && u->ctevents != NULL) { 3448 e = u->ctevents; 3449 for (;;) { 3450 if (del) 3451 delete_anc_ctab(e); 3452 else 3453 create_anc_ctab(e); 3454 if ((e = e->link) == NULL) 3455 break; 3456 } 3457 } 3458 3459 if (u->atevents != NULL) { 3460 e = u->atevents; 3461 for (;;) { 3462 if (del) 3463 delete_anc_atjob(e); 3464 else 3465 create_anc_atjob(e); 3466 if ((e = e->link) == NULL) 3467 break; 3468 } 3469 } 3470 3471 if ((u = u->nextusr) == NULL) 3472 break; 3473 } 3474 } 3475 3476 /*ARGSUSED*/ 3477 static int 3478 cron_conv(int num_msg, struct pam_message **msgs, 3479 struct pam_response **response, void *appdata_ptr) 3480 { 3481 struct pam_message **m = msgs; 3482 int i; 3483 3484 for (i = 0; i < num_msg; i++) { 3485 switch (m[i]->msg_style) { 3486 case PAM_ERROR_MSG: 3487 case PAM_TEXT_INFO: 3488 if (m[i]->msg != NULL) { 3489 (void) msg("%s\n", m[i]->msg); 3490 } 3491 break; 3492 3493 default: 3494 break; 3495 } 3496 } 3497 return (0); 3498 } 3499 3500 /* 3501 * Cron creates process for other than job. Mail process is the 3502 * one which rinfo does not cover. Therefore, miscpid will keep 3503 * track of the pids executed from cron. Otherwise, we will see 3504 * "unexpected pid returned.." messages appear in the log file. 3505 */ 3506 static void 3507 miscpid_insert(pid_t pid) 3508 { 3509 struct miscpid *mp; 3510 3511 mp = xmalloc(sizeof (*mp)); 3512 mp->pid = pid; 3513 mp->next = miscpid_head; 3514 miscpid_head = mp; 3515 } 3516 3517 static int 3518 miscpid_delete(pid_t pid) 3519 { 3520 struct miscpid *mp, *omp; 3521 int found = 0; 3522 3523 omp = NULL; 3524 for (mp = miscpid_head; mp != NULL; mp = mp->next) { 3525 if (mp->pid == pid) { 3526 found = 1; 3527 break; 3528 } 3529 omp = mp; 3530 } 3531 if (found) { 3532 if (omp != NULL) 3533 omp->next = mp->next; 3534 else 3535 miscpid_head = NULL; 3536 free(mp); 3537 } 3538 return (found); 3539 } 3540 3541 /* 3542 * Establish contract terms such that all children are in abandoned 3543 * process contracts. 3544 */ 3545 static void 3546 contract_set_template(void) 3547 { 3548 int fd; 3549 3550 if ((fd = open64(CTFS_ROOT "/process/template", O_RDWR)) < 0) 3551 crabort("cannot open process contract template", 3552 REMOVE_FIFO | CONSOLE_MSG); 3553 3554 if (ct_pr_tmpl_set_param(fd, 0) || 3555 ct_tmpl_set_informative(fd, 0) || 3556 ct_pr_tmpl_set_fatal(fd, CT_PR_EV_HWERR)) 3557 crabort("cannot establish contract template terms", 3558 REMOVE_FIFO | CONSOLE_MSG); 3559 3560 if (ct_tmpl_activate(fd)) 3561 crabort("cannot activate contract template", 3562 REMOVE_FIFO | CONSOLE_MSG); 3563 3564 (void) close(fd); 3565 } 3566 3567 /* 3568 * Clear active process contract template. 3569 */ 3570 static void 3571 contract_clear_template(void) 3572 { 3573 int fd; 3574 3575 if ((fd = open64(CTFS_ROOT "/process/template", O_RDWR)) < 0) 3576 crabort("cannot open process contract template", 3577 REMOVE_FIFO | CONSOLE_MSG); 3578 3579 if (ct_tmpl_clear(fd)) 3580 crabort("cannot clear contract template", 3581 REMOVE_FIFO | CONSOLE_MSG); 3582 3583 (void) close(fd); 3584 } 3585 3586 /* 3587 * Abandon latest process contract unconditionally. If we have leaked [some 3588 * critical amount], exit such that the kernel reaps our contracts. 3589 */ 3590 static void 3591 contract_abandon_latest(pid_t pid) 3592 { 3593 int r; 3594 ctid_t id; 3595 static uint_t cts_lost; 3596 3597 if (cts_lost > MAX_LOST_CONTRACTS) 3598 crabort("repeated failure to abandon contracts", 3599 REMOVE_FIFO | CONSOLE_MSG); 3600 3601 if (r = contract_latest(&id)) { 3602 msg("could not obtain latest contract for " 3603 "PID %ld: %s", pid, strerror(r)); 3604 cts_lost++; 3605 return; 3606 } 3607 3608 if (r = contract_abandon_id(id)) { 3609 msg("could not abandon latest contract %ld: %s", id, 3610 strerror(r)); 3611 cts_lost++; 3612 return; 3613 } 3614 } 3615 3616 static struct shared * 3617 create_shared(void *obj, void * (*obj_alloc)(void *obj), 3618 void (*obj_free)(void *)) 3619 { 3620 struct shared *out; 3621 3622 if ((out = xmalloc(sizeof (struct shared))) == NULL) { 3623 return (NULL); 3624 } 3625 if ((out->obj = obj_alloc(obj)) == NULL) { 3626 free(out); 3627 return (NULL); 3628 } 3629 out->count = 1; 3630 out->free = obj_free; 3631 3632 return (out); 3633 } 3634 3635 static struct shared * 3636 create_shared_str(char *str) 3637 { 3638 return (create_shared(str, (void *(*)(void *))strdup, free)); 3639 } 3640 3641 static struct shared * 3642 dup_shared(struct shared *obj) 3643 { 3644 if (obj != NULL) { 3645 obj->count++; 3646 } 3647 return (obj); 3648 } 3649 3650 static void 3651 rel_shared(struct shared *obj) 3652 { 3653 if (obj && (--obj->count) == 0) { 3654 obj->free(obj->obj); 3655 free(obj); 3656 } 3657 } 3658 3659 static void * 3660 get_obj(struct shared *obj) 3661 { 3662 return (obj->obj); 3663 } 3664