/* Copyright 2000-2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "apr_arch_threadproc.h" #include "apr_strings.h" #include "apr_portable.h" #include "apr_signal.h" #include "apr_random.h" APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new, apr_pool_t *pool) 15 { 15 (*new) = (apr_procattr_t *)apr_pcalloc(pool, sizeof(apr_procattr_t)); 15 if ((*new) == NULL) { ###### return APR_ENOMEM; } 15 (*new)->pool = pool; 15 (*new)->cmdtype = APR_PROGRAM; 15 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, apr_int32_t out, apr_int32_t err) 12 { 12 apr_status_t status; 12 if (in != 0) { 3 if ((status = apr_file_pipe_create(&attr->child_in, &attr->parent_in, attr->pool)) != APR_SUCCESS) { ###### return status; } 3 switch (in) { case APR_FULL_BLOCK: ###### break; case APR_PARENT_BLOCK: ###### apr_file_pipe_timeout_set(attr->child_in, 0); ###### break; case APR_CHILD_BLOCK: 1 apr_file_pipe_timeout_set(attr->parent_in, 0); 1 break; default: ###### apr_file_pipe_timeout_set(attr->child_in, 0); ###### apr_file_pipe_timeout_set(attr->parent_in, 0); } } 12 if (out) { 2 if ((status = apr_file_pipe_create(&attr->parent_out, &attr->child_out, attr->pool)) != APR_SUCCESS) { ###### return status; } 2 switch (out) { case APR_FULL_BLOCK: ###### break; case APR_PARENT_BLOCK: ###### apr_file_pipe_timeout_set(attr->child_out, 0); ###### break; case APR_CHILD_BLOCK: 1 apr_file_pipe_timeout_set(attr->parent_out, 0); 1 break; default: ###### apr_file_pipe_timeout_set(attr->child_out, 0); ###### apr_file_pipe_timeout_set(attr->parent_out, 0); } } 12 if (err) { 1 if ((status = apr_file_pipe_create(&attr->parent_err, &attr->child_err, attr->pool)) != APR_SUCCESS) { ###### return status; } 1 switch (err) { case APR_FULL_BLOCK: ###### break; case APR_PARENT_BLOCK: ###### apr_file_pipe_timeout_set(attr->child_err, 0); ###### break; case APR_CHILD_BLOCK: 1 apr_file_pipe_timeout_set(attr->parent_err, 0); 1 break; default: ###### apr_file_pipe_timeout_set(attr->child_err, 0); ###### apr_file_pipe_timeout_set(attr->parent_err, 0); } } 12 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in, apr_file_t *parent_in) 1 { 1 if (attr->child_in == NULL && attr->parent_in == NULL) 1 apr_file_pipe_create(&attr->child_in, &attr->parent_in, attr->pool); 1 if (child_in != NULL) 1 apr_file_dup2(attr->child_in, child_in, attr->pool); 1 if (parent_in != NULL) ###### apr_file_dup2(attr->parent_in, parent_in, attr->pool); 1 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out, apr_file_t *parent_out) 1 { 1 if (attr->child_out == NULL && attr->parent_out == NULL) 1 apr_file_pipe_create(&attr->child_out, &attr->parent_out, attr->pool); 1 if (child_out != NULL) 1 apr_file_dup2(attr->child_out, child_out, attr->pool); 1 if (parent_out != NULL) ###### apr_file_dup2(attr->parent_out, parent_out, attr->pool); 1 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err, apr_file_t *parent_err) 1 { 1 if (attr->child_err == NULL && attr->parent_err == NULL) 1 apr_file_pipe_create(&attr->child_err, &attr->parent_err, attr->pool); 1 if (child_err != NULL) 1 apr_file_dup2(attr->child_err, child_err, attr->pool); 1 if (parent_err != NULL) ###### apr_file_dup2(attr->parent_err, parent_err, attr->pool); 1 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr, const char *dir) 2 { 2 attr->currdir = apr_pstrdup(attr->pool, dir); 2 if (attr->currdir) { 2 return APR_SUCCESS; } ###### return APR_ENOMEM; } APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr, apr_cmdtype_e cmd) 2 { 2 attr->cmdtype = cmd; 2 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) ###### { ###### attr->detached = detach; ###### return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *pool) 8 { 8 int pid; 8 if ((pid = fork()) < 0) { ###### return errno; } 16 else if (pid == 0) { 8 proc->pid = pid; 8 proc->in = NULL; 8 proc->out = NULL; 8 proc->err = NULL; 8 apr_random_after_fork(proc); 8 return APR_INCHILD; } 8 proc->pid = pid; 8 proc->in = NULL; 8 proc->out = NULL; 8 proc->err = NULL; 8 return APR_INPARENT; } static apr_status_t limit_proc(apr_procattr_t *attr) 15 { #if APR_HAVE_STRUCT_RLIMIT && APR_HAVE_SETRLIMIT #ifdef RLIMIT_CPU 15 if (attr->limit_cpu != NULL) { ###### if ((setrlimit(RLIMIT_CPU, attr->limit_cpu)) != 0) { ###### return errno; } } #endif #ifdef RLIMIT_NPROC 15 if (attr->limit_nproc != NULL) { ###### if ((setrlimit(RLIMIT_NPROC, attr->limit_nproc)) != 0) { ###### return errno; } } #endif #ifdef RLIMIT_NOFILE 15 if (attr->limit_nofile != NULL) { ###### if ((setrlimit(RLIMIT_NOFILE, attr->limit_nofile)) != 0) { ###### return errno; } } #endif #if defined(RLIMIT_AS) 15 if (attr->limit_mem != NULL) { ###### if ((setrlimit(RLIMIT_AS, attr->limit_mem)) != 0) { ###### return errno; } } #elif defined(RLIMIT_DATA) if (attr->limit_mem != NULL) { if ((setrlimit(RLIMIT_DATA, attr->limit_mem)) != 0) { return errno; } } #elif defined(RLIMIT_VMEM) if (attr->limit_mem != NULL) { if ((setrlimit(RLIMIT_VMEM, attr->limit_mem)) != 0) { return errno; } } #endif #else /* * Maybe make a note in error_log that setrlimit isn't supported?? */ #endif 15 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_child_errfn_set(apr_procattr_t *attr, apr_child_errfn_t *errfn) ###### { ###### attr->errfn = errfn; ###### return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_procattr_error_check_set(apr_procattr_t *attr, apr_int32_t chk) 10 { 10 attr->errchk = chk; 10 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new, const char *progname, const char * const *args, const char * const *env, apr_procattr_t *attr, apr_pool_t *pool) 15 { 15 int i; 15 new->in = attr->parent_in; 15 new->err = attr->parent_err; 15 new->out = attr->parent_out; 15 if (attr->errchk) { 10 if (attr->currdir) { ###### if (access(attr->currdir, R_OK|X_OK) == -1) { /* chdir() in child wouldn't have worked */ ###### return errno; } } 10 if (attr->cmdtype == APR_PROGRAM || attr->cmdtype == APR_PROGRAM_ENV || *progname == '/') { /* for both of these values of cmdtype, caller must pass * full path, so it is easy to check; * caller can choose to pass full path for other * values of cmdtype */ 10 if (access(progname, R_OK|X_OK) == -1) { /* exec*() in child wouldn't have worked */ ###### return errno; } } else { /* todo: search PATH for progname then try to access it */ } } 15 if ((new->pid = fork()) < 0) { ###### return errno; } 30 else if (new->pid == 0) { 15 int status; /* child process */ /* * If we do exec cleanup before the dup2() calls to set up pipes * on 0-2, we accidentally close the pipes used by programs like * mod_cgid. * * If we do exec cleanup after the dup2() calls, cleanup can accidentally * close our pipes which replaced any files which previously had * descriptors 0-2. * * The solution is to kill the cleanup for the pipes, then do * exec cleanup, then do the dup2() calls. */ 15 if (attr->child_in) { 4 apr_pool_cleanup_kill(apr_file_pool_get(attr->child_in), attr->child_in, apr_unix_file_cleanup); } 15 if (attr->child_out) { 3 apr_pool_cleanup_kill(apr_file_pool_get(attr->child_out), attr->child_out, apr_unix_file_cleanup); } 15 if (attr->child_err) { 2 apr_pool_cleanup_kill(apr_file_pool_get(attr->child_err), attr->child_err, apr_unix_file_cleanup); } 15 apr_pool_cleanup_for_exec(); 15 if (attr->child_in) { 4 apr_file_close(attr->parent_in); 4 dup2(attr->child_in->filedes, STDIN_FILENO); 4 apr_file_close(attr->child_in); } 15 if (attr->child_out) { 3 apr_file_close(attr->parent_out); 3 dup2(attr->child_out->filedes, STDOUT_FILENO); 3 apr_file_close(attr->child_out); } 15 if (attr->child_err) { 2 apr_file_close(attr->parent_err); 2 dup2(attr->child_err->filedes, STDERR_FILENO); 2 apr_file_close(attr->child_err); } 15 apr_signal(SIGCHLD, SIG_DFL); /* not sure if this is needed or not */ 15 if (attr->currdir != NULL) { 2 if (chdir(attr->currdir) == -1) { ###### if (attr->errfn) { ###### attr->errfn(pool, errno, "change of working directory failed"); } ###### exit(-1); /* We have big problems, the child should exit. */ } } 15 if ((status = limit_proc(attr)) != APR_SUCCESS) { ###### if (attr->errfn) { ###### attr->errfn(pool, errno, "setting of resource limits failed"); } ###### exit(-1); /* We have big problems, the child should exit. */ } 15 if (attr->cmdtype == APR_SHELLCMD) { ###### int onearg_len = 0; ###### const char *newargs[4]; ###### newargs[0] = SHELL_PATH; ###### newargs[1] = "-c"; ###### i = 0; ###### while (args[i]) { ###### onearg_len += strlen(args[i]); ###### onearg_len++; /* for space delimiter */ ###### i++; } ###### switch(i) { case 0: /* bad parameters; we're doomed */ ###### break; case 1: /* no args, or caller already built a single string from * progname and args */ ###### newargs[2] = args[0]; ###### break; default: { ###### char *ch, *onearg; ###### ch = onearg = apr_palloc(pool, onearg_len); ###### i = 0; ###### while (args[i]) { ###### size_t len = strlen(args[i]); ###### memcpy(ch, args[i], len); ###### ch += len; ###### *ch = ' '; ###### ++ch; ###### ++i; } ###### --ch; /* back up to trailing blank */ ###### *ch = '\0'; ###### newargs[2] = onearg; } } ###### newargs[3] = NULL; ###### if (attr->detached) { ###### apr_proc_detach(APR_PROC_DETACH_DAEMONIZE); } ###### execve(SHELL_PATH, (char * const *) newargs, (char * const *)env); } 15 else if (attr->cmdtype == APR_PROGRAM) { 15 if (attr->detached) { ###### apr_proc_detach(APR_PROC_DETACH_DAEMONIZE); } 15 execve(progname, (char * const *)args, (char * const *)env); } ###### else if (attr->cmdtype == APR_PROGRAM_ENV) { ###### if (attr->detached) { ###### apr_proc_detach(APR_PROC_DETACH_DAEMONIZE); } ###### execv(progname, (char * const *)args); } else { /* APR_PROGRAM_PATH */ ###### if (attr->detached) { ###### apr_proc_detach(APR_PROC_DETACH_DAEMONIZE); } ###### execvp(progname, (char * const *)args); } ###### if (attr->errfn) { ###### char *desc; ###### desc = apr_psprintf(pool, "exec of '%s' failed", progname); ###### attr->errfn(pool, errno, desc); } ###### exit(-1); /* if we get here, there is a problem, so exit with an * error code. */ } /* Parent process */ 15 if (attr->child_in) { 4 apr_file_close(attr->child_in); } 15 if (attr->child_out) { 3 apr_file_close(attr->child_out); } 15 if (attr->child_err) { 2 apr_file_close(attr->child_err); } 15 return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc, int *exitcode, apr_exit_why_e *exitwhy, apr_wait_how_e waithow, apr_pool_t *p) ###### { ###### proc->pid = -1; ###### return apr_proc_wait(proc, exitcode, exitwhy, waithow); } APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc, int *exitcode, apr_exit_why_e *exitwhy, apr_wait_how_e waithow) 22 { 22 pid_t pstatus; 22 int waitpid_options = WUNTRACED; 22 int exit_int; 22 int ignore; 22 apr_exit_why_e ignorewhy; 22 if (exitcode == NULL) { 3 exitcode = &ignore; } 22 if (exitwhy == NULL) { 3 exitwhy = &ignorewhy; } 22 if (waithow != APR_WAIT) { ###### waitpid_options |= WNOHANG; } 22 do { 22 pstatus = waitpid(proc->pid, &exit_int, waitpid_options); 22 } while (pstatus < 0 && errno == EINTR); 22 if (pstatus > 0) { 22 proc->pid = pstatus; 22 if (WIFEXITED(exit_int)) { 22 *exitwhy = APR_PROC_EXIT; 22 *exitcode = WEXITSTATUS(exit_int); } ###### else if (WIFSIGNALED(exit_int)) { ###### *exitwhy = APR_PROC_SIGNAL; #ifdef WCOREDUMP ###### if (WCOREDUMP(exit_int)) { ###### *exitwhy |= APR_PROC_SIGNAL_CORE; } #endif ###### *exitcode = WTERMSIG(exit_int); } else { /* unexpected condition */ ###### return APR_EGENERAL; } 22 return APR_CHILD_DONE; } ###### else if (pstatus == 0) { ###### return APR_CHILD_NOTDONE; } ###### return errno; } APR_DECLARE(apr_status_t) apr_procattr_limit_set(apr_procattr_t *attr, apr_int32_t what, struct rlimit *limit) ###### { ###### switch(what) { case APR_LIMIT_CPU: #ifdef RLIMIT_CPU ###### attr->limit_cpu = limit; ###### break; #else return APR_ENOTIMPL; #endif case APR_LIMIT_MEM: #if defined (RLIMIT_DATA) || defined (RLIMIT_VMEM) || defined(RLIMIT_AS) ###### attr->limit_mem = limit; ###### break; #else return APR_ENOTIMPL; #endif case APR_LIMIT_NPROC: #ifdef RLIMIT_NPROC ###### attr->limit_nproc = limit; ###### break; #else return APR_ENOTIMPL; #endif case APR_LIMIT_NOFILE: #ifdef RLIMIT_NOFILE ###### attr->limit_nofile = limit; break; #else return APR_ENOTIMPL; #endif } ###### return APR_SUCCESS; }