1407b3718cea54aa830736399428732e809b8967
[exim.git] / src / src / child.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9
10 #include "exim.h"
11
12 static void (*oldsignal)(int);
13
14
15 /*************************************************
16 *          Ensure an fd has a given value        *
17 *************************************************/
18
19 /* This function is called when we want to ensure that a certain fd has a
20 specific value (one of 0, 1, 2). If it hasn't got it already, close the value
21 we want, duplicate the fd, then close the old one.
22
23 Arguments:
24   oldfd        original fd
25   newfd        the fd we want
26
27 Returns:       nothing
28 */
29
30 void
31 force_fd(int oldfd, int newfd)
32 {
33 if (oldfd == newfd) return;
34 (void)close(newfd);
35 (void)dup2(oldfd, newfd);
36 (void)close(oldfd);
37 }
38
39
40 #ifndef STAND_ALONE
41 /*************************************************
42 *   Build argv list and optionally re-exec Exim  *
43 *************************************************/
44
45 /* This function is called when Exim wants to re-exec (overlay) itself in the
46 current process. This is different to child_open_exim(), which runs another
47 Exim process in parallel (but it then calls this function). The function's
48 basic job is to build the argv list according to the values of current options
49 settings. There is a basic list that all calls require, and an additional list
50 that some do not require. Further additions can be given as additional
51 arguments. An option specifies whether the exec() is actually to happen, and if
52 so, what is to be done if it fails.
53
54 Arguments:
55   exec_type      CEE_RETURN_ARGV => don't exec; return the argv list
56                  CEE_EXEC_EXIT   => just exit() on exec failure
57                  CEE_EXEC_PANIC  => panic-die on exec failure
58   kill_v         if TRUE, don't pass on the D_v flag
59   pcount         if not NULL, points to extra size of argv required, and if
60                    CEE_RETURN_ARGV is specified, it is updated to give the
61                    number of slots used
62   minimal        TRUE if only minimal argv is required
63   acount         number of additional arguments
64   ...            further values to add to argv
65
66 Returns:         if CEE_RETURN_ARGV is given, returns a pointer to argv;
67                  otherwise, does not return
68 */
69
70 uschar **
71 child_exec_exim(int exec_type, BOOL kill_v, int *pcount, BOOL minimal,
72   int acount, ...)
73 {
74 int first_special = -1;
75 int n = 0;
76 int extra = pcount ? *pcount : 0;
77 uschar **argv;
78
79 argv = store_get((extra + acount + MAX_CLMACROS + 21) * sizeof(char *), FALSE);
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 (f.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   DEBUG(D_any)
114     {
115     argv[n++] = US"-MCd";
116     argv[n++] = US process_purpose;
117     }
118   if (!f.testsuite_delays) argv[n++] = US"-odd";
119   if (f.dont_deliver) argv[n++] = US"-N";
120   if (f.queue_smtp) argv[n++] = US"-odqs";
121   if (f.synchronous_delivery) argv[n++] = US"-odi";
122   if (connection_max_messages >= 0)
123     argv[n++] = string_sprintf("-oB%d", connection_max_messages);
124   if (*queue_name)
125     {
126     argv[n++] = US"-MCG";
127     argv[n++] = queue_name;
128     }
129   }
130
131 /* Now add in any others that are in the call. Remember which they were,
132 for more helpful diagnosis on failure. */
133
134 if (acount > 0)
135   {
136   va_list ap;
137   va_start(ap, acount);
138   first_special = n;
139   while (acount-- > 0)
140     argv[n++] = va_arg(ap, uschar *);
141   va_end(ap);
142   }
143
144 /* Terminate the list, and return it, if that is what is wanted. */
145
146 argv[n] = NULL;
147 if (exec_type == CEE_RETURN_ARGV)
148   {
149   if (pcount) *pcount = n;
150   return argv;
151   }
152
153 /* Otherwise, do the exec() here, and handle the consequences of an unexpected
154 failure. We know that there will always be at least one extra option in the
155 call when exec() is done here, so it can be used to add to the panic data. */
156
157 DEBUG(D_exec) debug_print_argv(CUSS argv);
158 exim_nullstd();                            /* Make sure std{in,out,err} exist */
159 execv(CS argv[0], (char *const *)argv);
160
161 log_write(0,
162   LOG_MAIN | ((exec_type == CEE_EXEC_EXIT)? LOG_PANIC : LOG_PANIC_DIE),
163   "re-exec of exim (%s) with %s failed: %s", exim_path, argv[first_special],
164   strerror(errno));
165
166 /* Get here if exec_type == CEE_EXEC_EXIT.
167 Note: this must be _exit(), not exit(). */
168
169 _exit(EX_EXECFAILED);
170
171 return NULL;   /* To keep compilers happy */
172 }
173
174
175
176
177 /*************************************************
178 *          Create a child Exim process           *
179 *************************************************/
180
181 /* This function is called when Exim wants to run a parallel instance of itself
182 in order to inject a message via the standard input. The function creates a
183 child process and runs Exim in it. It sets up a pipe to the standard input of
184 the new process, and returns that to the caller via fdptr. The function returns
185 the pid of the new process, or -1 if things go wrong. If debug_fd is
186 non-negative, it is passed as stderr.
187
188 This interface is now a just wrapper for the more complicated function
189 child_open_exim2(), which has additional arguments. The wrapper must continue
190 to exist, even if all calls from within Exim are changed, because it is
191 documented for use from local_scan().
192
193 Argument: fdptr   pointer to int for the stdin fd
194           purpose of the child process, for debug
195 Returns:          pid of the created process or -1 if anything has gone wrong
196 */
197
198 pid_t
199 child_open_exim_function(int * fdptr, const uschar * purpose)
200 {
201 return child_open_exim2_function(fdptr, US"<>", bounce_sender_authentication,
202   purpose);
203 }
204
205
206 /* This is a more complicated function for creating a child Exim process, with
207 more arguments.
208
209 Arguments:
210   fdptr                   pointer to int for the stdin fd
211   sender                  for a sender address (data for -f)
212   sender_authentication   authenticated sender address or NULL
213   purpose                 of the child process, for debug
214
215 Returns:          pid of the created process or -1 if anything has gone wrong
216 */
217
218 pid_t
219 child_open_exim2_function(int * fdptr, uschar * sender,
220   uschar * sender_authentication, const uschar * purpose)
221 {
222 int pfd[2];
223 int save_errno;
224 pid_t pid;
225
226 /* Create the pipe and fork the process. Ensure that SIGCHLD is set to
227 SIG_DFL before forking, so that the child process can be waited for. We
228 sometimes get here with it set otherwise. Save the old state for resetting
229 on the wait. */
230
231 if (pipe(pfd) != 0) return (pid_t)(-1);
232 oldsignal = signal(SIGCHLD, SIG_DFL);
233 pid = exim_fork(purpose);
234
235 /* Child process: make the reading end of the pipe into the standard input and
236 close the writing end. If debugging, pass debug_fd as stderr. Then re-exec
237 Exim with appropriate options. In the test harness, use -odi unless queue_only
238 is set, so that the bounce is fully delivered before returning. Failure is
239 signalled with EX_EXECFAILED (specified by CEE_EXEC_EXIT), but this shouldn't
240 occur. */
241
242 if (pid == 0)
243   {
244   force_fd(pfd[pipe_read], 0);
245   (void)close(pfd[pipe_write]);
246   if (debug_fd > 0) force_fd(debug_fd, 2);
247   if (f.running_in_test_harness && !queue_only)
248     {
249     if (sender_authentication)
250       child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 9,
251         US "-odi", US"-t", US"-oem", US"-oi", US"-f", sender, US"-oMas",
252         sender_authentication, message_id_option);
253     else
254       child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 7,
255         US "-odi", US"-t", US"-oem", US"-oi", US"-f", sender,
256         message_id_option);
257     /* Control does not return here. */
258     }
259   else   /* Not test harness */
260     {
261     if (sender_authentication)
262       child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 8,
263         US"-t", US"-oem", US"-oi", US"-f", sender, US"-oMas",
264         sender_authentication, message_id_option);
265     else
266       child_exec_exim(CEE_EXEC_EXIT, FALSE, NULL, FALSE, 6,
267         US"-t", US"-oem", US"-oi", US"-f", sender, message_id_option);
268     /* Control does not return here. */
269     }
270   }
271
272 /* Parent process. Save fork() errno and close the reading end of the stdin
273 pipe. */
274
275 save_errno = errno;
276 (void)close(pfd[pipe_read]);
277
278 /* Fork succeeded */
279
280 if (pid > 0)
281   {
282   *fdptr = pfd[pipe_write];   /* return writing end of stdin pipe */
283   return pid;                 /* and pid of new process */
284   }
285
286 /* Fork failed */
287
288 (void)close(pfd[pipe_write]);
289 errno = save_errno;
290 return (pid_t)(-1);
291 }
292 #endif   /* STAND_ALONE */
293
294
295
296 /*************************************************
297 *         Create a non-Exim child process        *
298 *************************************************/
299
300 /* This function creates a child process and runs the given command in it. It
301 sets up pipes to the standard input and output of the new process, and returns
302 them to the caller. The standard error is cloned to the output. If there are
303 any file descriptors "in the way" in the new process, they are closed. A new
304 umask is supplied for the process, and an optional new uid and gid are also
305 available. These are used by the queryprogram router to set an unprivileged id.
306 SIGUSR1 is always disabled in the new process, as it is not going to be running
307 Exim (the function child_open_exim() is provided for that). This function
308 returns the pid of the new process, or -1 if things go wrong.
309
310 Arguments:
311   argv        the argv for exec in the new process
312   envp        the envp for exec in the new process
313   newumask    umask to set in the new process
314   newuid      point to uid for the new process or NULL for no change
315   newgid      point to gid for the new process or NULL for no change
316   infdptr     pointer to int into which the fd of the stdin of the new process
317                 is placed
318   outfdptr    pointer to int into which the fd of the stdout/stderr of the new
319                 process is placed
320   wd          if not NULL, a path to be handed to chdir() in the new process
321   make_leader if TRUE, make the new process a process group leader
322   purpose     for debug: reason for running the task
323
324 Returns:      the pid of the created process or -1 if anything has gone wrong
325 */
326
327 pid_t
328 child_open_uid(const uschar **argv, const uschar **envp, int newumask,
329   uid_t *newuid, gid_t *newgid, int *infdptr, int *outfdptr, uschar *wd,
330   BOOL make_leader, const uschar * purpose)
331 {
332 int save_errno;
333 int inpfd[2], outpfd[2];
334 pid_t pid;
335
336 /* Create the pipes. */
337
338 if (pipe(inpfd) != 0) return (pid_t)(-1);
339 if (pipe(outpfd) != 0)
340   {
341   (void)close(inpfd[pipe_read]);
342   (void)close(inpfd[pipe_write]);
343   return (pid_t)(-1);
344   }
345
346 /* Fork the process. Ensure that SIGCHLD is set to SIG_DFL before forking, so
347 that the child process can be waited for. We sometimes get here with it set
348 otherwise. Save the old state for resetting on the wait. */
349
350 oldsignal = signal(SIGCHLD, SIG_DFL);
351 pid = exim_fork(purpose);
352
353 /* Handle the child process. First, set the required environment. We must do
354 this before messing with the pipes, in order to be able to write debugging
355 output when things go wrong. */
356
357 if (pid == 0)
358   {
359   signal(SIGUSR1, SIG_IGN);
360   signal(SIGPIPE, SIG_DFL);
361
362   if (newgid && setgid(*newgid) < 0)
363     {
364     DEBUG(D_any) debug_printf("failed to set gid=%ld in subprocess: %s\n",
365       (long int)(*newgid), strerror(errno));
366     goto CHILD_FAILED;
367     }
368
369   if (newuid && setuid(*newuid) < 0)
370     {
371     DEBUG(D_any) debug_printf("failed to set uid=%ld in subprocess: %s\n",
372       (long int)(*newuid), strerror(errno));
373     goto CHILD_FAILED;
374     }
375
376   (void)umask(newumask);
377
378   if (wd && Uchdir(wd) < 0)
379     {
380     DEBUG(D_any) debug_printf("failed to chdir to %s: %s\n", wd,
381       strerror(errno));
382     goto CHILD_FAILED;
383     }
384
385   /* Becomes a process group leader if requested, and then organize the pipes.
386   Any unexpected failure is signalled with EX_EXECFAILED; these are all "should
387   never occur" failures, except for exec failing because the command doesn't
388   exist. */
389
390   if (make_leader && setpgid(0,0) < 0)
391     {
392     DEBUG(D_any) debug_printf("failed to set group leader in subprocess: %s\n",
393       strerror(errno));
394     goto CHILD_FAILED;
395     }
396
397   (void)close(inpfd[pipe_write]);
398   force_fd(inpfd[pipe_read], 0);
399
400   (void)close(outpfd[pipe_read]);
401   force_fd(outpfd[pipe_write], 1);
402
403   (void)close(2);
404   (void)dup2(1, 2);
405
406   /* Now do the exec */
407
408   if (envp) execve(CS argv[0], (char *const *)argv, (char *const *)envp);
409   else execv(CS argv[0], (char *const *)argv);
410
411   /* Failed to execv. Signal this failure using EX_EXECFAILED. We are
412   losing the actual errno we got back, because there is no way to return
413   this information. */
414
415   CHILD_FAILED:
416   _exit(EX_EXECFAILED);      /* Note: must be _exit(), NOT exit() */
417   }
418
419 /* Parent process. Save any fork failure code, and close the reading end of the
420 stdin pipe, and the writing end of the stdout pipe. */
421
422 save_errno = errno;
423 (void)close(inpfd[pipe_read]);
424 (void)close(outpfd[pipe_write]);
425
426 /* Fork succeeded; return the input/output pipes and the pid */
427
428 if (pid > 0)
429   {
430   *infdptr = inpfd[pipe_write];
431   *outfdptr = outpfd[pipe_read];
432   return pid;
433   }
434
435 /* Fork failed; reset fork errno before returning */
436
437 (void)close(inpfd[pipe_write]);
438 (void)close(outpfd[pipe_read]);
439 errno = save_errno;
440 return (pid_t)(-1);
441 }
442
443
444
445
446 /*************************************************
447 *    Create child process without uid change     *
448 *************************************************/
449
450 /* This function is a wrapper for child_open_uid() that doesn't have the uid,
451 gid and working directory changing arguments. The function is provided so as to
452 have a clean interface for use from local_scan(), but also saves writing NULL
453 arguments several calls that would otherwise use child_open_uid().
454
455 Arguments:
456   argv        the argv for exec in the new process
457   envp        the envp for exec in the new process
458   newumask    umask to set in the new process
459   infdptr     pointer to int into which the fd of the stdin of the new process
460                 is placed
461   outfdptr    pointer to int into which the fd of the stdout/stderr of the new
462                 process is placed
463   make_leader if TRUE, make the new process a process group leader
464   purpose     for debug: reason for running the task
465
466 Returns:      the pid of the created process or -1 if anything has gone wrong
467 */
468
469 pid_t
470 child_open_function(uschar **argv, uschar **envp, int newumask, int *infdptr,
471   int *outfdptr, BOOL make_leader, const uschar * purpose)
472 {
473 return child_open_uid(CUSS argv, CUSS envp, newumask, NULL, NULL,
474   infdptr, outfdptr, NULL, make_leader, purpose);
475 }
476
477
478
479
480 /*************************************************
481 *           Close down child process             *
482 *************************************************/
483
484 /* Wait for the given process to finish, with optional timeout.
485
486 Arguments
487   pid:      the pid to wait for
488   timeout:  maximum time to wait; 0 means for as long as it takes
489
490 Returns:    >= 0          process terminated by exiting; value is process
491                             ending status; if an execve() failed, the value
492                             is typically 127 (defined as EX_EXECFAILED)
493             < 0 & > -256  process was terminated by a signal; value is the
494                             negation of the signal number
495             -256          timed out
496             -257          other error in wait(); errno still set
497 */
498
499 int
500 child_close(pid_t pid, int timeout)
501 {
502 int yield;
503
504 if (timeout > 0)
505   {
506   sigalrm_seen = FALSE;
507   ALARM(timeout);
508   }
509
510 for(;;)
511   {
512   int status;
513   pid_t rc = waitpid(pid, &status, 0);
514   if (rc == pid)
515     {
516     int lowbyte = status & 255;
517     yield = lowbyte == 0 ? (status >> 8) & 255 : -lowbyte;
518     break;
519     }
520   if (rc < 0)
521     {
522     /* This "shouldn't happen" test does happen on MacOS: for some reason
523     I do not understand we seems to get an alarm signal despite not having
524     an active alarm set. There seems to be only one, so just go round again. */
525
526     if (errno == EINTR && sigalrm_seen && timeout <= 0) continue;
527
528     yield = (errno == EINTR && sigalrm_seen) ? -256 : -257;
529     break;
530     }
531   }
532
533 if (timeout > 0) ALARM_CLR(0);
534
535 signal(SIGCHLD, oldsignal);   /* restore */
536 return yield;
537 }
538
539 /* End of child.c */