src/src/child.c

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