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 testharness_pause_ms(100); /* let child work even longer, for exec */
 273
 274 /* Parent process. Save fork() errno and close the reading end of the stdin
 275 pipe. */
 276
 277 save_errno = errno;
 278 (void)close(pfd[pipe_read]);
 279
 280 /* Fork succeeded */
 281
 282 if (pid > 0)
 283   {
 284   *fdptr = pfd[pipe_write];   /* return writing end of stdin pipe */
 285   return pid;                 /* and pid of new process */
 286   }
 287
 288 /* Fork failed */
 289
 290 (void)close(pfd[pipe_write]);
 291 errno = save_errno;
 292 return (pid_t)(-1);
 293 }
 294 #endif   /* STAND_ALONE */
 295
 296
 297
 298 /*************************************************
 299 *         Create a non-Exim child process        *
 300 *************************************************/
 301
 302 /* This function creates a child process and runs the given command in it. It
 303 sets up pipes to the standard input and output of the new process, and returns
 304 them to the caller. The standard error is cloned to the output. If there are
 305 any file descriptors "in the way" in the new process, they are closed. A new
 306 umask is supplied for the process, and an optional new uid and gid are also
 307 available. These are used by the queryprogram router to set an unprivileged id.
 308 SIGUSR1 is always disabled in the new process, as it is not going to be running
 309 Exim (the function child_open_exim() is provided for that). This function
 310 returns the pid of the new process, or -1 if things go wrong.
 311
 312 Arguments:
 313   argv        the argv for exec in the new process
 314   envp        the envp for exec in the new process
 315   newumask    umask to set in the new process
 316   newuid      point to uid for the new process or NULL for no change
 317   newgid      point to gid for the new process or NULL for no change
 318   infdptr     pointer to int into which the fd of the stdin of the new process
 319                 is placed
 320   outfdptr    pointer to int into which the fd of the stdout/stderr of the new
 321                 process is placed
 322   wd          if not NULL, a path to be handed to chdir() in the new process
 323   make_leader if TRUE, make the new process a process group leader
 324   purpose     for debug: reason for running the task
 325
 326 Returns:      the pid of the created process or -1 if anything has gone wrong
 327 */
 328
 329 pid_t
 330 child_open_uid(const uschar **argv, const uschar **envp, int newumask,
 331   uid_t *newuid, gid_t *newgid, int *infdptr, int *outfdptr, uschar *wd,
 332   BOOL make_leader, const uschar * purpose)
 333 {
 334 int save_errno;
 335 int inpfd[2], outpfd[2];
 336 pid_t pid;
 337
 338 /* Create the pipes. */
 339
 340 if (pipe(inpfd) != 0) return (pid_t)(-1);
 341 if (pipe(outpfd) != 0)
 342   {
 343   (void)close(inpfd[pipe_read]);
 344   (void)close(inpfd[pipe_write]);
 345   return (pid_t)(-1);
 346   }
 347
 348 /* Fork the process. Ensure that SIGCHLD is set to SIG_DFL before forking, so
 349 that the child process can be waited for. We sometimes get here with it set
 350 otherwise. Save the old state for resetting on the wait. */
 351
 352 oldsignal = signal(SIGCHLD, SIG_DFL);
 353 pid = exim_fork(purpose);
 354
 355 /* Handle the child process. First, set the required environment. We must do
 356 this before messing with the pipes, in order to be able to write debugging
 357 output when things go wrong. */
 358
 359 if (pid == 0)
 360   {
 361   signal(SIGUSR1, SIG_IGN);
 362   signal(SIGPIPE, SIG_DFL);
 363
 364   if (newgid && setgid(*newgid) < 0)
 365     {
 366     DEBUG(D_any) debug_printf("failed to set gid=%ld in subprocess: %s\n",
 367       (long int)(*newgid), strerror(errno));
 368     goto CHILD_FAILED;
 369     }
 370
 371   if (newuid && setuid(*newuid) < 0)
 372     {
 373     DEBUG(D_any) debug_printf("failed to set uid=%ld in subprocess: %s\n",
 374       (long int)(*newuid), strerror(errno));
 375     goto CHILD_FAILED;
 376     }
 377
 378   (void)umask(newumask);
 379
 380   if (wd && Uchdir(wd) < 0)
 381     {
 382     DEBUG(D_any) debug_printf("failed to chdir to %s: %s\n", wd,
 383       strerror(errno));
 384     goto CHILD_FAILED;
 385     }
 386
 387   /* Becomes a process group leader if requested, and then organize the pipes.
 388   Any unexpected failure is signalled with EX_EXECFAILED; these are all "should
 389   never occur" failures, except for exec failing because the command doesn't
 390   exist. */
 391
 392   if (make_leader && setpgid(0,0) < 0)
 393     {
 394     DEBUG(D_any) debug_printf("failed to set group leader in subprocess: %s\n",
 395       strerror(errno));
 396     goto CHILD_FAILED;
 397     }
 398
 399   (void)close(inpfd[pipe_write]);
 400   force_fd(inpfd[pipe_read], 0);
 401
 402   (void)close(outpfd[pipe_read]);
 403   force_fd(outpfd[pipe_write], 1);
 404
 405   (void)close(2);
 406   (void)dup2(1, 2);
 407
 408   /* Now do the exec */
 409
 410   if (envp) execve(CS argv[0], (char *const *)argv, (char *const *)envp);
 411   else execv(CS argv[0], (char *const *)argv);
 412
 413   /* Failed to execv. Signal this failure using EX_EXECFAILED. We are
 414   losing the actual errno we got back, because there is no way to return
 415   this information. */
 416
 417   CHILD_FAILED:
 418   _exit(EX_EXECFAILED);      /* Note: must be _exit(), NOT exit() */
 419   }
 420
 421 /* Parent process. Save any fork failure code, and close the reading end of the
 422 stdin pipe, and the writing end of the stdout pipe. */
 423
 424 save_errno = errno;
 425 (void)close(inpfd[pipe_read]);
 426 (void)close(outpfd[pipe_write]);
 427
 428 /* Fork succeeded; return the input/output pipes and the pid */
 429
 430 if (pid > 0)
 431   {
 432   *infdptr = inpfd[pipe_write];
 433   *outfdptr = outpfd[pipe_read];
 434   return pid;
 435   }
 436
 437 /* Fork failed; reset fork errno before returning */
 438
 439 (void)close(inpfd[pipe_write]);
 440 (void)close(outpfd[pipe_read]);
 441 errno = save_errno;
 442 return (pid_t)(-1);
 443 }
 444
 445
 446
 447
 448 /*************************************************
 449 *    Create child process without uid change     *
 450 *************************************************/
 451
 452 /* This function is a wrapper for child_open_uid() that doesn't have the uid,
 453 gid and working directory changing arguments. The function is provided so as to
 454 have a clean interface for use from local_scan(), but also saves writing NULL
 455 arguments several calls that would otherwise use child_open_uid().
 456
 457 Arguments:
 458   argv        the argv for exec in the new process
 459   envp        the envp for exec in the new process
 460   newumask    umask to set in the new process
 461   infdptr     pointer to int into which the fd of the stdin of the new process
 462                 is placed
 463   outfdptr    pointer to int into which the fd of the stdout/stderr of the new
 464                 process is placed
 465   make_leader if TRUE, make the new process a process group leader
 466   purpose     for debug: reason for running the task
 467
 468 Returns:      the pid of the created process or -1 if anything has gone wrong
 469 */
 470
 471 pid_t
 472 child_open_function(uschar **argv, uschar **envp, int newumask, int *infdptr,
 473   int *outfdptr, BOOL make_leader, const uschar * purpose)
 474 {
 475 return child_open_uid(CUSS argv, CUSS envp, newumask, NULL, NULL,
 476   infdptr, outfdptr, NULL, make_leader, purpose);
 477 }
 478
 479
 480
 481
 482 /*************************************************
 483 *           Close down child process             *
 484 *************************************************/
 485
 486 /* Wait for the given process to finish, with optional timeout.
 487
 488 Arguments
 489   pid:      the pid to wait for
 490   timeout:  maximum time to wait; 0 means for as long as it takes
 491
 492 Returns:    >= 0          process terminated by exiting; value is process
 493                             ending status; if an execve() failed, the value
 494                             is typically 127 (defined as EX_EXECFAILED)
 495             < 0 & > -256  process was terminated by a signal; value is the
 496                             negation of the signal number
 497             -256          timed out
 498             -257          other error in wait(); errno still set
 499 */
 500
 501 int
 502 child_close(pid_t pid, int timeout)
 503 {
 504 int yield;
 505
 506 if (timeout > 0)
 507   {
 508   sigalrm_seen = FALSE;
 509   ALARM(timeout);
 510   }
 511
 512 for(;;)
 513   {
 514   int status;
 515   pid_t rc = waitpid(pid, &status, 0);
 516   if (rc == pid)
 517     {
 518     int lowbyte = status & 255;
 519     yield = lowbyte == 0 ? (status >> 8) & 255 : -lowbyte;
 520     break;
 521     }
 522   if (rc < 0)
 523     {
 524     /* This "shouldn't happen" test does happen on MacOS: for some reason
 525     I do not understand we seems to get an alarm signal despite not having
 526     an active alarm set. There seems to be only one, so just go round again. */
 527
 528     if (errno == EINTR && sigalrm_seen && timeout <= 0) continue;
 529
 530     yield = (errno == EINTR && sigalrm_seen) ? -256 : -257;
 531     break;
 532     }
 533   }
 534
 535 if (timeout > 0) ALARM_CLR(0);
 536
 537 signal(SIGCHLD, oldsignal);   /* restore */
 538 return yield;
 539 }
 540
 541 /* End of child.c */