#if !defined(lint) && !defined(LINT)
static char rcsid
[] = "$Header: do_command.c,v 2.1 90/07/18 00:23:38 vixie Exp $";
/* $Source: /jove_u3/vixie/src/cron/RCS/do_command.c,v $
* Revision 2.1 90/07/18 00:23:38 vixie
* Baseline for 4.4BSD release
* Revision 2.0 88/12/10 04:57:44 vixie
* Revision 1.5 88/11/29 13:06:06 vixie
* seems to work on Ultrix 3.0 FT1
* Revision 1.4 87/05/02 17:33:35 paul
* baseline for mod.sources release
* Revision 1.3 87/04/09 00:03:58 paul
* improved data hiding, locality of declaration/references
* fixed a rs@mirror bug by redesigning the mailto stuff completely
* Revision 1.2 87/03/19 12:46:24 paul
* implemented suggestions from rs@mirror (Rich $alz):
* MAILTO="" means no mail should be sent
* various fixes of bugs or lint complaints
* put a To: line in the mail message
* Revision 1.1 87/01/26 23:47:00 paul
* PATCHES MAGIC LEVEL PATCH THAT GOT US HERE
* -------------------- ----- ----------------------
* CURRENT PATCH LEVEL: 1 00131
* -------------------- ----- ----------------------
* 06 Apr 93 Adam Glass Fixes so it compiles quitely
/* Copyright 1988,1990 by Paul Vixie
* Distribute freely, except: don't remove my name from the source or
* documentation (don't take credit for my work), mark your changes (don't
* get me blamed for your possible bugs), don't alter or remove this
* notice. May be sold if buildable source is provided to buyer. No
* warrantee of any kind, express or implied, is included with this
* software; use at your own risk, responsibility for damages (if any) to
* anyone resulting from the use of this software rests entirely with the
* Send bug reports, bug fixes, enhancements, requests, flames, etc., and
* I'll try to keep a version up to date. I can be reached as follows:
* Paul Vixie, 329 Noe Street, San Francisco, CA, 94114, (415) 864-7013,
* paul@vixie.sf.ca.us || {hoptoad,pacbell,decwrl,crash}!vixie!paul
# include <sys/universe.h>
extern int fork(), _exit();
extern void child_process(), log_it();
Debug(DPROC
, ("[%d] do_command(%s, (%s,%d,%d))\n",
getpid(), cmd
, env_get(USERENV
, u
->envp
), u
->uid
, u
->gid
))
/* fork to become asynchronous -- parent process is done immediately,
* and continues to run the normal cron code, which means return to
* tick(). the child and grandchild don't leave this function, alive.
* vfork() is unsuitable, since we have much to do, and the parent
* needs to be able to run off and fork other processes.
log_it("CROND",getpid(),"error","can't fork");
Debug(DPROC
, ("[%d] child process done, exiting\n", getpid()))
Debug(DPROC
, ("[%d] main process returning to work\n", getpid()))
extern struct passwd
*getpwnam();
extern void sigpipe_func(), be_different(), log_it();
extern char *index(), *env_get();
auto int stdin_pipe
[2], stdout_pipe
[2];
register char *input_data
, *usernm
, *mailto
;
Debug(DPROC
, ("[%d] child_process('%s')\n", getpid(), cmd
))
/* mark ourselves as different to PS command watchers by upshifting
* our program name. This has no effect on some kernels.
for (pch
= ProgramName
; *pch
; pch
++)
/* discover some useful and important environment settings
usernm
= env_get(USERENV
, u
->envp
);
mailto
= env_get("MAILTO", u
->envp
);
/* our parent is watching for our death by catching SIGCHLD. we
* do not care to watch for our children's deaths this way -- we
* use wait() explictly. so we have to disable the signal (which
* was inherited from the parent).
* this isn't needed for system V, since our parent is already
* SIG_IGN on SIGCLD -- which, hopefully, will cause children to
* simply vanish when they die.
(void) signal(SIGCHLD
, SIG_IGN
);
/* create some pipes to talk to our future child
pipe(stdin_pipe
); /* child's stdin */
pipe(stdout_pipe
); /* child's stdout */
/* since we are a forked process, we can diddle the command string
* we were passed -- nobody else is going to use it again, right?
* if a % is present in the command, previous characters are the
* command, and subsequent characters are the additional input to
* the command. Subsequent %'s will be transformed into newlines,
* but that happens later.
if (NULL
== (input_data
= index(cmd
, '%')))
/* no %. point input_data at a null string.
/* % found. replace with a null (remember, we're a forked
* process and the string won't be reused), and increment
* input_data to point at the following character.
/* fork again, this time so we can exec the user's command. Vfork()
* is okay this time, since we are going to exec() pretty quickly.
* I'm assuming that closing pipe ends &whatnot will not affect our
* suspended pseudo-parent/alter-ego.
Debug(DPROC
, ("[%d] grandchild process VFORK()'ed\n", getpid()))
/* write a log message. we've waited this long to do it
* because it was not until now that we knew the PID that
* the actual user command shell was going to get and the
* PID is part of the log message.
char *x
= mkprints(cmd
, strlen(cmd
));
log_it(usernm
, getpid(), "CMD", x
);
/* get new pgrp, void tty, etc.
/* close the pipe ends that we won't use. this doesn't affect
* the parent, who has to read and write them; it keeps the
* kernel from recording us as a potential client TWICE --
* which would keep it from sending SIGPIPE in otherwise
* appropriate circumstances.
close(stdin_pipe
[WRITE_PIPE
]);
close(stdout_pipe
[READ_PIPE
]);
/* grandchild process. make std{in,out} be the ends of
* pipes opened by our daddy; make stderr go to stdout.
close(STDIN
); dup2(stdin_pipe
[READ_PIPE
], STDIN
);
close(STDOUT
); dup2(stdout_pipe
[WRITE_PIPE
], STDOUT
);
close(STDERR
); dup2(STDOUT
, STDERR
);
/* close the pipes we just dup'ed. The resources will remain,
* since they've been dup'ed... :-)...
close(stdin_pipe
[READ_PIPE
]);
close(stdout_pipe
[WRITE_PIPE
]);
/* set our login universe. Do this in the grandchild
* so that the child can invoke /usr/lib/sendmail
/* set our directory, uid and gid. Set gid first, since once
* we set uid, we've lost root privledges. (oops!)
initgroups(env_get(USERENV
, u
->envp
), u
->gid
);
setuid(u
->uid
); /* you aren't root after this... */
chdir(env_get("HOME", u
->envp
));
char *shell
= env_get("SHELL", u
->envp
);
if (DebugFlags
& DTEST
) {
"debug DTEST is on, not exec'ing command.\n");
"\tcmd='%s' shell='%s'\n", cmd
, shell
);
/* normally you can't put debugging stuff here because
* it gets mailed with the command output.
Debug(DPROC, ("[%d] execle('%s', '%s', -c, '%s')\n",
getpid(), shell, shell, cmd))
/* files writable by non-owner are a no-no
if (0 != stat(cmd
, &sb
)) {
fputs("crond: stat(2): ", stderr
);
} else if (sb
.st_mode
& 022) {
"crond: %s writable by nonowner\n",
} else if (sb
.st_uid
& 022) {
"crond: %s owned by uid %d\n",
execle(shell
, shell
, "-c", cmd
, (char *)0, u
->envp
);
fprintf(stderr
, "execl: couldn't exec `%s'\n", shell
);
/* middle process, child of original cron, parent of process running
Debug(DPROC
, ("[%d] child continues, closing pipes\n", getpid()))
/* close the ends of the pipe that will only be referenced in the
close(stdin_pipe
[READ_PIPE
]);
close(stdout_pipe
[WRITE_PIPE
]);
* write, to the pipe connected to child's stdin, any input specified
* after a % in the crontab entry. while we copy, convert any
* additional %'s to newlines. when done, if some characters were
* written and the last one wasn't a newline, write a newline.
* Note that if the input data won't fit into one pipe buffer (2K
* or 4K on most BSD systems), and the child doesn't read its stdin,
* we would block here. the solution, of course, is to fork again.
if (*input_data
&& fork() == 0) {
register FILE *out
= fdopen(stdin_pipe
[WRITE_PIPE
], "w");
register int need_newline
= FALSE
;
register int escaped
= FALSE
;
Debug(DPROC
, ("[%d] child2 sending data to grandchild\n", getpid()))
/* close the pipe we don't use, since we inherited it and
* are part of its reference count now.
close(stdout_pipe
[READ_PIPE
]);
* \x -> \x for all x != %
while (ch
= *input_data
++)
if (!(escaped
= (ch
== '\\'))) {
need_newline
= (ch
!= '\n');
/* close the pipe, causing an EOF condition. fclose causes
* stdin_pipe[WRITE_PIPE] to be closed, too.
Debug(DPROC
, ("[%d] child2 done sending to grandchild\n", getpid()))
/* close the pipe to the grandkiddie's stdin, since its wicked uncle
* ernie back there has it open and will close it when he's done.
close(stdin_pipe
[WRITE_PIPE
]);
* read output from the grandchild. it's stderr has been redirected to
* it's stdout, which has been redirected to our pipe. if there is any
* output, we'll be mailing it to the user whose crontab this is...
* when the grandchild exits, we'll get EOF.
Debug(DPROC
, ("[%d] child reading output from grandchild\n", getpid()))
register FILE *in
= fdopen(stdout_pipe
[READ_PIPE
], "r");
register int ch
= getc(in
);
("[%d] got data (%x:%c) from grandchild\n",
/* get name of recipient. this is MAILTO if set to a
* valid local username; USER otherwise.
/* MAILTO was present in the environment
/* ... but it's empty. set to NULL
/* MAILTO not present, set to USER.
/* if we are supposed to be mailing, MAILTO will
* be non-NULL. only in this case should we set
* up the mail command and subjects and stuff...
extern char *print_cmd();
auto char mailcmd
[MAX_COMMAND
];
auto char hostname
[MAXHOSTNAMELEN
];
(void) gethostname(hostname
, MAXHOSTNAMELEN
);
(void) sprintf(mailcmd
, MAILCMD
, mailto
);
if (!(mail
= popen(mailcmd
, "w")))
(void) _exit(ERROR_EXIT
);
fprintf(mail
, "From: root (Cron Daemon)\n");
fprintf(mail
, "To: %s\n", mailto
);
"Subject: cron for %s@%s said this\n",
usernm
, first_word(hostname
, ".")
fprintf(mail
, "Date: %s", ctime(&TargetTime
));
fprintf(mail
, "X-Cron-Cmd: <%s>\n", cmd
);
for (env
= u
->envp
; *env
; env
++)
fprintf(mail
, "X-Cron-Env: <%s>\n",
/* this was the first char from the pipe
/* we have to read the input pipe no matter whether
* we mail or not, but obviously we only write to
* mail pipe if we ARE mailing.
while (EOF
!= (ch
= getc(in
)))
/* only close pipe if we opened it -- i.e., we're
Debug(DPROC
, ("[%d] closing pipe to mail\n",
/* Note: the pclose will probably see
* the termination of the grandchild
* in addition to the mail process, since
* it (the grandchild) is likely to exit
* after closing its stdout.
status
.w_status
= pclose(mail
);
/* if there was output and we could not mail it,
* log the facts so the poor user can figure out
if (mailto
&& status
.w_status
) {
"mailed %d byte%s of output but got status 0x%04x\n",
bytes
, (bytes
==1)?"":"s",
log_it(usernm
, getpid(), "MAIL", buf
);
} /*if data from grandchild*/
Debug(DPROC
, ("[%d] got EOF from grandchild\n", getpid()))
fclose(in
); /* also closes stdout_pipe[READ_PIPE] */
/* wait for children to die.
for (; children
> 0; children
--)
Debug(DPROC
, ("[%d] waiting for grandchild #%d to finish\n",
pid
= wait((int *) &waiter
);
Debug(DPROC
, ("[%d] no more grandchildren--mail written?\n",
Debug(DPROC
, ("[%d] grandchild #%d finished, status=%04x",
getpid(), pid
, waiter
.w_status
))
Debug(DPROC
, (", dumped core"))
/* Dynix (Sequent) hack to put the user associated with
* the passed user structure into the ATT universe if
* necessary. We have to dig the gecos info out of
* the user's password entry to see if the magic
* "universe(att)" string is present. If we do change
* the universe, also set "LOGNAME".
char envstr
[MAX_ENVSTR
], **env_set();
if ((s
= index(s
, ',')) == NULL
)
if (strcmp(s
, "universe(att)"))
(void) sprintf(envstr
, "LOGNAME=%s", p
->pw_name
);
u
->envp
= env_set(u
->envp
, envstr
);