File: [local] / src / usr.sbin / cron / do_command.c (download)
Revision 1.63, Sat May 21 01:21:29 2022 UTC (2 years ago) by deraadt
Branch: MAIN
CVS Tags: OPENBSD_7_5_BASE, OPENBSD_7_5, OPENBSD_7_4_BASE, OPENBSD_7_4, OPENBSD_7_3_BASE, OPENBSD_7_3, OPENBSD_7_2_BASE, OPENBSD_7_2, HEAD Changes since 1.62: +5 -5 lines
repair a few more backwards compares that create headaches
ok millert
|
/* $OpenBSD: do_command.c,v 1.63 2022/05/21 01:21:29 deraadt Exp $ */
/* Copyright 1988,1990,1993,1994 by Paul Vixie
* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1997,2000 by Internet Software Consortium, Inc.
* Copyright (c) 2018 Job Snijders <job@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <bitstring.h> /* for structs.h */
#include <bsd_auth.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <login_cap.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <time.h> /* for structs.h */
#include <unistd.h>
#include <vis.h>
#include "config.h"
#include "pathnames.h"
#include "macros.h"
#include "structs.h"
#include "funcs.h"
static void child_process(entry *, user *);
pid_t
do_command(entry *e, user *u)
{
pid_t pid;
/* 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 ((pid = fork())) {
case -1:
syslog(LOG_ERR, "(CRON) CAN'T FORK (%m)");
break;
case 0:
/* child process */
child_process(e, u);
_exit(EXIT_SUCCESS);
break;
default:
/* parent process */
if ((e->flags & SINGLE_JOB) == 0)
pid = -1;
break;
}
/* only return pid if a singleton */
return (pid);
}
static void
child_process(entry *e, user *u)
{
FILE *in;
int stdin_pipe[2], stdout_pipe[2];
char **p, *input_data, *usernm;
auth_session_t *as;
login_cap_t *lc;
extern char **environ;
/* mark ourselves as different to PS command watchers */
setproctitle("running job");
/* close sockets from parent (i.e. cronSock) */
closefrom(3);
/* discover some useful and important environment settings
*/
usernm = e->pwd->pw_name;
/* 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() explicitly. so we have to reset the signal (which
* was inherited from the parent).
*/
(void) signal(SIGCHLD, SIG_DFL);
/* create some pipes to talk to our future child
*/
if (pipe(stdin_pipe) != 0 || pipe(stdout_pipe) != 0) {
syslog(LOG_ERR, "(CRON) PIPE (%m)");
_exit(EXIT_FAILURE);
}
/* 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. An escaped % will have the escape character stripped
* from it. Subsequent %'s will be transformed into newlines,
* but that happens later.
*/
/*local*/{
int escaped = FALSE;
int ch;
char *p;
for (input_data = p = e->cmd;
(ch = *input_data) != '\0';
input_data++, p++) {
if (p != input_data)
*p = ch;
if (escaped) {
if (ch == '%')
*--p = ch;
escaped = FALSE;
continue;
}
if (ch == '\\') {
escaped = TRUE;
continue;
}
if (ch == '%') {
*input_data++ = '\0';
break;
}
}
*p = '\0';
}
/* fork again, this time so we can exec the user's command.
*/
pid_t jobpid;
switch (jobpid = fork()) {
case -1:
syslog(LOG_ERR, "(CRON) CAN'T FORK (%m)");
_exit(EXIT_FAILURE);
/*NOTREACHED*/
case 0:
/* 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 ((e->flags & DONT_LOG) == 0) {
char *x;
if (stravis(&x, e->cmd, 0) != -1) {
syslog(LOG_INFO, "(%s) CMD (%s)", usernm, x);
free(x);
}
}
/* get new pgrp, void tty, etc.
*/
(void) setsid();
/* 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.
*/
if (stdin_pipe[READ_PIPE] != STDIN_FILENO) {
dup2(stdin_pipe[READ_PIPE], STDIN_FILENO);
close(stdin_pipe[READ_PIPE]);
}
if (stdout_pipe[WRITE_PIPE] != STDOUT_FILENO) {
dup2(stdout_pipe[WRITE_PIPE], STDOUT_FILENO);
close(stdout_pipe[WRITE_PIPE]);
}
dup2(STDOUT_FILENO, STDERR_FILENO);
/*
* From this point on, anything written to stderr will be
* mailed to the user as output.
*/
/* XXX - should just pass in a login_cap_t * */
if ((lc = login_getclass(e->pwd->pw_class)) == NULL) {
warnx("unable to get login class for %s",
e->pwd->pw_name);
syslog(LOG_ERR, "(CRON) CAN'T GET LOGIN CLASS (%s)",
e->pwd->pw_name);
_exit(EXIT_FAILURE);
}
if (setusercontext(lc, e->pwd, e->pwd->pw_uid, LOGIN_SETALL) == -1) {
warn("setusercontext failed for %s", e->pwd->pw_name);
syslog(LOG_ERR, "(%s) SETUSERCONTEXT FAILED (%m)",
e->pwd->pw_name);
_exit(EXIT_FAILURE);
}
as = auth_open();
if (as == NULL || auth_setpwd(as, e->pwd) != 0) {
warn("auth_setpwd");
syslog(LOG_ERR, "(%s) AUTH_SETPWD FAILED (%m)",
e->pwd->pw_name);
_exit(EXIT_FAILURE);
}
if (auth_approval(as, lc, usernm, "cron") <= 0) {
warnx("approval failed for %s", e->pwd->pw_name);
syslog(LOG_ERR, "(%s) APPROVAL FAILED (cron)",
e->pwd->pw_name);
_exit(EXIT_FAILURE);
}
auth_close(as);
login_close(lc);
/* If no PATH specified in crontab file but
* we just added one via login.conf, add it to
* the crontab environment.
*/
if (env_get("PATH", e->envp) == NULL && environ != NULL) {
for (p = environ; *p; p++) {
if (strncmp(*p, "PATH=", 5) == 0) {
e->envp = env_set(e->envp, *p);
break;
}
}
}
chdir(env_get("HOME", e->envp));
(void) signal(SIGPIPE, SIG_DFL);
/*
* Exec the command.
*/
{
char *shell = env_get("SHELL", e->envp);
execle(shell, shell, "-c", e->cmd, (char *)NULL, e->envp);
warn("unable to execute %s", shell);
syslog(LOG_ERR, "(%s) CAN'T EXEC (%s: %m)",
e->pwd->pw_name, shell);
_exit(EXIT_FAILURE);
}
break;
default:
/* parent process */
break;
}
/* middle process, child of original cron, parent of process running
* the user's command.
*/
/* 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. thus we must fork again.
*/
pid_t stdinjob;
if (*input_data && (stdinjob = fork()) == 0) {
FILE *out = fdopen(stdin_pipe[WRITE_PIPE], "w");
int need_newline = FALSE;
int escaped = FALSE;
int ch;
/* 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++) != '\0') {
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);
_exit(EXIT_SUCCESS);
}
/* 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. Its stderr has been redirected to
* its 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.
*/
(void) signal(SIGPIPE, SIG_IGN);
in = fdopen(stdout_pipe[READ_PIPE], "r");
char *mailto;
FILE *mail = NULL;
int status = 0;
pid_t mailpid;
size_t bytes = 1;
if (in != NULL) {
int ch = getc(in);
if (ch != EOF) {
/* get name of recipient. this is MAILTO if set to a
* valid local username; USER otherwise.
*/
mailto = env_get("MAILTO", e->envp);
if (!mailto) {
/* MAILTO not present, set to USER.
*/
mailto = usernm;
} else if (!*mailto || !safe_p(usernm, mailto)) {
mailto = NULL;
}
/* 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) {
char **env;
char mailcmd[MAX_COMMAND];
char hostname[HOST_NAME_MAX + 1];
gethostname(hostname, sizeof(hostname));
if (snprintf(mailcmd, sizeof mailcmd, MAILFMT,
MAILARG) >= sizeof mailcmd) {
syslog(LOG_ERR,
"(%s) ERROR (mailcmd too long)",
e->pwd->pw_name);
(void) _exit(EXIT_FAILURE);
}
if (!(mail = cron_popen(mailcmd, "w", e->pwd,
&mailpid))) {
syslog(LOG_ERR, "(%s) POPEN (%s)",
e->pwd->pw_name, mailcmd);
(void) _exit(EXIT_FAILURE);
}
fprintf(mail, "From: root (Cron Daemon)\n");
fprintf(mail, "To: %s\n", mailto);
fprintf(mail, "Subject: Cron <%s@%s> %s\n",
usernm, first_word(hostname, "."),
e->cmd);
fprintf(mail, "Auto-Submitted: auto-generated\n");
for (env = e->envp; *env; env++)
fprintf(mail, "X-Cron-Env: <%s>\n",
*env);
fprintf(mail, "\n");
/* this was the first char from the pipe
*/
fputc(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 ((ch = getc(in)) != EOF) {
bytes++;
if (mail)
fputc(ch, mail);
}
} /*if data from grandchild*/
fclose(in); /* also closes stdout_pipe[READ_PIPE] */
}
/* wait for children to die.
*/
int waiter;
if (jobpid > 0) {
while (waitpid(jobpid, &waiter, 0) == -1 && errno == EINTR)
;
/* If everything went well, and -n was set, _and_ we have mail,
* we won't be mailing... so shoot the messenger!
*/
if (WIFEXITED(waiter) && WEXITSTATUS(waiter) == 0
&& (e->flags & MAIL_WHEN_ERR) == MAIL_WHEN_ERR
&& mail) {
kill(mailpid, SIGKILL);
(void)fclose(mail);
mail = NULL;
}
/* only close pipe if we opened it -- i.e., we're mailing... */
if (mail) {
/*
* 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 = cron_pclose(mail, mailpid);
}
/* 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 (mail && status) {
syslog(LOG_NOTICE, "(%s) MAIL (mailed %zu byte"
"%s of output but got status 0x%04x)", usernm,
bytes, (bytes == 1) ? "" : "s", status);
}
}
if (stdinjob > 0)
while (waitpid(stdinjob, &waiter, 0) == -1 && errno == EINTR)
;
}
int
safe_p(const char *usernm, const char *s)
{
static const char safe_delim[] = "@!:%+-.,"; /* conservative! */
const char *t;
int ch, first;
for (t = s, first = 1; (ch = (unsigned char)*t++) != '\0'; first = 0) {
if (isascii(ch) && isprint(ch) &&
(isalnum(ch) || ch == '_' ||
(!first && strchr(safe_delim, ch))))
continue;
syslog(LOG_WARNING, "(%s) UNSAFE (%s)", usernm, s);
return (FALSE);
}
return (TRUE);
}