1 /* Copyright 1988,1990,1993,1994 by Paul Vixie 2 * All rights reserved 3 * 4 * Distribute freely, except: don't remove my name from the source or 5 * documentation (don't take credit for my work), mark your changes (don't 6 * get me blamed for your possible bugs), don't alter or remove this 7 * notice. May be sold if buildable source is provided to buyer. No 8 * warrantee of any kind, express or implied, is included with this 9 * software; use at your own risk, responsibility for damages (if any) to 10 * anyone resulting from the use of this software rests entirely with the 11 * user. 12 * 13 * Send bug reports, bug fixes, enhancements, requests, flames, etc., and 14 * I'll try to keep a version up to date. I can be reached as follows: 15 * Paul Vixie <paul@vix.com> uunet!decwrl!vixie!paul 16 * 17 * $FreeBSD: src/usr.sbin/cron/cron/do_command.c,v 1.15.2.5 2001/05/04 00:59:40 peter Exp $ 18 * $DragonFly: src/usr.sbin/cron/cron/do_command.c,v 1.3 2003/11/03 19:31:36 eirikn Exp $ 19 */ 20 21 #include "cron.h" 22 #include <sys/signal.h> 23 #if defined(sequent) 24 # include <sys/universe.h> 25 #endif 26 #if defined(SYSLOG) 27 # include <syslog.h> 28 #endif 29 #if defined(LOGIN_CAP) 30 # include <login_cap.h> 31 #endif 32 33 34 static void child_process(entry *, user *), 35 do_univ(user *); 36 37 38 void 39 do_command(e, u) 40 entry *e; 41 user *u; 42 { 43 Debug(DPROC, ("[%d] do_command(%s, (%s,%d,%d))\n", 44 getpid(), e->cmd, u->name, e->uid, e->gid)) 45 46 /* fork to become asynchronous -- parent process is done immediately, 47 * and continues to run the normal cron code, which means return to 48 * tick(). the child and grandchild don't leave this function, alive. 49 * 50 * vfork() is unsuitable, since we have much to do, and the parent 51 * needs to be able to run off and fork other processes. 52 */ 53 switch (fork()) { 54 case -1: 55 log_it("CRON",getpid(),"error","can't fork"); 56 break; 57 case 0: 58 /* child process */ 59 acquire_daemonlock(1); 60 child_process(e, u); 61 Debug(DPROC, ("[%d] child process done, exiting\n", getpid())) 62 _exit(OK_EXIT); 63 break; 64 default: 65 /* parent process */ 66 break; 67 } 68 Debug(DPROC, ("[%d] main process returning to work\n", getpid())) 69 } 70 71 72 static void 73 child_process(e, u) 74 entry *e; 75 user *u; 76 { 77 int stdin_pipe[2], stdout_pipe[2]; 78 register char *input_data; 79 char *usernm, *mailto; 80 int children = 0; 81 # if defined(LOGIN_CAP) 82 struct passwd *pwd; 83 login_cap_t *lc; 84 # endif 85 86 Debug(DPROC, ("[%d] child_process('%s')\n", getpid(), e->cmd)) 87 88 /* mark ourselves as different to PS command watchers by upshifting 89 * our program name. This has no effect on some kernels. 90 */ 91 setproctitle("running job"); 92 93 /* discover some useful and important environment settings 94 */ 95 usernm = env_get("LOGNAME", e->envp); 96 mailto = env_get("MAILTO", e->envp); 97 98 #ifdef USE_SIGCHLD 99 /* our parent is watching for our death by catching SIGCHLD. we 100 * do not care to watch for our children's deaths this way -- we 101 * use wait() explictly. so we have to disable the signal (which 102 * was inherited from the parent). 103 */ 104 (void) signal(SIGCHLD, SIG_DFL); 105 #else 106 /* on system-V systems, we are ignoring SIGCLD. we have to stop 107 * ignoring it now or the wait() in cron_pclose() won't work. 108 * because of this, we have to wait() for our children here, as well. 109 */ 110 (void) signal(SIGCLD, SIG_DFL); 111 #endif /*BSD*/ 112 113 /* create some pipes to talk to our future child 114 */ 115 pipe(stdin_pipe); /* child's stdin */ 116 pipe(stdout_pipe); /* child's stdout */ 117 118 /* since we are a forked process, we can diddle the command string 119 * we were passed -- nobody else is going to use it again, right? 120 * 121 * if a % is present in the command, previous characters are the 122 * command, and subsequent characters are the additional input to 123 * the command. Subsequent %'s will be transformed into newlines, 124 * but that happens later. 125 * 126 * If there are escaped %'s, remove the escape character. 127 */ 128 /*local*/{ 129 register int escaped = FALSE; 130 register int ch; 131 register char *p; 132 133 for (input_data = p = e->cmd; (ch = *input_data); 134 input_data++, p++) { 135 if (p != input_data) 136 *p = ch; 137 if (escaped) { 138 if (ch == '%' || ch == '\\') 139 *--p = ch; 140 escaped = FALSE; 141 continue; 142 } 143 if (ch == '\\') { 144 escaped = TRUE; 145 continue; 146 } 147 if (ch == '%') { 148 *input_data++ = '\0'; 149 break; 150 } 151 } 152 *p = '\0'; 153 } 154 155 /* fork again, this time so we can exec the user's command. 156 */ 157 switch (vfork()) { 158 case -1: 159 log_it("CRON",getpid(),"error","can't vfork"); 160 exit(ERROR_EXIT); 161 /*NOTREACHED*/ 162 case 0: 163 Debug(DPROC, ("[%d] grandchild process Vfork()'ed\n", 164 getpid())) 165 166 /* write a log message. we've waited this long to do it 167 * because it was not until now that we knew the PID that 168 * the actual user command shell was going to get and the 169 * PID is part of the log message. 170 */ 171 /*local*/{ 172 char *x = mkprints((u_char *)e->cmd, strlen(e->cmd)); 173 174 log_it(usernm, getpid(), "CMD", x); 175 free(x); 176 } 177 178 /* that's the last thing we'll log. close the log files. 179 */ 180 #ifdef SYSLOG 181 closelog(); 182 #endif 183 184 /* get new pgrp, void tty, etc. 185 */ 186 (void) setsid(); 187 188 /* close the pipe ends that we won't use. this doesn't affect 189 * the parent, who has to read and write them; it keeps the 190 * kernel from recording us as a potential client TWICE -- 191 * which would keep it from sending SIGPIPE in otherwise 192 * appropriate circumstances. 193 */ 194 close(stdin_pipe[WRITE_PIPE]); 195 close(stdout_pipe[READ_PIPE]); 196 197 /* grandchild process. make std{in,out} be the ends of 198 * pipes opened by our daddy; make stderr go to stdout. 199 */ 200 close(STDIN); dup2(stdin_pipe[READ_PIPE], STDIN); 201 close(STDOUT); dup2(stdout_pipe[WRITE_PIPE], STDOUT); 202 close(STDERR); dup2(STDOUT, STDERR); 203 204 /* close the pipes we just dup'ed. The resources will remain. 205 */ 206 close(stdin_pipe[READ_PIPE]); 207 close(stdout_pipe[WRITE_PIPE]); 208 209 /* set our login universe. Do this in the grandchild 210 * so that the child can invoke /usr/lib/sendmail 211 * without surprises. 212 */ 213 do_univ(u); 214 215 # if defined(LOGIN_CAP) 216 /* Set user's entire context, but skip the environment 217 * as cron provides a separate interface for this 218 */ 219 if ((pwd = getpwnam(usernm)) == NULL) 220 pwd = getpwuid(e->uid); 221 lc = NULL; 222 if (pwd != NULL) { 223 pwd->pw_gid = e->gid; 224 if (e->class != NULL) 225 lc = login_getclass(e->class); 226 } 227 if (pwd && 228 setusercontext(lc, pwd, e->uid, 229 LOGIN_SETALL & ~(LOGIN_SETPATH|LOGIN_SETENV)) == 0) 230 (void) endpwent(); 231 else { 232 /* fall back to the old method */ 233 (void) endpwent(); 234 # endif 235 /* set our directory, uid and gid. Set gid first, 236 * since once we set uid, we've lost root privledges. 237 */ 238 setgid(e->gid); 239 # if defined(BSD) 240 initgroups(usernm, e->gid); 241 # endif 242 setlogin(usernm); 243 setuid(e->uid); /* we aren't root after this..*/ 244 #if defined(LOGIN_CAP) 245 } 246 if (lc != NULL) 247 login_close(lc); 248 #endif 249 chdir(env_get("HOME", e->envp)); 250 251 /* exec the command. 252 */ 253 { 254 char *shell = env_get("SHELL", e->envp); 255 256 # if DEBUGGING 257 if (DebugFlags & DTEST) { 258 fprintf(stderr, 259 "debug DTEST is on, not exec'ing command.\n"); 260 fprintf(stderr, 261 "\tcmd='%s' shell='%s'\n", e->cmd, shell); 262 _exit(OK_EXIT); 263 } 264 # endif /*DEBUGGING*/ 265 execle(shell, shell, "-c", e->cmd, (char *)0, e->envp); 266 warn("execl: couldn't exec `%s'", shell); 267 _exit(ERROR_EXIT); 268 } 269 break; 270 default: 271 /* parent process */ 272 break; 273 } 274 275 children++; 276 277 /* middle process, child of original cron, parent of process running 278 * the user's command. 279 */ 280 281 Debug(DPROC, ("[%d] child continues, closing pipes\n", getpid())) 282 283 /* close the ends of the pipe that will only be referenced in the 284 * grandchild process... 285 */ 286 close(stdin_pipe[READ_PIPE]); 287 close(stdout_pipe[WRITE_PIPE]); 288 289 /* 290 * write, to the pipe connected to child's stdin, any input specified 291 * after a % in the crontab entry. while we copy, convert any 292 * additional %'s to newlines. when done, if some characters were 293 * written and the last one wasn't a newline, write a newline. 294 * 295 * Note that if the input data won't fit into one pipe buffer (2K 296 * or 4K on most BSD systems), and the child doesn't read its stdin, 297 * we would block here. thus we must fork again. 298 */ 299 300 if (*input_data && fork() == 0) { 301 register FILE *out = fdopen(stdin_pipe[WRITE_PIPE], "w"); 302 register int need_newline = FALSE; 303 register int escaped = FALSE; 304 register int ch; 305 306 if (out == NULL) { 307 warn("fdopen failed in child2"); 308 _exit(ERROR_EXIT); 309 } 310 311 Debug(DPROC, ("[%d] child2 sending data to grandchild\n", getpid())) 312 313 /* close the pipe we don't use, since we inherited it and 314 * are part of its reference count now. 315 */ 316 close(stdout_pipe[READ_PIPE]); 317 318 /* translation: 319 * \% -> % 320 * % -> \n 321 * \x -> \x for all x != % 322 */ 323 while ((ch = *input_data++)) { 324 if (escaped) { 325 if (ch != '%') 326 putc('\\', out); 327 } else { 328 if (ch == '%') 329 ch = '\n'; 330 } 331 332 if (!(escaped = (ch == '\\'))) { 333 putc(ch, out); 334 need_newline = (ch != '\n'); 335 } 336 } 337 if (escaped) 338 putc('\\', out); 339 if (need_newline) 340 putc('\n', out); 341 342 /* close the pipe, causing an EOF condition. fclose causes 343 * stdin_pipe[WRITE_PIPE] to be closed, too. 344 */ 345 fclose(out); 346 347 Debug(DPROC, ("[%d] child2 done sending to grandchild\n", getpid())) 348 exit(0); 349 } 350 351 /* close the pipe to the grandkiddie's stdin, since its wicked uncle 352 * ernie back there has it open and will close it when he's done. 353 */ 354 close(stdin_pipe[WRITE_PIPE]); 355 356 children++; 357 358 /* 359 * read output from the grandchild. it's stderr has been redirected to 360 * it's stdout, which has been redirected to our pipe. if there is any 361 * output, we'll be mailing it to the user whose crontab this is... 362 * when the grandchild exits, we'll get EOF. 363 */ 364 365 Debug(DPROC, ("[%d] child reading output from grandchild\n", getpid())) 366 367 /*local*/{ 368 register FILE *in = fdopen(stdout_pipe[READ_PIPE], "r"); 369 register int ch = getc(in); 370 371 if (in == NULL) { 372 warn("fdopen failed in child"); 373 _exit(ERROR_EXIT); 374 } 375 376 if (ch != EOF) { 377 register FILE *mail; 378 register int bytes = 1; 379 int status = 0; 380 381 Debug(DPROC|DEXT, 382 ("[%d] got data (%x:%c) from grandchild\n", 383 getpid(), ch, ch)) 384 385 /* get name of recipient. this is MAILTO if set to a 386 * valid local username; USER otherwise. 387 */ 388 if (mailto) { 389 /* MAILTO was present in the environment 390 */ 391 if (!*mailto) { 392 /* ... but it's empty. set to NULL 393 */ 394 mailto = NULL; 395 } 396 } else { 397 /* MAILTO not present, set to USER. 398 */ 399 mailto = usernm; 400 } 401 402 /* if we are supposed to be mailing, MAILTO will 403 * be non-NULL. only in this case should we set 404 * up the mail command and subjects and stuff... 405 */ 406 407 if (mailto) { 408 register char **env; 409 auto char mailcmd[MAX_COMMAND]; 410 auto char hostname[MAXHOSTNAMELEN]; 411 412 (void) gethostname(hostname, MAXHOSTNAMELEN); 413 (void) snprintf(mailcmd, sizeof(mailcmd), 414 MAILARGS, MAILCMD); 415 if (!(mail = cron_popen(mailcmd, "w", e))) { 416 warn("%s", MAILCMD); 417 (void) _exit(ERROR_EXIT); 418 } 419 fprintf(mail, "From: %s (Cron Daemon)\n", usernm); 420 fprintf(mail, "To: %s\n", mailto); 421 fprintf(mail, "Subject: Cron <%s@%s> %s\n", 422 usernm, first_word(hostname, "."), 423 e->cmd); 424 # if defined(MAIL_DATE) 425 fprintf(mail, "Date: %s\n", 426 arpadate(&TargetTime)); 427 # endif /* MAIL_DATE */ 428 for (env = e->envp; *env; env++) 429 fprintf(mail, "X-Cron-Env: <%s>\n", 430 *env); 431 fprintf(mail, "\n"); 432 433 /* this was the first char from the pipe 434 */ 435 putc(ch, mail); 436 } 437 438 /* we have to read the input pipe no matter whether 439 * we mail or not, but obviously we only write to 440 * mail pipe if we ARE mailing. 441 */ 442 443 while (EOF != (ch = getc(in))) { 444 bytes++; 445 if (mailto) 446 putc(ch, mail); 447 } 448 449 /* only close pipe if we opened it -- i.e., we're 450 * mailing... 451 */ 452 453 if (mailto) { 454 Debug(DPROC, ("[%d] closing pipe to mail\n", 455 getpid())) 456 /* Note: the pclose will probably see 457 * the termination of the grandchild 458 * in addition to the mail process, since 459 * it (the grandchild) is likely to exit 460 * after closing its stdout. 461 */ 462 status = cron_pclose(mail); 463 } 464 465 /* if there was output and we could not mail it, 466 * log the facts so the poor user can figure out 467 * what's going on. 468 */ 469 if (mailto && status) { 470 char buf[MAX_TEMPSTR]; 471 472 snprintf(buf, sizeof(buf), 473 "mailed %d byte%s of output but got status 0x%04x\n", 474 bytes, (bytes==1)?"":"s", 475 status); 476 log_it(usernm, getpid(), "MAIL", buf); 477 } 478 479 } /*if data from grandchild*/ 480 481 Debug(DPROC, ("[%d] got EOF from grandchild\n", getpid())) 482 483 fclose(in); /* also closes stdout_pipe[READ_PIPE] */ 484 } 485 486 /* wait for children to die. 487 */ 488 for (; children > 0; children--) 489 { 490 WAIT_T waiter; 491 PID_T pid; 492 493 Debug(DPROC, ("[%d] waiting for grandchild #%d to finish\n", 494 getpid(), children)) 495 pid = wait(&waiter); 496 if (pid < OK) { 497 Debug(DPROC, ("[%d] no more grandchildren--mail written?\n", 498 getpid())) 499 break; 500 } 501 Debug(DPROC, ("[%d] grandchild #%d finished, status=%04x", 502 getpid(), pid, WEXITSTATUS(waiter))) 503 if (WIFSIGNALED(waiter) && WCOREDUMP(waiter)) 504 Debug(DPROC, (", dumped core")) 505 Debug(DPROC, ("\n")) 506 } 507 } 508 509 510 static void 511 do_univ(u) 512 user *u; 513 { 514 #if defined(sequent) 515 /* Dynix (Sequent) hack to put the user associated with 516 * the passed user structure into the ATT universe if 517 * necessary. We have to dig the gecos info out of 518 * the user's password entry to see if the magic 519 * "universe(att)" string is present. 520 */ 521 522 struct passwd *p; 523 char *s; 524 int i; 525 526 p = getpwuid(u->uid); 527 (void) endpwent(); 528 529 if (p == NULL) 530 return; 531 532 s = p->pw_gecos; 533 534 for (i = 0; i < 4; i++) 535 { 536 if ((s = strchr(s, ',')) == NULL) 537 return; 538 s++; 539 } 540 if (strcmp(s, "universe(att)")) 541 return; 542 543 (void) universe(U_ATT); 544 #endif 545 } 546