1 /* $Cambridge: exim/src/src/child.c,v 1.9 2006/02/14 10:26:27 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
8 /* See the file NOTICE for conditions of use and distribution. */
13 static void (*oldsignal)(int);
16 /*************************************************
17 * Ensure an fd has a given value *
18 *************************************************/
20 /* This function is called when we want to ensure that a certain fd has a
21 specific value (one of 0, 1, 2). If it hasn't got it already, close the value
22 we want, duplicate the fd, then close the old one.
32 force_fd(int oldfd, int newfd)
34 if (oldfd == newfd) return;
36 (void)dup2(oldfd, newfd);
42 /*************************************************
43 * Build argv list and optionally re-exec Exim *
44 *************************************************/
46 /* This function is called when Exim wants to re-exec (overlay) itself in the
47 current process. This is different to child_open_exim(), which runs another
48 Exim process in parallel (but it then calls this function). The function's
49 basic job is to build the argv list according to the values of current options
50 settings. There is a basic list that all calls require, and an additional list
51 that some do not require. Further additions can be given as additional
52 arguments. An option specifies whether the exec() is actually to happen, and if
53 so, what is to be done if it fails.
56 exec_type CEE_RETURN_ARGV => don't exec; return the argv list
57 CEE_EXEC_EXIT => just exit() on exec failure
58 CEE_EXEC_PANIC => panic-die on exec failure
59 kill_v if TRUE, don't pass on the D_v flag
60 pcount if not NULL, points to extra size of argv required, and if
61 CEE_RETURN_ARGV is specified, it is updated to give the
63 minimal TRUE if only minimal argv is required
64 acount number of additional arguments
65 ... further values to add to argv
67 Returns: if CEE_RETURN_ARGV is given, returns a pointer to argv;
68 otherwise, does not return
72 child_exec_exim(int exec_type, BOOL kill_v, int *pcount, BOOL minimal,
75 int first_special = -1;
77 int extra = (pcount != NULL)? *pcount : 0;
79 store_get((extra + acount + MAX_CLMACROS + 16) * sizeof(char *));
81 /* In all case, the list starts out with the path, any macros, and a changed
84 argv[n++] = exim_path;
85 if (clmacro_count > 0)
87 memcpy(argv + n, clmacros, clmacro_count * sizeof(uschar *));
93 argv[n++] = config_main_filename;
96 /* These values are added only for non-minimal cases. If debug_selector is
97 precisely D_v, we have to assume this was started by a non-admin user, and
98 we suppress the flag when requested. (This happens when passing on an SMTP
99 connection, and after ETRN.) If there's more debugging going on, an admin user
100 was involved, so we do pass it on. */
104 if (debug_selector == D_v)
106 if (!kill_v) argv[n++] = US"-v";
110 if (debug_selector != 0)
111 argv[n++] = string_sprintf("-d=0x%x", debug_selector);
113 if (dont_deliver) argv[n++] = US"-N";
114 if (queue_smtp) argv[n++] = US"-odqs";
115 if (synchronous_delivery) argv[n++] = US"-odi";
116 if (connection_max_messages >= 0)
117 argv[n++] = string_sprintf("-oB%d", connection_max_messages);
120 /* Now add in any others that are in the call. Remember which they were,
121 for more helpful diagnosis on failure. */
126 va_start(ap, acount);
129 argv[n++] = va_arg(ap, uschar *);
133 /* Terminate the list, and return it, if that is what is wanted. */
136 if (exec_type == CEE_RETURN_ARGV)
138 if (pcount != NULL) *pcount = n;
142 /* Otherwise, do the exec() here, and handle the consequences of an unexpected
143 failure. We know that there will always be at least one extra option in the
144 call when exec() is done here, so it can be used to add to the panic data. */
146 DEBUG(D_exec) debug_print_argv(argv);
147 exim_nullstd(); /* Make sure std{in,out,err} exist */
148 execv(CS argv[0], (char *const *)argv);
151 LOG_MAIN | ((exec_type == CEE_EXEC_EXIT)? LOG_PANIC : LOG_PANIC_DIE),
152 "re-exec of exim (%s) with %s failed: %s", exim_path, argv[first_special],
155 /* Get here if exec_type == CEE_EXEC_EXIT.
156 Note: this must be _exit(), not exit(). */
158 _exit(EX_EXECFAILED);
160 return NULL; /* To keep compilers happy */
166 /*************************************************
167 * Create a child Exim process *
168 *************************************************/
170 /* This function is called when Exim wants to run a parallel instance of itself
171 in order to inject a message via the standard input. The function creates a
172 child process and runs Exim in it. It sets up a pipe to the standard input of
173 the new process, and returns that to the caller via fdptr. The function returns
174 the pid of the new process, or -1 if things go wrong. If debug_fd is
175 non-negative, it is passed as stderr.
177 This interface is now a just wrapper for the more complicated function
178 child_open_exim2(), which has additional arguments. The wrapper must continue
179 to exist, even if all calls from within Exim are changed, because it is
180 documented for use from local_scan().
182 Argument: fdptr pointer to int for the stdin fd
183 Returns: pid of the created process or -1 if anything has gone wrong
187 child_open_exim(int *fdptr)
189 return child_open_exim2(fdptr, US"<>", bounce_sender_authentication);
193 /* This is a more complicated function for creating a child Exim process, with
197 fdptr pointer to int for the stdin fd
198 sender for a sender address (data for -f)
199 sender_authentication authenticated sender address or NULL
201 Returns: pid of the created process or -1 if anything has gone wrong
205 child_open_exim2(int *fdptr, uschar *sender, uschar *sender_authentication)
211 /* Create the pipe and fork the process. Ensure that SIGCHLD is set to
212 SIG_DFL before forking, so that the child process can be waited for. We
213 sometimes get here with it set otherwise. Save the old state for resetting
216 if (pipe(pfd) != 0) return (pid_t)(-1);
217 oldsignal = signal(SIGCHLD, SIG_DFL);
220 /* Child process: make the reading end of the pipe into the standard input and
221 close the writing end. If debugging, pass debug_fd as stderr. Then re-exec
222 Exim. Failure is signalled with EX_EXECFAILED, but this shouldn't occur! */
226 force_fd(pfd[pipe_read], 0);
227 (void)close(pfd[pipe_write]);
228 if (debug_fd > 0) force_fd(debug_fd, 2);
229 if (sender_authentication != NULL)
230 child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 8,
231 US"-t", US"-oem", US"-oi", US"-f", sender, US"-oMas",
232 sender_authentication, message_id_option);
234 child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 6,
235 US"-t", US"-oem", US"-oi", US"-f", sender, message_id_option);
236 /* Control does not return here. */
239 /* Parent process. Save fork() errno and close the reading end of the stdin
243 (void)close(pfd[pipe_read]);
249 *fdptr = pfd[pipe_write]; /* return writing end of stdin pipe */
250 return pid; /* and pid of new process */
255 (void)close(pfd[pipe_write]);
263 /*************************************************
264 * Create a non-Exim child process *
265 *************************************************/
267 /* This function creates a child process and runs the given command in it. It
268 sets up pipes to the standard input and output of the new process, and returns
269 them to the caller. The standard error is cloned to the output. If there are
270 any file descriptors "in the way" in the new process, they are closed. A new
271 umask is supplied for the process, and an optional new uid and gid are also
272 available. These are used by the queryprogram router to set an unprivileged id.
273 SIGUSR1 is always disabled in the new process, as it is not going to be running
274 Exim (the function child_open_exim() is provided for that). This function
275 returns the pid of the new process, or -1 if things go wrong.
278 argv the argv for exec in the new process
279 envp the envp for exec in the new process
280 newumask umask to set in the new process
281 newuid point to uid for the new process or NULL for no change
282 newgid point to gid for the new process or NULL for no change
283 infdptr pointer to int into which the fd of the stdin of the new process
285 outfdptr pointer to int into which the fd of the stdout/stderr of the new
287 wd if not NULL, a path to be handed to chdir() in the new process
288 make_leader if TRUE, make the new process a process group leader
290 Returns: the pid of the created process or -1 if anything has gone wrong
294 child_open_uid(uschar **argv, uschar **envp, int newumask, uid_t *newuid,
295 gid_t *newgid, int *infdptr, int *outfdptr, uschar *wd, BOOL make_leader)
298 int inpfd[2], outpfd[2];
301 /* Create the pipes. */
303 if (pipe(inpfd) != 0) return (pid_t)(-1);
304 if (pipe(outpfd) != 0)
306 (void)close(inpfd[pipe_read]);
307 (void)close(inpfd[pipe_write]);
311 /* Fork the process. Ensure that SIGCHLD is set to SIG_DFL before forking, so
312 that the child process can be waited for. We sometimes get here with it set
313 otherwise. Save the old state for resetting on the wait. */
315 oldsignal = signal(SIGCHLD, SIG_DFL);
318 /* Handle the child process. First, set the required environment. We must do
319 this before messing with the pipes, in order to be able to write debugging
320 output when things go wrong. */
324 signal(SIGUSR1, SIG_IGN);
326 if (newgid != NULL && setgid(*newgid) < 0)
328 DEBUG(D_any) debug_printf("failed to set gid=%ld in subprocess: %s\n",
329 (long int)(*newgid), strerror(errno));
333 if (newuid != NULL && setuid(*newuid) < 0)
335 DEBUG(D_any) debug_printf("failed to set uid=%ld in subprocess: %s\n",
336 (long int)(*newuid), strerror(errno));
340 (void)umask(newumask);
342 if (wd != NULL && Uchdir(wd) < 0)
344 DEBUG(D_any) debug_printf("failed to chdir to %s: %s\n", wd,
349 /* Becomes a process group leader if requested, and then organize the pipes.
350 Any unexpected failure is signalled with EX_EXECFAILED; these are all "should
351 never occur" failures, except for exec failing because the command doesn't
354 if (make_leader && setpgid(0,0) < 0)
356 DEBUG(D_any) debug_printf("failed to set group leader in subprocess: %s\n",
361 (void)close(inpfd[pipe_write]);
362 force_fd(inpfd[pipe_read], 0);
364 (void)close(outpfd[pipe_read]);
365 force_fd(outpfd[pipe_write], 1);
370 /* Now do the exec */
372 if (envp == NULL) execv(CS argv[0], (char *const *)argv);
373 else execve(CS argv[0], (char *const *)argv, (char *const *)envp);
375 /* Failed to execv. Signal this failure using EX_EXECFAILED. We are
376 losing the actual errno we got back, because there is no way to return
380 _exit(EX_EXECFAILED); /* Note: must be _exit(), NOT exit() */
383 /* Parent process. Save any fork failure code, and close the reading end of the
384 stdin pipe, and the writing end of the stdout pipe. */
387 (void)close(inpfd[pipe_read]);
388 (void)close(outpfd[pipe_write]);
390 /* Fork succeeded; return the input/output pipes and the pid */
394 *infdptr = inpfd[pipe_write];
395 *outfdptr = outpfd[pipe_read];
399 /* Fork failed; reset fork errno before returning */
401 (void)close(inpfd[pipe_write]);
402 (void)close(outpfd[pipe_read]);
410 /*************************************************
411 * Create child process without uid change *
412 *************************************************/
414 /* This function is a wrapper for child_open_uid() that doesn't have the uid,
415 gid and working directory changing arguments. The function is provided so as to
416 have a clean interface for use from local_scan(), but also saves writing NULL
417 arguments several calls that would otherwise use child_open_uid().
420 argv the argv for exec in the new process
421 envp the envp for exec in the new process
422 newumask umask to set in the new process
423 infdptr pointer to int into which the fd of the stdin of the new process
425 outfdptr pointer to int into which the fd of the stdout/stderr of the new
427 make_leader if TRUE, make the new process a process group leader
429 Returns: the pid of the created process or -1 if anything has gone wrong
433 child_open(uschar **argv, uschar **envp, int newumask, int *infdptr,
434 int *outfdptr, BOOL make_leader)
436 return child_open_uid(argv, envp, newumask, NULL, NULL, infdptr, outfdptr,
443 /*************************************************
444 * Close down child process *
445 *************************************************/
447 /* Wait for the given process to finish, with optional timeout.
450 pid: the pid to wait for
451 timeout: maximum time to wait; 0 means for as long as it takes
453 Returns: >= 0 process terminated by exiting; value is process
454 ending status; if an execve() failed, the value
455 is typically 127 (defined as EX_EXECFAILED)
456 < 0 & > -256 process was terminated by a signal; value is the
457 negation of the signal number
459 -257 other error in wait(); errno still set
463 child_close(pid_t pid, int timeout)
469 sigalrm_seen = FALSE;
476 pid_t rc = waitpid(pid, &status, 0);
479 int lowbyte = status & 255;
480 if (lowbyte == 0) yield = (status >> 8) & 255;
481 else yield = -lowbyte;
486 yield = (errno == EINTR && sigalrm_seen)? -256 : -257;
491 if (timeout > 0) alarm(0);
493 signal(SIGCHLD, oldsignal); /* restore */