Start
[users/jgh/exim.git] / src / src / child.c
1 /* $Cambridge: exim/src/src/child.c,v 1.1 2004/10/07 10:39:01 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2004 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10
11 #include "exim.h"
12
13 static void (*oldsignal)(int);
14
15
16 /*************************************************
17 *          Ensure an fd has a given value        *
18 *************************************************/
19
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.
23
24 Arguments:
25   oldfd        original fd
26   newfd        the fd we want
27
28 Returns:       nothing
29 */
30
31 static void
32 force_fd(int oldfd, int newfd)
33 {
34 if (oldfd == newfd) return;
35 close(newfd);
36 dup2(oldfd, newfd);
37 close(oldfd);
38 }
39
40
41
42 /*************************************************
43 *   Build argv list and optionally re-exec Exim  *
44 *************************************************/
45
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.
54
55 Arguments:
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
62                    number of slots used
63   minimal        TRUE if only minimal argv is required
64   acount         number of additional arguments
65   ...            further values to add to argv
66
67 Returns:         if CEE_RETURN_ARGV is given, returns a pointer to argv;
68                  otherwise, does not return
69 */
70
71 uschar **
72 child_exec_exim(int exec_type, BOOL kill_v, int *pcount, BOOL minimal,
73   int acount, ...)
74 {
75 int first_special = -1;
76 int n = 0;
77 int extra = (pcount != NULL)? *pcount : 0;
78 uschar **argv =
79   store_get((extra + acount + MAX_CLMACROS + 16) * sizeof(char *));
80
81 /* In all case, the list starts out with the path, any macros, and a changed
82 config file. */
83
84 argv[n++] = exim_path;
85 if (clmacro_count > 0)
86   {
87   memcpy(argv + n, clmacros, clmacro_count * sizeof(uschar *));
88   n += clmacro_count;
89   }
90 if (config_changed)
91   {
92   argv[n++] = US"-C";
93   argv[n++] = config_main_filename;
94   }
95
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. */
101
102 if (!minimal)
103   {
104   if (debug_selector == D_v)
105     {
106     if (!kill_v) argv[n++] = US"-v";
107     }
108   else
109     {
110     if (debug_selector != 0)
111       argv[n++] = string_sprintf("-d=0x%x", debug_selector);
112     }
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);
118   }
119
120 /* Now add in any others that are in the call. Remember which they were,
121 for more helpful diagnosis on failure. */
122
123 if (acount > 0)
124   {
125   va_list ap;
126   va_start(ap, acount);
127   first_special = n;
128   while (acount-- > 0)
129     argv[n++] = va_arg(ap, uschar *);
130   va_end(ap);
131   }
132
133 /* Terminate the list, and return it, if that is what is wanted. */
134
135 argv[n] = NULL;
136 if (exec_type == CEE_RETURN_ARGV)
137   {
138   if (pcount != NULL) *pcount = n;
139   return argv;
140   }
141
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. */
145
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);
149
150 log_write(0,
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],
153   strerror(errno));
154
155 /* Get here if exec_type == CEE_EXEC_EXIT.
156 Note: this must be _exit(), not exit(). */
157
158 _exit(EX_EXECFAILED);
159
160 return NULL;   /* To keep compilers happy */
161 }
162
163
164
165
166 /*************************************************
167 *          Create a child Exim process           *
168 *************************************************/
169
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.
176
177 Argument: fdptr   pointer to int for the stdin fd
178 Returns:          pid of the created process or -1 if anything has gone wrong
179 */
180
181 pid_t
182 child_open_exim(int *fdptr)
183 {
184 int pfd[2];
185 int save_errno;
186 pid_t pid;
187
188 /* Create the pipe and fork the process. Ensure that SIGCHLD is set to
189 SIG_DFL before forking, so that the child process can be waited for. We
190 sometimes get here with it set otherwise. Save the old state for resetting
191 on the wait. */
192
193 if (pipe(pfd) != 0) return (pid_t)(-1);
194 oldsignal = signal(SIGCHLD, SIG_DFL);
195 pid = fork();
196
197 /* Child process: make the reading end of the pipe into the standard input and
198 close the writing end. If debugging, pass debug_fd as stderr. Then re-exec
199 Exim. Failure is signalled with EX_EXECFAILED, but this shouldn't occur! */
200
201 if (pid == 0)
202   {
203   force_fd(pfd[pipe_read], 0);
204   close(pfd[pipe_write]);
205   if (debug_fd > 0) force_fd(debug_fd, 2);
206   if (bounce_sender_authentication != NULL)
207     child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 8,
208       US"-t", US"-oem", US"-oi", US"-f", US"<>", US"-oMas",
209       bounce_sender_authentication, message_id_option);
210   else
211     child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 6,
212       US"-t", US"-oem", US"-oi", US"-f", US"<>", message_id_option);
213   /* Control does not return here. */
214   }
215
216 /* Parent process. Save fork() errno and close the reading end of the stdin
217 pipe. */
218
219 save_errno = errno;
220 close(pfd[pipe_read]);
221
222 /* Fork succeeded */
223
224 if (pid > 0)
225   {
226   *fdptr = pfd[pipe_write];   /* return writing end of stdin pipe */
227   return pid;                 /* and pid of new process */
228   }
229
230 /* Fork failed */
231
232 close(pfd[pipe_write]);
233 errno = save_errno;
234 return (pid_t)(-1);
235 }
236
237
238
239
240 /*************************************************
241 *         Create a non-Exim child process        *
242 *************************************************/
243
244 /* This function creates a child process and runs the given command in it. It
245 sets up pipes to the standard input and output of the new process, and returns
246 them to the caller. The standard error is cloned to the output. If there are
247 any file descriptors "in the way" in the new process, they are closed. A new
248 umask is supplied for the process, and an optional new uid and gid are also
249 available. These are used by the queryprogram router to set an unprivileged id.
250 The function returns the pid of the new process, or -1 if things go wrong.
251
252 Arguments:
253   argv        the argv for exec in the new process
254   envp        the envp for exec in the new process
255   newumask    umask to set in the new process
256   newuid      point to uid for the new process or NULL for no change
257   newgid      point to gid for the new process or NULL for no change
258   infdptr     pointer to int into which the fd of the stdin of the new process
259                 is placed
260   outfdptr    pointer to int into which the fd of the stdout/stderr of the new
261                 process is placed
262   wd          if not NULL, a path to be handed to chdir() in the new process
263   make_leader if TRUE, make the new process a process group leader
264
265 Returns:      the pid of the created process or -1 if anything has gone wrong
266 */
267
268 pid_t
269 child_open_uid(uschar **argv, uschar **envp, int newumask, uid_t *newuid,
270   gid_t *newgid, int *infdptr, int *outfdptr, uschar *wd, BOOL make_leader)
271 {
272 int save_errno;
273 int inpfd[2], outpfd[2];
274 pid_t pid;
275
276 /* Create the pipes. */
277
278 if (pipe(inpfd) != 0) return (pid_t)(-1);
279 if (pipe(outpfd) != 0)
280   {
281   close(inpfd[pipe_read]);
282   close(inpfd[pipe_write]);
283   return (pid_t)(-1);
284   }
285
286 /* Fork the process. Ensure that SIGCHLD is set to SIG_DFL before forking, so
287 that the child process can be waited for. We sometimes get here with it set
288 otherwise. Save the old state for resetting on the wait. */
289
290 oldsignal = signal(SIGCHLD, SIG_DFL);
291 pid = fork();
292
293 /* The child process becomes a process group leader if requested, and then
294 organizes the pipes. Any unexpected failure is signalled with EX_EXECFAILED;
295 these are all "should never occur" failures, except perhaps for exec failing
296 because the command doesn't exist. */
297
298 if (pid == 0)
299   {
300   if (make_leader && setpgid(0,0) < 0) goto CHILD_FAILED;
301
302   close(inpfd[pipe_write]);
303   force_fd(inpfd[pipe_read], 0);
304
305   close(outpfd[pipe_read]);
306   force_fd(outpfd[pipe_write], 1);
307
308   close(2);
309   dup2(1, 2);
310
311   /* Set the required environment. If changing uid, ensure that
312   SIGUSR1 is ignored, as the process won't have the privilege to
313   write to the process log. */
314
315   if (newgid != NULL && setgid(*newgid) < 0) goto CHILD_FAILED;
316   if (newuid != NULL)
317     {
318     signal(SIGUSR1, SIG_IGN);
319     if (setuid(*newuid) < 0) goto CHILD_FAILED;
320     }
321   (void)umask(newumask);
322
323   /* Set the working directory if required */
324
325   if (wd != NULL && Uchdir(wd) < 0) goto CHILD_FAILED;
326
327   /* Now do the exec */
328
329   if (envp == NULL) execv(CS argv[0], (char *const *)argv);
330     else execve(CS argv[0], (char *const *)argv, (char *const *)envp);
331
332   /* Failed to execv. Signal this failure using EX_EXECFAILED. We are
333   losing the actual errno we got back, because there is no way to return
334   this. */
335
336   CHILD_FAILED:
337   _exit(EX_EXECFAILED);      /* Note: must be _exit(), NOT exit() */
338   }
339
340 /* Parent process. Save any fork failure code, and close the reading end of the
341 stdin pipe, and the writing end of the stdout pipe. */
342
343 save_errno = errno;
344 close(inpfd[pipe_read]);
345 close(outpfd[pipe_write]);
346
347 /* Fork succeeded; return the input/output pipes and the pid */
348
349 if (pid > 0)
350   {
351   *infdptr = inpfd[pipe_write];
352   *outfdptr = outpfd[pipe_read];
353   return pid;
354   }
355
356 /* Fork failed; reset fork errno before returning */
357
358 close(inpfd[pipe_write]);
359 close(outpfd[pipe_read]);
360 errno = save_errno;
361 return (pid_t)(-1);
362 }
363
364
365
366
367 /*************************************************
368 *    Create child process without uid change     *
369 *************************************************/
370
371 /* This function is a wrapper for child_open_uid() that doesn't have the uid,
372 gid, and working directory changing arguments. It is provided so as to have a
373 clean interface for use from local_scan(), but also saves writing NULL
374 arguments in other calls.
375
376 Arguments:
377   argv        the argv for exec in the new process
378   envp        the envp for exec in the new process
379   newumask    umask to set in the new process
380   infdptr     pointer to int into which the fd of the stdin of the new process
381                 is placed
382   outfdptr    pointer to int into which the fd of the stdout/stderr of the new
383                 process is placed
384   make_leader if TRUE, make the new process a process group leader
385
386 Returns:      the pid of the created process or -1 if anything has gone wrong
387 */
388
389 pid_t
390 child_open(uschar **argv, uschar **envp, int newumask, int *infdptr,
391   int *outfdptr, BOOL make_leader)
392 {
393 return child_open_uid(argv, envp, newumask, NULL, NULL, infdptr, outfdptr,
394   NULL, make_leader);
395 }
396
397
398
399
400 /*************************************************
401 *           Close down child process             *
402 *************************************************/
403
404 /* Wait for the given process to finish, with optional timeout.
405
406 Arguments
407   pid:      the pid to wait for
408   timeout:  maximum time to wait; 0 means for as long as it takes
409
410 Returns:    >= 0          process terminated by exiting; value is process
411                             ending status; if an execve() failed, the value
412                             is typically 127 (defined as EX_EXECFAILED)
413             < 0 & > -256  process was terminated by a signal; value is the
414                             negation of the signal number
415             -256          timed out
416             -257          other error in wait(); errno still set
417 */
418
419 int
420 child_close(pid_t pid, int timeout)
421 {
422 int yield;
423
424 if (timeout > 0)
425   {
426   sigalrm_seen = FALSE;
427   alarm(timeout);
428   }
429
430 for(;;)
431   {
432   int status;
433   pid_t rc = waitpid(pid, &status, 0);
434   if (rc == pid)
435     {
436     int lowbyte = status & 255;
437     if (lowbyte == 0) yield = (status >> 8) & 255;
438       else yield = -lowbyte;
439     break;
440     }
441   if (rc < 0)
442     {
443     yield = (errno == EINTR && sigalrm_seen)? -256 : -257;
444     break;
445     }
446   }
447
448 if (timeout > 0) alarm(0);
449
450 signal(SIGCHLD, oldsignal);   /* restore */
451 return yield;
452 }
453
454 /* End of child.c */