572 lines
14 KiB
C
572 lines
14 KiB
C
/* Copyright 1988,1990 by Paul Vixie
|
|
* All rights reserved
|
|
*
|
|
* 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
|
|
* user.
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char rcsid[] = "$Id: do_command.c,v 1.10 1993/12/06 23:57:11 cgd Exp $";
|
|
#endif
|
|
|
|
|
|
#include "cron.h"
|
|
#include <signal.h>
|
|
#include <pwd.h>
|
|
#if defined(BSD)
|
|
# include <sys/wait.h>
|
|
#endif /*BSD*/
|
|
#if defined(sequent)
|
|
# include <strings.h>
|
|
# include <sys/universe.h>
|
|
#endif
|
|
|
|
static void child_process();
|
|
|
|
void
|
|
do_command(cmd, u)
|
|
char *cmd;
|
|
user *u;
|
|
{
|
|
extern int fork();
|
|
extern void log_it();
|
|
extern char *env_get(), arpadate();
|
|
|
|
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.
|
|
*/
|
|
switch (fork())
|
|
{
|
|
case -1:
|
|
log_it("CROND",getpid(),"error","can't fork");
|
|
break;
|
|
case 0:
|
|
/* child process */
|
|
child_process(cmd, u);
|
|
Debug(DPROC, ("[%d] child process done, exiting\n", getpid()))
|
|
_exit(OK_EXIT);
|
|
break;
|
|
}
|
|
Debug(DPROC, ("[%d] main process returning to work\n", getpid()))
|
|
}
|
|
|
|
|
|
static void
|
|
child_process(cmd, u)
|
|
char *cmd;
|
|
user *u;
|
|
{
|
|
extern struct passwd *getpwnam();
|
|
extern void sigpipe_func(), be_different(), log_it();
|
|
extern int VFORK();
|
|
extern char *index(), *env_get();
|
|
|
|
auto int stdin_pipe[2], stdout_pipe[2];
|
|
register char *input_data, *usernm, *mailto;
|
|
auto int children = 0;
|
|
#if defined(sequent)
|
|
extern void do_univ();
|
|
#endif
|
|
|
|
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.
|
|
*/
|
|
{
|
|
register char *pch;
|
|
|
|
for (pch = ProgramName; *pch; pch++)
|
|
*pch = MkUpper(*pch);
|
|
}
|
|
|
|
/* discover some useful and important environment settings
|
|
*/
|
|
usernm = env_get(USERENV, u->envp);
|
|
mailto = env_get("MAILTO", u->envp);
|
|
|
|
#if defined(BSD)
|
|
/* 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);
|
|
#endif /*BSD*/
|
|
|
|
/* 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.
|
|
*/
|
|
input_data = "";
|
|
}
|
|
else
|
|
{
|
|
/* % 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.
|
|
*/
|
|
*input_data++ = '\0';
|
|
}
|
|
|
|
/* set our directory, uid and gid. Set gid first, since once
|
|
* we set uid, we've lost root privledges. (oops!)
|
|
*/
|
|
setgid(u->gid);
|
|
# if defined(BSD)
|
|
initgroups(env_get(USERENV, u->envp), u->gid);
|
|
# endif
|
|
setuid(u->uid); /* you aren't root after this... */
|
|
chdir(env_get("HOME", u->envp));
|
|
|
|
/* 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.
|
|
*/
|
|
if (VFORK() == 0)
|
|
{
|
|
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.
|
|
*/
|
|
#if defined(LOG_FILE) || defined(SYSLOG)
|
|
{
|
|
extern char *mkprints();
|
|
char *x = mkprints(cmd, strlen(cmd));
|
|
|
|
log_it(usernm, getpid(), "CMD", x);
|
|
free(x);
|
|
}
|
|
#endif
|
|
|
|
/* get new pgrp, void tty, etc.
|
|
*/
|
|
be_different();
|
|
|
|
/* 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]);
|
|
|
|
# if defined(sequent)
|
|
/* set our login universe. Do this in the grandchild
|
|
* so that the child can invoke /usr/lib/sendmail
|
|
* without surprises.
|
|
*/
|
|
do_univ(u);
|
|
# endif
|
|
|
|
/* exec the command.
|
|
*/
|
|
{
|
|
char *shell = env_get("SHELL", u->envp);
|
|
|
|
# if DEBUGGING
|
|
if (DebugFlags & DTEST) {
|
|
fprintf(stderr,
|
|
"debug DTEST is on, not exec'ing command.\n");
|
|
fprintf(stderr,
|
|
"\tcmd='%s' shell='%s'\n", cmd, shell);
|
|
_exit(OK_EXIT);
|
|
}
|
|
# endif /*DEBUGGING*/
|
|
/* 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 we are
|
|
* running with privileges.
|
|
*/
|
|
if (u->uid == ROOT_UID) {
|
|
struct stat sb;
|
|
char *filename, *fp;
|
|
|
|
filename = (char *)malloc(strlen(cmd)+1);
|
|
/* they're checked nowhere else! */
|
|
|
|
strcpy(filename,cmd);
|
|
fp = filename;
|
|
while (*fp && !isspace(*fp))
|
|
fp++;
|
|
*fp = '\0';
|
|
|
|
if (0 != stat(filename, &sb)) {
|
|
fputs("crond: stat(2): ", stderr);
|
|
perror(filename);
|
|
_exit(ERROR_EXIT);
|
|
} else if (sb.st_mode & 022) {
|
|
fprintf(stderr,
|
|
"crond: %s writable by nonowner\n",
|
|
filename);
|
|
_exit(ERROR_EXIT);
|
|
} else if (sb.st_uid != u->uid) {
|
|
fprintf(stderr,
|
|
"crond: %s owned by uid %d\n",
|
|
filename, sb.st_uid);
|
|
_exit(ERROR_EXIT);
|
|
}
|
|
|
|
free(filename);
|
|
}
|
|
|
|
execle(shell, shell, "-c", cmd, (char *)0, u->envp);
|
|
fprintf(stderr, "execl: couldn't exec `%s'\n", shell);
|
|
perror("execl");
|
|
_exit(ERROR_EXIT);
|
|
}
|
|
}
|
|
|
|
children++;
|
|
|
|
/* middle process, child of original cron, parent of process running
|
|
* the user's command.
|
|
*/
|
|
|
|
Debug(DPROC, ("[%d] child continues, closing pipes\n", getpid()))
|
|
|
|
/* close the ends of the pipe that will only be referenced in the
|
|
* grandchild process...
|
|
*/
|
|
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;
|
|
register int ch;
|
|
|
|
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]);
|
|
|
|
/* translation:
|
|
* \% -> %
|
|
* % -> \n
|
|
* \x -> \x for all x != %
|
|
*/
|
|
while (ch = *input_data++)
|
|
{
|
|
if (escaped) {
|
|
if (ch != '%')
|
|
putc('\\', out);
|
|
} else {
|
|
if (ch == '%')
|
|
ch = '\n';
|
|
}
|
|
|
|
if (!(escaped = (ch == '\\'))) {
|
|
putc(ch, out);
|
|
need_newline = (ch != '\n');
|
|
}
|
|
}
|
|
if (escaped)
|
|
putc('\\', out);
|
|
if (need_newline)
|
|
putc('\n', out);
|
|
|
|
/* close the pipe, causing an EOF condition. fclose causes
|
|
* stdin_pipe[WRITE_PIPE] to be closed, too.
|
|
*/
|
|
fclose(out);
|
|
|
|
Debug(DPROC, ("[%d] child2 done sending to grandchild\n", getpid()))
|
|
exit(0);
|
|
}
|
|
|
|
/* 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]);
|
|
|
|
children++;
|
|
|
|
/*
|
|
* 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);
|
|
|
|
if (ch != EOF)
|
|
{
|
|
register FILE *mail;
|
|
register int bytes = 1;
|
|
union wait status;
|
|
|
|
Debug(DPROC|DEXT,
|
|
("[%d] got data (%x:%c) from grandchild\n",
|
|
getpid(), ch, ch))
|
|
|
|
/* get name of recipient. this is MAILTO if set to a
|
|
* valid local username; USER otherwise.
|
|
*/
|
|
if (mailto)
|
|
{
|
|
/* MAILTO was present in the environment
|
|
*/
|
|
if (!*mailto)
|
|
{
|
|
/* ... but it's empty. set to NULL
|
|
*/
|
|
mailto = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* MAILTO not present, set to USER.
|
|
*/
|
|
mailto = usernm;
|
|
}
|
|
|
|
/* 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...
|
|
*/
|
|
|
|
if (mailto)
|
|
{
|
|
extern FILE *popen();
|
|
extern char *print_cmd();
|
|
register char **env;
|
|
auto char mailcmd[MAX_COMMAND];
|
|
auto char hostname[MAXHOSTNAMELEN];
|
|
|
|
(void) gethostname(hostname, MAXHOSTNAMELEN);
|
|
(void) sprintf(mailcmd, MAILARGS,
|
|
MAILCMD, mailto);
|
|
if (!(mail = popen(mailcmd, "w")))
|
|
{
|
|
perror(MAILCMD);
|
|
(void) _exit(ERROR_EXIT);
|
|
}
|
|
fprintf(mail, "From: root (Cron Daemon)\n");
|
|
fprintf(mail, "To: %s\n", mailto);
|
|
fprintf(mail,
|
|
"Subject: cron for %s@%s said this\n",
|
|
usernm, first_word(hostname, ".")
|
|
);
|
|
# if defined(MAIL_DATE)
|
|
fprintf(mail, "Date: %s",
|
|
arpadate(&TargetTime));
|
|
# endif /* MAIL_DATE */
|
|
fprintf(mail, "X-Cron-Cmd: <%s>\n", cmd);
|
|
for (env = u->envp; *env; env++)
|
|
fprintf(mail, "X-Cron-Env: <%s>\n",
|
|
*env);
|
|
fprintf(mail, "\n");
|
|
|
|
/* this was the first char from the pipe
|
|
*/
|
|
putc(ch, mail);
|
|
}
|
|
|
|
/* 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)))
|
|
{
|
|
bytes++;
|
|
if (mailto)
|
|
putc(ch, mail);
|
|
}
|
|
|
|
/* if the cron job output ended on something other
|
|
* than a newline, add a newline here. this helps
|
|
* keep mailboxes from being corrupted; apparently
|
|
* /bin/mail versions that use \n\nFrom as a marker
|
|
* do not guarantee that messages end on newlines,
|
|
* which causes follow-on messages to glue together.
|
|
*/
|
|
if (mailto && (ch != '\n')) {
|
|
bytes++;
|
|
putc('\n', mail);
|
|
}
|
|
|
|
/* only close pipe if we opened it -- i.e., we're
|
|
* mailing...
|
|
*/
|
|
|
|
if (mailto) {
|
|
Debug(DPROC, ("[%d] closing pipe to mail\n",
|
|
getpid()))
|
|
/* 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
|
|
* what's going on.
|
|
*/
|
|
if (mailto && status.w_status) {
|
|
char buf[MAX_TEMPSTR];
|
|
|
|
sprintf(buf,
|
|
"mailed %d byte%s of output but got status 0x%04x\n",
|
|
bytes, (bytes==1)?"":"s",
|
|
status.w_status);
|
|
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] */
|
|
}
|
|
|
|
#if defined(BSD)
|
|
/* wait for children to die.
|
|
*/
|
|
for (; children > 0; children--)
|
|
{
|
|
int pid;
|
|
union wait waiter;
|
|
|
|
Debug(DPROC, ("[%d] waiting for grandchild #%d to finish\n",
|
|
getpid(), children))
|
|
pid = wait((int *)&waiter);
|
|
if (pid < OK) {
|
|
Debug(DPROC, ("[%d] no more grandchildren--mail written?\n",
|
|
getpid()))
|
|
break;
|
|
}
|
|
Debug(DPROC, ("[%d] grandchild #%d finished, status=%04x",
|
|
getpid(), pid, waiter.w_status))
|
|
if (waiter.w_coredump)
|
|
Debug(DPROC, (", dumped core"))
|
|
Debug(DPROC, ("\n"))
|
|
}
|
|
#endif /*BSD*/
|
|
}
|
|
|
|
|
|
#if defined(sequent)
|
|
/* 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".
|
|
*/
|
|
|
|
void
|
|
do_univ(u)
|
|
user *u;
|
|
{
|
|
struct passwd *p;
|
|
char *s;
|
|
int i;
|
|
char envstr[MAX_ENVSTR], **env_set();
|
|
|
|
p = getpwuid(u->uid);
|
|
(void) endpwent();
|
|
|
|
if (p == NULL)
|
|
return;
|
|
|
|
s = p->pw_gecos;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if ((s = index(s, ',')) == NULL)
|
|
return;
|
|
s++;
|
|
}
|
|
if (strcmp(s, "universe(att)"))
|
|
return;
|
|
|
|
(void) sprintf(envstr, "LOGNAME=%s", p->pw_name);
|
|
u->envp = env_set(u->envp, envstr);
|
|
|
|
(void) universe(U_ATT);
|
|
}
|
|
#endif
|