fcgi_pm.c

   1 /*
   2  * $Id: fcgi_pm.c,v 1.75 2002/07/29 00:07:28 robs Exp $
   3  */
   4
   5
   6 #include "fcgi.h"
   7
   8 #if defined(APACHE2) && !defined(WIN32)
   9 #include <pwd.h>
  10 #endif
  11
  12 #ifdef _HPUX_SOURCE
  13 #include <unistd.h>
  14 #define seteuid(arg) setresuid(-1, (arg), -1)
  15 #endif
  16
  17 int fcgi_dynamic_total_proc_count = 0;    /* number of running apps */
  18 time_t fcgi_dynamic_epoch = 0;            /* last time kill_procs was
  19                                            * invoked by process mgr */
  20 time_t fcgi_dynamic_last_analyzed = 0;    /* last time calculation was
  21                                            * made for the dynamic procs */
  22
  23 static time_t now = 0;
  24
  25 #ifdef WIN32
  26 #pragma warning ( disable : 4100 4102 )
  27 static BOOL bTimeToDie = FALSE;  /* process termination flag */
  28 HANDLE fcgi_event_handles[3];
  29 #ifndef SIGKILL
  30 #define SIGKILL 9
  31 #endif
  32 #endif
  33
  34
  35 #if !defined(WIN32) && !defined(APACHE2)
  36 static int seteuid_root(void)
  37 {
  38     int rc = seteuid((uid_t)0);
  39     if (rc == -1) {
  40         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
  41             "FastCGI: seteuid(0) failed");
  42     }
  43     return rc;
  44 }
  45
  46 static int seteuid_user(void)
  47 {
  48     int rc = seteuid(ap_user_id);
  49     if (rc == -1) {
  50         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
  51             "FastCGI: seteuid(%u) failed", (unsigned)ap_user_id);
  52     }
  53     return rc;
  54 }
  55 #endif
  56
  57 /*
  58  * Signal the process to exit.  How (or if) the process responds
  59  * depends on the FastCGI application library (esp. on Win32) and
  60  * possibly application code (signal handlers and whether or not
  61  * SA_RESTART is on).  At any rate, we send the signal with the
  62  * hopes that the process will exit on its own.  Later, as we
  63  * review the state of application processes, if we see one marked
  64  * for death, but that hasn't died within a specified period of
  65  * time, fcgi_kill() is called again with a KILL)
  66  */
  67 static void fcgi_kill(ServerProcess *process, int sig)
  68 {
  69     FCGIDBG3("fcgi_kill(%ld, %d)", (long) process->pid, sig);
  70
  71     process->state = FCGI_VICTIM_STATE;
  72
  73 #ifdef WIN32
  74
  75     if (sig == SIGTERM)
  76     {
  77         SetEvent(process->terminationEvent);
  78     }
  79     else if (sig == SIGKILL)
  80     {
  81         TerminateProcess(process->handle, 1);
  82     }
  83     else
  84     {
  85         ap_assert(0);
  86     }
  87
  88 #else /* !WIN32 */
  89
  90 #ifndef APACHE2
  91     if (fcgi_wrapper)
  92     {
  93         seteuid_root();
  94     }
  95 #endif
  96
  97     kill(process->pid, sig);
  98
  99 #ifndef APACHE2
 100     if (fcgi_wrapper)
 101     {
 102         seteuid_user();
 103     }
 104 #endif
 105
 106 #endif /* !WIN32 */
 107 }
 108
 109 /*******************************************************************************
 110  * Send SIGTERM to each process in the server class, remove socket
 111  * file if appropriate.  Currently this is only called when the PM is shutting
 112  * down and thus memory isn't freed and sockets and files aren't closed.
 113  */
 114 static void shutdown_all()
 115 {
 116     fcgi_server *s = fcgi_servers;
 117
 118     while (s)
 119     {
 120         ServerProcess *proc = s->procs;
 121         int i;
 122         int numChildren = (s->directive == APP_CLASS_DYNAMIC)
 123             ? dynamicMaxClassProcs
 124             : s->numProcesses;
 125
 126 #ifndef WIN32
 127         if (s->socket_path != NULL && s->directive != APP_CLASS_EXTERNAL)
 128         {
 129             /* Remove the socket file */
 130             if (unlink(s->socket_path) != 0 && errno != ENOENT) {
 131                 ap_log_error(FCGI_LOG_ERR, fcgi_apache_main_server,
 132                     "FastCGI: unlink() failed to remove socket file \"%s\" for%s server \"%s\"",
 133                     s->socket_path,
 134                     (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "", s->fs_path);
 135             }
 136         }
 137 #endif
 138
 139         /* Send TERM to all processes */
 140         for (i = 0; i < numChildren; i++, proc++)
 141         {
 142             if (proc->state == FCGI_RUNNING_STATE)
 143             {
 144                 fcgi_kill(proc, SIGTERM);
 145             }
 146         }
 147
 148         s = s->next;
 149     }
 150
 151 #if defined(WIN32) && (WIN32_SHUTDOWN_GRACEFUL_WAIT > 0)
 152
 153     /*
 154      * WIN32 applications may not have support for the shutdown event
 155      * depending on their application library version
 156      */
 157
 158     Sleep(WIN32_SHUTDOWN_GRACEFUL_WAIT);
 159     s = fcgi_servers;
 160
 161     while (s)
 162     {
 163         ServerProcess *proc = s->procs;
 164         int i;
 165         int numChildren = (s->directive == APP_CLASS_DYNAMIC)
 166             ? dynamicMaxClassProcs
 167             : s->numProcesses;
 168
 169         /* Send KILL to all processes */
 170         for (i = 0; i < numChildren; i++, proc++)
 171         {
 172             if (proc->state == FCGI_RUNNING_STATE)
 173             {
 174                 fcgi_kill(proc, SIGKILL);
 175             }
 176         }
 177
 178         s = s->next;
 179     }
 180
 181 #endif /* WIN32 */
 182 }
 183
 184 static int init_listen_sock(fcgi_server * fs)
 185 {
 186     ap_assert(fs->directive != APP_CLASS_EXTERNAL);
 187
 188     /* Create the socket */
 189     if ((fs->listenFd = socket(fs->socket_addr->sa_family, SOCK_STREAM, 0)) < 0)
 190     {
 191 #ifdef WIN32
 192         errno = WSAGetLastError();  // Not sure if this will work as expected
 193 #endif
 194         ap_log_error(FCGI_LOG_CRIT_ERRNO, fcgi_apache_main_server,
 195             "FastCGI: can't create %sserver \"%s\": socket() failed",
 196             (fs->directive == APP_CLASS_DYNAMIC) ? "(dynamic) " : "",
 197             fs->fs_path);
 198         return -1;
 199     }
 200
 201 #ifndef WIN32
 202     if (fs->socket_addr->sa_family == AF_UNIX)
 203     {
 204         /* Remove any existing socket file.. just in case */
 205         unlink(((struct sockaddr_un *)fs->socket_addr)->sun_path);
 206     }
 207     else
 208 #endif
 209     {
 210         int flag = 1;
 211         setsockopt(fs->listenFd, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof(flag));
 212     }
 213
 214     /* Bind it to the socket_addr */
 215     if (bind(fs->listenFd, fs->socket_addr, fs->socket_addr_len))
 216     {
 217         char port[11];
 218
 219 #ifdef WIN32
 220         errno = WSAGetLastError();
 221 #endif
 222         ap_snprintf(port, sizeof(port), "port=%d",
 223             ((struct sockaddr_in *)fs->socket_addr)->sin_port);
 224
 225         ap_log_error(FCGI_LOG_CRIT_ERRNO, fcgi_apache_main_server,
 226             "FastCGI: can't create %sserver \"%s\": bind() failed [%s]",
 227             (fs->directive == APP_CLASS_DYNAMIC) ? "(dynamic) " : "",
 228             fs->fs_path,
 229 #ifndef WIN32
 230             (fs->socket_addr->sa_family == AF_UNIX) ?
 231                 ((struct sockaddr_un *)fs->socket_addr)->sun_path :
 232 #endif
 233                 port);
 234     }
 235
 236 #ifndef WIN32
 237     /* Twiddle Unix socket permissions */
 238     else if (fs->socket_addr->sa_family == AF_UNIX
 239         && chmod(((struct sockaddr_un *)fs->socket_addr)->sun_path, S_IRUSR | S_IWUSR))
 240     {
 241         ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
 242             "FastCGI: can't create %sserver \"%s\": chmod() of socket failed",
 243             (fs->directive == APP_CLASS_DYNAMIC) ? "(dynamic) " : "",
 244             fs->fs_path);
 245     }
 246 #endif
 247
 248     /* Set to listen */
 249     else if (listen(fs->listenFd, fs->listenQueueDepth))
 250     {
 251 #ifdef WIN32
 252         errno = WSAGetLastError();
 253 #endif
 254         ap_log_error(FCGI_LOG_CRIT_ERRNO, fcgi_apache_main_server,
 255             "FastCGI: can't create %sserver \"%s\": listen() failed",
 256             (fs->directive == APP_CLASS_DYNAMIC) ? "(dynamic) " : "",
 257             fs->fs_path);
 258     }
 259     else
 260     {
 261         return 0;
 262     }
 263
 264     close(fs->listenFd);
 265     fs->listenFd = -1;
 266     return -2;
 267 }
 268
 269 /*
 270  *----------------------------------------------------------------------
 271  *
 272  * pm_main
 273  *
 274  *      The FastCGI process manager, which runs as a separate
 275  *      process responsible for:
 276  *        - Starting all the FastCGI proceses.
 277  *        - Restarting any of these processes that die (indicated
 278  *          by SIGCHLD).
 279  *        - Catching SIGTERM and relaying it to all the FastCGI
 280  *          processes before exiting.
 281  *
 282  * Inputs:
 283  *      Uses global variable fcgi_servers.
 284  *
 285  * Results:
 286  *      Does not return.
 287  *
 288  * Side effects:
 289  *      Described above.
 290  *
 291  *----------------------------------------------------------------------
 292  */
 293 #ifndef WIN32
 294 static int caughtSigTerm = FALSE;
 295 static int caughtSigChld = FALSE;
 296 static int caughtSigAlarm = FALSE;
 297
 298 static void signal_handler(int signo)
 299 {
 300     if ((signo == SIGTERM) || (signo == SIGUSR1) || (signo == SIGHUP)) {
 301         /* SIGUSR1 & SIGHUP are sent by apache to its process group
 302          * when apache get 'em.  Apache follows up (1.2.x) with attacks
 303          * on each of its child processes, but we've got the KillMgr
 304          * sitting between us so we never see the KILL.  The main loop
 305          * in ProcMgr also checks to see if the KillMgr has terminated,
 306          * and if it has, we handl it as if we should shutdown too. */
 307         caughtSigTerm = TRUE;
 308     } else if(signo == SIGCHLD) {
 309         caughtSigChld = TRUE;
 310     } else if(signo == SIGALRM) {
 311         caughtSigAlarm = TRUE;
 312     }
 313 }
 314 #endif
 315
 316 /*
 317  *----------------------------------------------------------------------
 318  *
 319  * spawn_fs_process --
 320  *
 321  *      Fork and exec the specified fcgi process.
 322  *
 323  * Results:
 324  *      0 for successful fork, -1 for failed fork.
 325  *
 326  *      In case the child fails before or in the exec, the child
 327  *      obtains the error log by calling getErrLog, logs
 328  *      the error, and exits with exit status = errno of
 329  *      the failed system call.
 330  *
 331  * Side effects:
 332  *      Child process created.
 333  *
 334  *----------------------------------------------------------------------
 335  */
 336 static pid_t spawn_fs_process(fcgi_server *fs, ServerProcess *process)
 337 {
 338 #ifndef WIN32
 339
 340     pid_t child_pid;
 341     int i;
 342     char *dirName;
 343     char *dnEnd, *failedSysCall;
 344
 345     child_pid = fork();
 346     if (child_pid) {
 347         return child_pid;
 348     }
 349
 350     /* We're the child.  We're gonna exec() so pools don't matter. */
 351
 352     dnEnd = strrchr(fs->fs_path, '/');
 353     if (dnEnd == NULL) {
 354         dirName = "./";
 355     } else {
 356         dirName = ap_pcalloc(fcgi_config_pool, dnEnd - fs->fs_path + 1);
 357         dirName = memcpy(dirName, fs->fs_path, dnEnd - fs->fs_path);
 358     }
 359     if (chdir(dirName) < 0) {
 360         failedSysCall = "chdir()";
 361         goto FailedSystemCallExit;
 362     }
 363
 364 #ifndef __EMX__
 365      /* OS/2 dosen't support nice() */
 366     if (fs->processPriority != 0) {
 367         if (nice(fs->processPriority) == -1) {
 368             failedSysCall = "nice()";
 369             goto FailedSystemCallExit;
 370         }
 371     }
 372 #endif
 373
 374     /* Open the listenFd on spec'd fd */
 375     if (fs->listenFd != FCGI_LISTENSOCK_FILENO)
 376         dup2(fs->listenFd, FCGI_LISTENSOCK_FILENO);
 377
 378     /* Close all other open fds, except stdout/stderr.  Leave these two open so
 379      * FastCGI applications don't have to find and fix ALL 3rd party libs that
 380      * write to stdout/stderr inadvertantly.  For now, just leave 'em open to the
 381      * main server error_log - @@@ provide a directive control where this goes.
 382      */
 383     ap_error_log2stderr(fcgi_apache_main_server);
 384     dup2(2, 1);
 385     for (i = 0; i < FCGI_MAX_FD; i++) {
 386         if (i != FCGI_LISTENSOCK_FILENO && i != 2 && i != 1) {
 387             close(i);
 388         }
 389     }
 390
 391     /* Ignore SIGPIPE by default rather than terminate.  The fs SHOULD
 392      * install its own handler. */
 393     signal(SIGPIPE, SIG_IGN);
 394
 395     if (fcgi_wrapper && (fcgi_user_id != fs->uid || fcgi_group_id != fs->gid)) {
 396         char *shortName = strrchr(fs->fs_path, '/') + 1;
 397
 398 #ifndef APACHE2
 399         /* Relinquish our root real uid powers */
 400         seteuid_root();
 401         setuid(ap_user_id);
 402 #endif
 403
 404         do {
 405             execle(fcgi_wrapper, fcgi_wrapper, fs->username, fs->group, shortName, NULL, fs->envp);
 406         } while (errno == EINTR);
 407     }
 408     else {
 409         do {
 410             execle(fs->fs_path, fs->fs_path, NULL, fs->envp);
 411         } while (errno == EINTR);
 412     }
 413
 414     failedSysCall = "execle()";
 415
 416 FailedSystemCallExit:
 417     fprintf(stderr, "FastCGI: can't start server \"%s\" (pid %ld), %s failed: %s\n",
 418         fs->fs_path, (long) getpid(), failedSysCall, strerror(errno));
 419     exit(-1);
 420
 421     /* avoid an irrelevant compiler warning */
 422     return(0);
 423
 424 #else /* WIN32 */
 425
 426 #ifdef APACHE2
 427
 428     /* based on mod_cgi.c:run_cgi_child() */
 429
 430     apr_pool_t * tp;
 431     char * termination_env_string;
 432     HANDLE listen_handle = INVALID_HANDLE_VALUE;
 433     apr_procattr_t * procattr;
 434     apr_proc_t proc = { 0 };
 435     apr_file_t * file;
 436     int i = 0;
 437
 438     if (apr_pool_create(&tp, fcgi_config_pool))
 439         return 0;
 440
 441     process->terminationEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 442     if (process->terminationEvent == NULL)
 443         goto CLEANUP;
 444
 445     SetHandleInformation(process->terminationEvent, HANDLE_FLAG_INHERIT, TRUE);
 446
 447     termination_env_string = ap_psprintf(tp,
 448         "_FCGI_SHUTDOWN_EVENT_=%ld", process->terminationEvent);
 449
 450     while (fs->envp[i]) i++;
 451     fs->envp[i++] = termination_env_string;
 452     fs->envp[i] = (char *) fs->mutex_env_string;
 453
 454     ap_assert(fs->envp[i + 1] == NULL);
 455
 456     if (fs->socket_path)
 457     {
 458         SECURITY_ATTRIBUTES sa = { 0 };
 459
 460         sa.bInheritHandle = TRUE;
 461         sa.nLength = sizeof(sa);
 462
 463         listen_handle = CreateNamedPipe(fs->socket_path,
 464             PIPE_ACCESS_DUPLEX,
 465             PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
 466             PIPE_UNLIMITED_INSTANCES, 4096, 4096, 0, &sa);
 467
 468         if (listen_handle == INVALID_HANDLE_VALUE)
 469         {
 470             ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
 471                 "FastCGI: can't exec server \"%s\", CreateNamedPipe() failed",
 472                 fs->fs_path);
 473             goto CLEANUP;
 474         }
 475     }
 476     else
 477     {
 478         listen_handle = (HANDLE) fs->listenFd;
 479     }
 480
 481     if (apr_procattr_create(&procattr, tp))
 482         goto CLEANUP;
 483
 484     if (apr_procattr_dir_set(procattr, ap_make_dirstr_parent(tp, fs->fs_path)))
 485         goto CLEANUP;
 486
 487     if (apr_procattr_detach_set(procattr, 1))
 488         goto CLEANUP;
 489
 490     if (apr_os_file_put(&file, &listen_handle, 0, tp))
 491         goto CLEANUP;
 492
 493     /* procattr is opaque so we have to use this - unfortuantely it dups */
 494     if (apr_procattr_child_in_set(procattr, file, NULL))
 495         goto CLEANUP;
 496
 497     if (apr_proc_create(&proc, fs->fs_path, NULL, fs->envp, procattr, tp))
 498         goto CLEANUP;
 499
 500     process->handle = proc.hproc;
 501
 502
 503 CLEANUP:
 504
 505     if (i)
 506     {
 507         fs->envp[i - 1] = NULL;
 508     }
 509
 510     ap_destroy_pool(tp);
 511
 512     return proc.pid;
 513
 514 #else /* WIN32 && !APACHE2 */
 515
 516     /* Adapted from Apache's util_script.c ap_call_exec() */
 517     char *interpreter = NULL;
 518     char *quoted_filename;
 519     char *pCommand;
 520     char *pEnvBlock, *pNext;
 521
 522     int i = 0;
 523     int iEnvBlockLen = 1;
 524
 525     file_type_e fileType;
 526
 527     STARTUPINFO si;
 528     PROCESS_INFORMATION pi;
 529
 530     request_rec r;
 531     pid_t pid = -1;
 532
 533     pool * tp = ap_make_sub_pool(fcgi_config_pool);
 534
 535     HANDLE listen_handle;
 536     char * termination_env_string = NULL;
 537
 538     process->terminationEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 539     if (process->terminationEvent == NULL)
 540     {
 541         ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
 542             "FastCGI: can't create termination event for server \"%s\", "
 543             "CreateEvent() failed", fs->fs_path);
 544         goto CLEANUP;
 545     }
 546     SetHandleInformation(process->terminationEvent, HANDLE_FLAG_INHERIT, TRUE);
 547
 548     termination_env_string = ap_psprintf(tp,
 549         "_FCGI_SHUTDOWN_EVENT_=%ld", process->terminationEvent);
 550
 551     if (fs->socket_path)
 552     {
 553         SECURITY_ATTRIBUTES sa;
 554
 555         sa.lpSecurityDescriptor = NULL;
 556         sa.bInheritHandle = TRUE;
 557         sa.nLength = sizeof(sa);
 558
 559         listen_handle = CreateNamedPipe(fs->socket_path,
 560             PIPE_ACCESS_DUPLEX,
 561             PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
 562             PIPE_UNLIMITED_INSTANCES, 4096, 4096, 0, &sa);
 563
 564         if (listen_handle == INVALID_HANDLE_VALUE)
 565         {
 566             ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
 567                 "FastCGI: can't exec server \"%s\", CreateNamedPipe() failed", fs->fs_path);
 568             goto CLEANUP;
 569         }
 570     }
 571     else
 572     {
 573         listen_handle = (HANDLE) fs->listenFd;
 574     }
 575
 576     memset(&si, 0, sizeof(si));
 577     memset(&pi, 0, sizeof(pi));
 578     memset(&r,  0, sizeof(r));
 579
 580     // Can up a fake request to pass to ap_get_win32_interpreter()
 581     r.per_dir_config = fcgi_apache_main_server->lookup_defaults;
 582     r.server = fcgi_apache_main_server;
 583     r.filename = (char *) fs->fs_path;
 584     r.pool = tp;
 585
 586     fileType = ap_get_win32_interpreter(&r, &interpreter);
 587
 588     if (fileType == eFileTypeUNKNOWN) {
 589         ap_log_error(FCGI_LOG_ERR_NOERRNO, fcgi_apache_main_server,
 590             "FastCGI: %s is not executable; ensure interpreted scripts have "
 591             "\"#!\" as their first line",
 592             fs->fs_path);
 593         ap_destroy_pool(tp);
 594         goto CLEANUP;
 595     }
 596
 597     /*
 598      * We have the interpreter (if there is one) and we have
 599      * the arguments (if there are any).
 600      * Build the command string to pass to CreateProcess.
 601      */
 602     quoted_filename = ap_pstrcat(tp, "\"", fs->fs_path, "\"", NULL);
 603     if (interpreter && *interpreter) {
 604         pCommand = ap_pstrcat(tp, interpreter, " ", quoted_filename, NULL);
 605     }
 606     else {
 607         pCommand = quoted_filename;
 608     }
 609
 610     /*
 611      * Make child process use hPipeOutputWrite as standard out,
 612      * and make sure it does not show on screen.
 613      */
 614     si.cb = sizeof(si);
 615     si.dwFlags     = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
 616     si.wShowWindow = SW_HIDE;
 617     si.hStdInput   = listen_handle;
 618
 619     // XXX These should be open to the error_log
 620     si.hStdOutput  = INVALID_HANDLE_VALUE;
 621     si.hStdError   = INVALID_HANDLE_VALUE;
 622
 623     /*
 624      * Win32's CreateProcess call requires that the environment
 625      * be passed in an environment block, a null terminated block of
 626      * null terminated strings.
 627      * @todo we should store the env in this format for win32.
 628      */
 629     while (fs->envp[i])
 630     {
 631         iEnvBlockLen += strlen(fs->envp[i]) + 1;
 632         i++;
 633     }
 634
 635     iEnvBlockLen += strlen(termination_env_string) + 1;
 636     iEnvBlockLen += strlen(fs->mutex_env_string) + 1;
 637
 638     pEnvBlock = (char *) ap_pcalloc(tp, iEnvBlockLen);
 639
 640     i = 0;
 641     pNext = pEnvBlock;
 642     while (fs->envp[i])
 643     {
 644         strcpy(pNext, fs->envp[i]);
 645         pNext += strlen(pNext) + 1;
 646         i++;
 647     }
 648
 649     strcpy(pNext, termination_env_string);
 650     pNext += strlen(pNext) + 1;
 651     strcpy(pNext, fs->mutex_env_string);
 652
 653     if (CreateProcess(NULL, pCommand, NULL, NULL, TRUE,
 654                       0,
 655                       pEnvBlock,
 656                       ap_make_dirstr_parent(tp, fs->fs_path),
 657                       &si, &pi))
 658     {
 659         /* Hack to get 16-bit CGI's working. It works for all the
 660          * standard modules shipped with Apache. pi.dwProcessId is 0
 661          * for 16-bit CGIs and all the Unix specific code that calls
 662          * ap_call_exec interprets this as a failure case. And we can't
 663          * use -1 either because it is mapped to 0 by the caller.
 664          */
 665         pid = (fileType == eFileTypeEXE16) ? -2 : pi.dwProcessId;
 666
 667         process->handle = pi.hProcess;
 668         CloseHandle(pi.hThread);
 669     }
 670
 671     if (fs->socket_path)
 672     {
 673         CloseHandle(listen_handle);
 674     }
 675
 676 CLEANUP:
 677
 678     ap_destroy_pool(tp);
 679
 680     return pid;
 681
 682 #endif /* !APACHE2 */
 683 #endif /* WIN32 */
 684 }
 685
 686 #if !defined(WIN32) && !defined(APACHE2)
 687 static void reduce_privileges(void)
 688 {
 689     char *name;
 690
 691     if (geteuid() != 0)
 692         return;
 693
 694 #ifndef __EMX__
 695     /* Get username if passed as a uid */
 696     if (ap_user_name[0] == '#') {
 697         uid_t uid = atoi(&ap_user_name[1]);
 698         struct passwd *ent = getpwuid(uid);
 699
 700         if (ent == NULL) {
 701             ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 702                 "FastCGI: process manager exiting, getpwuid(%u) couldn't determine user name, "
 703                 "you probably need to modify the User directive", (unsigned)uid);
 704             exit(1);
 705         }
 706         name = ent->pw_name;
 707     }
 708     else
 709         name = ap_user_name;
 710
 711     /* Change Group */
 712     if (setgid(ap_group_id) == -1) {
 713         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 714             "FastCGI: process manager exiting, setgid(%u) failed", (unsigned)ap_group_id);
 715         exit(1);
 716     }
 717
 718     /* See Apache PR2580. Until its resolved, do it the same way CGI is done.. */
 719
 720     /* Initialize supplementary groups */
 721     if (initgroups(name, ap_group_id) == -1) {
 722         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 723             "FastCGI: process manager exiting, initgroups(%s,%u) failed",
 724             name, (unsigned)ap_group_id);
 725         exit(1);
 726     }
 727 #endif /* __EMX__ */
 728
 729     /* Change User */
 730     if (fcgi_wrapper) {
 731         if (seteuid_user() == -1) {
 732             ap_log_error(FCGI_LOG_ALERT_NOERRNO, fcgi_apache_main_server,
 733                 "FastCGI: process manager exiting, failed to reduce privileges");
 734             exit(1);
 735         }
 736     }
 737     else {
 738         if (setuid(ap_user_id) == -1) {
 739             ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 740                 "FastCGI: process manager exiting, setuid(%u) failed", (unsigned)ap_user_id);
 741             exit(1);
 742         }
 743     }
 744 }
 745
 746 /*************
 747  * Change the name of this process - best we can easily.
 748  */
 749 static void change_process_name(const char * const name)
 750 {
 751     strncpy(ap_server_argv0, name, strlen(ap_server_argv0));
 752 }
 753 #endif
 754
 755 static void schedule_start(fcgi_server *s, int proc)
 756 {
 757     /* If we've started one recently, don't register another */
 758     time_t time_passed = now - s->restartTime;
 759
 760     if ((s->procs[proc].pid && (time_passed < (int) s->restartDelay))
 761         || ((s->procs[proc].pid == 0) && (time_passed < s->initStartDelay)))
 762     {
 763         FCGIDBG6("ignore_job: slot=%d, pid=%ld, time_passed=%ld, initStartDelay=%ld, restartDelay=%ld", proc, (long) s->procs[proc].pid, time_passed, s->initStartDelay, s->restartDelay);
 764         return;
 765     }
 766
 767     FCGIDBG3("scheduling_start: %s (%d)", s->fs_path, proc);
 768     s->procs[proc].state = FCGI_START_STATE;
 769     if (proc == dynamicMaxClassProcs - 1) {
 770         ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
 771             "FastCGI: scheduled the %sstart of the last (dynamic) server "
 772             "\"%s\" process: reached dynamicMaxClassProcs (%d)",
 773             s->procs[proc].pid ? "re" : "", s->fs_path, dynamicMaxClassProcs);
 774     }
 775 }
 776
 777 /*
 778  *----------------------------------------------------------------------
 779  *
 780  * dynamic_read_msgs
 781  *
 782  *      Removes the records written by request handlers and decodes them.
 783  *      We also update the data structures to reflect the changes.
 784  *
 785  *----------------------------------------------------------------------
 786  */
 787
 788 static void dynamic_read_msgs(int read_ready)
 789 {
 790     fcgi_server *s;
 791     int rc;
 792
 793 #ifndef WIN32
 794     static int buflen = 0;
 795     static char buf[FCGI_MSGS_BUFSIZE + 1];
 796     char *ptr1, *ptr2, opcode;
 797     char execName[FCGI_MAXPATH + 1];
 798     char user[MAX_USER_NAME_LEN + 2];
 799     char group[MAX_GID_CHAR_LEN + 1];
 800     unsigned long q_usec = 0UL, req_usec = 0UL;
 801 #else
 802     fcgi_pm_job *joblist = NULL;
 803     fcgi_pm_job *cjob = NULL;
 804 #endif
 805
 806     pool *sp = NULL, *tp;
 807
 808 #ifndef WIN32
 809     user[MAX_USER_NAME_LEN + 1] = group[MAX_GID_CHAR_LEN] = '\0';
 810 #endif
 811
 812     /*
 813      * To prevent the idle application from running indefinitely, we
 814      * check the timer and if it is expired, we recompute the values
 815      * for each running application class.  Then, when FCGI_REQUEST_COMPLETE_JOB
 816      * message is received, only updates are made to the data structures.
 817      */
 818     if (fcgi_dynamic_last_analyzed == 0) {
 819         fcgi_dynamic_last_analyzed = now;
 820     }
 821     if ((now - fcgi_dynamic_last_analyzed) >= (int)dynamicUpdateInterval) {
 822         for (s = fcgi_servers; s != NULL; s = s->next) {
 823             if (s->directive != APP_CLASS_DYNAMIC)
 824                 break;
 825
 826             /* Advance the last analyzed timestamp by the elapsed time since
 827              * it was last set. Round the increase down to the nearest
 828              * multiple of dynamicUpdateInterval */
 829
 830             fcgi_dynamic_last_analyzed += (((long)(now-fcgi_dynamic_last_analyzed)/dynamicUpdateInterval)*dynamicUpdateInterval);
 831             s->smoothConnTime = (unsigned long) ((1.0-dynamicGain)*s->smoothConnTime + dynamicGain*s->totalConnTime);
 832             s->totalConnTime = 0UL;
 833             s->totalQueueTime = 0UL;
 834         }
 835     }
 836
 837     if (read_ready <= 0) {
 838         return;
 839     }
 840
 841 #ifndef WIN32
 842     rc = read(fcgi_pm_pipe[0], (void *)(buf + buflen), FCGI_MSGS_BUFSIZE - buflen);
 843     if (rc <= 0) {
 844         if (!caughtSigTerm) {
 845             ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 846                 "FastCGI: read() from pipe failed (%d)", rc);
 847             if (rc == 0) {
 848                 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 849                     "FastCGI: the PM is shutting down, Apache seems to have disappeared - bye");
 850                 caughtSigTerm = TRUE;
 851             }
 852         }
 853         return;
 854     }
 855     buflen += rc;
 856     buf[buflen] = '\0';
 857
 858 #else
 859
 860     /* dynamic_read_msgs() is called when a MBOX_EVENT is received (a
 861      * request to do something) and/or when a timeout expires.
 862      * There really should be no reason why this wait would get stuck
 863      * but there's no point in waiting forever. */
 864
 865     rc = WaitForSingleObject(fcgi_dynamic_mbox_mutex, FCGI_MBOX_MUTEX_TIMEOUT);
 866
 867     if (rc != WAIT_OBJECT_0 && rc != WAIT_ABANDONED)
 868     {
 869         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 870             "FastCGI: failed to aquire the dynamic mbox mutex - something is broke?!");
 871         return;
 872     }
 873
 874     joblist = fcgi_dynamic_mbox;
 875     fcgi_dynamic_mbox = NULL;
 876
 877     if (! ReleaseMutex(fcgi_dynamic_mbox_mutex))
 878     {
 879         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 880             "FastCGI: failed to release the dynamic mbox mutex - something is broke?!");
 881     }
 882
 883     cjob = joblist;
 884 #endif
 885
 886 #ifdef APACHE2
 887     apr_pool_create(&tp, fcgi_config_pool);
 888 #else
 889     tp = ap_make_sub_pool(fcgi_config_pool);
 890 #endif
 891
 892 #ifndef WIN32
 893     for (ptr1 = buf; ptr1; ptr1 = ptr2) {
 894         int scan_failed = 0;
 895
 896         ptr2 = strchr(ptr1, '*');
 897         if (ptr2) {
 898             *ptr2++ = '\0';
 899         }
 900         else {
 901             break;
 902         }
 903
 904         opcode = *ptr1;
 905
 906         switch (opcode)
 907         {
 908         case FCGI_SERVER_START_JOB:
 909         case FCGI_SERVER_RESTART_JOB:
 910
 911             if (sscanf(ptr1, "%c %s %16s %15s",
 912                 &opcode, execName, user, group) != 4)
 913             {
 914                 scan_failed = 1;
 915             }
 916             break;
 917
 918         case FCGI_REQUEST_TIMEOUT_JOB:
 919
 920             if (sscanf(ptr1, "%c %s %16s %15s",
 921                 &opcode, execName, user, group) != 4)
 922             {
 923                 scan_failed = 1;
 924             }
 925             break;
 926
 927         case FCGI_REQUEST_COMPLETE_JOB:
 928
 929             if (sscanf(ptr1, "%c %s %16s %15s %lu %lu",
 930                 &opcode, execName, user, group, &q_usec, &req_usec) != 6)
 931             {
 932                 scan_failed = 1;
 933             }
 934             break;
 935
 936         default:
 937
 938             scan_failed = 1;
 939             break;
 940         }
 941
 942         FCGIDBG7("read_job: %c %s %s %s %lu %lu", opcode, execName, user, group, q_usec, req_usec);
 943
 944         if (scan_failed) {
 945             ap_log_error(FCGI_LOG_ERR_NOERRNO, fcgi_apache_main_server,
 946                 "FastCGI: bogus message, sscanf() failed: \"%s\"", ptr1);
 947             goto NextJob;
 948         }
 949 #else
 950     /* Update data structures for processing */
 951     while (cjob != NULL) {
 952         joblist = cjob->next;
 953         FCGIDBG7("read_job: %c %s %s %s %lu %lu", cjob->id, cjob->fs_path, cjob->user, cjob->group, cjob->qsec, cjob->start_time);
 954 #endif
 955
 956 #ifndef WIN32
 957         s = fcgi_util_fs_get(execName, user, group);
 958 #else
 959         s = fcgi_util_fs_get(cjob->fs_path, cjob->user, cjob->group);
 960 #endif
 961
 962 #ifndef WIN32
 963         if (s==NULL && opcode != FCGI_REQUEST_COMPLETE_JOB)
 964 #else
 965         if (s==NULL && cjob->id != FCGI_REQUEST_COMPLETE_JOB)
 966 #endif
 967         {
 968 #ifdef WIN32
 969
 970             HANDLE mutex = CreateMutex(NULL, FALSE, cjob->fs_path);
 971
 972             if (mutex == NULL)
 973             {
 974                 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 975                     "FastCGI: can't create accept mutex "
 976                     "for (dynamic) server \"%s\"", cjob->fs_path);
 977                 goto BagNewServer;
 978             }
 979
 980             SetHandleInformation(mutex, HANDLE_FLAG_INHERIT, TRUE);
 981 #else
 982             const char *err;
 983 #endif
 984
 985             /* Create a perm subpool to hold the new server data,
 986              * we can destroy it if something doesn't pan out */
 987 #ifdef APACHE2
 988             apr_pool_create(&sp, fcgi_config_pool);
 989 #else
 990             sp = ap_make_sub_pool(fcgi_config_pool);
 991 #endif
 992
 993             /* Create a new "dynamic" server */
 994             s = fcgi_util_fs_new(sp);
 995
 996             s->directive = APP_CLASS_DYNAMIC;
 997             s->restartDelay = dynamicRestartDelay;
 998             s->listenQueueDepth = dynamicListenQueueDepth;
 999             s->initStartDelay = dynamicInitStartDelay;
1000             s->envp = dynamicEnvp;
1001             s->flush = dynamicFlush;
1002
1003 #ifdef WIN32
1004             s->mutex_env_string = ap_psprintf(sp, "_FCGI_MUTEX_=%ld", mutex);
1005             s->fs_path = ap_pstrdup(sp, cjob->fs_path);
1006 #else
1007             s->fs_path = ap_pstrdup(sp, execName);
1008 #endif
1009             ap_getparents(s->fs_path);
1010             ap_no2slash(s->fs_path);
1011             s->procs = fcgi_util_fs_create_procs(sp, dynamicMaxClassProcs);
1012
1013             /* XXX the socket_path (both Unix and Win) *is* deducible and
1014              * thus can and will be used by other apache instances without
1015              * the use of shared data regarding the processes serving the
1016              * requests.  This can result in slightly unintuitive process
1017              * counts and security implications.  This is prevented
1018              * if suexec (Unix) is in use.  This is both a feature and a flaw.
1019              * Changing it now would break existing installations. */
1020
1021 #ifndef WIN32
1022             /* Create socket file's path */
1023             s->socket_path = fcgi_util_socket_hash_filename(tp, execName, user, group);
1024             s->socket_path = fcgi_util_socket_make_path_absolute(sp, s->socket_path, 1);
1025
1026             /* Create sockaddr, prealloc it so it won't get created in tp */
1027             s->socket_addr = ap_pcalloc(sp, sizeof(struct sockaddr_un));
1028             err = fcgi_util_socket_make_domain_addr(tp, (struct sockaddr_un **)&s->socket_addr,
1029                                           &s->socket_addr_len, s->socket_path);
1030             if (err) {
1031                 ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
1032                     "FastCGI: can't create (dynamic) server \"%s\": %s", execName, err);
1033                 goto BagNewServer;
1034             }
1035
1036             if (init_listen_sock(s)) {
1037                 goto BagNewServer;
1038             }
1039
1040             /* If a wrapper is being used, config user/group info */
1041             if (fcgi_wrapper) {
1042                 if (user[0] == '~') {
1043                     /* its a user dir uri, the rest is a username, not a uid */
1044                     struct passwd *pw = getpwnam(&user[1]);
1045
1046                     if (!pw) {
1047                         ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
1048                             "FastCGI: can't create (dynamic) server \"%s\": can't get uid/gid for wrapper: getpwnam(%s) failed",
1049                             execName, &user[1]);
1050                         goto BagNewServer;
1051                     }
1052                     s->uid = pw->pw_uid;
1053                     s->user = ap_pstrdup(sp, user);
1054                     s->username = s->user;
1055
1056                     s->gid = pw->pw_gid;
1057                     s->group = ap_psprintf(sp, "%ld", (long)s->gid);
1058                 }
1059                 else {
1060                     struct passwd *pw;
1061
1062                     s->uid = (uid_t)atol(user);
1063                     pw = getpwuid(s->uid);
1064                     if (!pw) {
1065                         ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
1066                             "FastCGI: can't create (dynamic) server \"%s\": can't get uid/gid for wrapper: getwpuid(%ld) failed",
1067                             execName, (long)s->uid);
1068                         goto BagNewServer;
1069                     }
1070                     s->user = ap_pstrdup(sp, user);
1071                     s->username = ap_pstrdup(sp, pw->pw_name);
1072
1073                     s->gid = (gid_t)atol(group);
1074                     s->group = ap_pstrdup(sp, group);
1075                 }
1076             }
1077 #else
1078             /* Create socket file's path */
1079             s->socket_path = fcgi_util_socket_hash_filename(tp, cjob->fs_path, cjob->user, cjob->group);
1080             s->socket_path = fcgi_util_socket_make_path_absolute(sp, s->socket_path, 1);
1081             s->listenFd = 0;
1082 #endif
1083
1084             fcgi_util_fs_add(s);
1085         }
1086         else {
1087 #ifndef WIN32
1088             if (opcode == FCGI_SERVER_RESTART_JOB) {
1089 #else
1090             if (cjob->id==FCGI_SERVER_RESTART_JOB) {
1091 #endif
1092                 /* Check to see if the binary has changed.  If so,
1093                 * kill the FCGI application processes, and
1094                 * restart them.
1095                 */
1096                 struct stat stbuf;
1097                 int i;
1098 #ifdef WIN32
1099                 char * app_path = cjob->fs_path;
1100 #else
1101                 char * app_path = execName;
1102 #endif
1103
1104                 if (stat(app_path, &stbuf) == 0 && stbuf.st_mtime > s->startTime)
1105                 {
1106                     int do_restart = 0;
1107
1108                     /* prevent addition restart requests */
1109                     s->startTime = now;
1110 #ifndef WIN32
1111                     utime(s->socket_path, NULL);
1112 #endif
1113
1114                     /* kill old server(s) */
1115                     for (i = 0; i < dynamicMaxClassProcs; i++)
1116                     {
1117                         if (s->procs[i].pid > 0
1118                             && stbuf.st_mtime > s->procs[i].start_time)
1119                         {
1120                             fcgi_kill(&s->procs[i], SIGTERM);
1121                             do_restart++;
1122                         }
1123                     }
1124
1125                     if (do_restart)
1126                     {
1127                         ap_log_error(FCGI_LOG_WARN_NOERRNO,
1128                             fcgi_apache_main_server, "FastCGI: restarting "
1129                             "old server \"%s\" processes, newer version "
1130                             "found", app_path);
1131                     }
1132                 }
1133
1134                 /* If dynamicAutoRestart, don't mark any new processes
1135                  * for  starting because we probably got the
1136                  * FCGI_SERVER_START_JOB due to dynamicAutoUpdate and the ProcMgr
1137                  * will be restarting all of those we just killed.
1138                  */
1139                 if (dynamicAutoRestart)
1140                     goto NextJob;
1141             }
1142 #ifndef WIN32
1143             else if (opcode == FCGI_SERVER_START_JOB) {
1144 #else
1145             else if (cjob->id==FCGI_SERVER_START_JOB) {
1146 #endif
1147                 /* we've been asked to start a process--only start
1148                 * it if we're not already running at least one
1149                 * instance.
1150                 */
1151                 int i;
1152
1153                 for (i = 0; i < dynamicMaxClassProcs; i++) {
1154                    if (s->procs[i].state == FCGI_RUNNING_STATE)
1155                       break;
1156                 }
1157                 /* if already running, don't start another one */
1158                 if (i < dynamicMaxClassProcs) {
1159                     goto NextJob;
1160                 }
1161             }
1162         }
1163
1164 #ifndef WIN32
1165         switch (opcode)
1166 #else
1167         switch (cjob->id)
1168 #endif
1169         {
1170             int i, start;
1171
1172             case FCGI_SERVER_RESTART_JOB:
1173
1174                 start = FALSE;
1175
1176                 /* We just waxed 'em all.  Try to find an idle slot. */
1177
1178                 for (i = 0; i < dynamicMaxClassProcs; ++i)
1179                 {
1180                     if (s->procs[i].state == FCGI_START_STATE
1181                         || s->procs[i].state == FCGI_RUNNING_STATE)
1182                     {
1183                         break;
1184                     }
1185                     else if (s->procs[i].state == FCGI_KILLED_STATE
1186                         || s->procs[i].state == FCGI_READY_STATE)
1187                     {
1188                         start = TRUE;
1189                         break;
1190                     }
1191                 }
1192
1193                 /* Nope, just use the first slot */
1194                 if (i == dynamicMaxClassProcs)
1195                 {
1196                     start = TRUE;
1197                     i = 0;
1198                 }
1199
1200                 if (start)
1201                 {
1202                     schedule_start(s, i);
1203                 }
1204
1205                 break;
1206
1207             case FCGI_SERVER_START_JOB:
1208             case FCGI_REQUEST_TIMEOUT_JOB:
1209
1210                 if ((fcgi_dynamic_total_proc_count + 1) > (int) dynamicMaxProcs) {
1211                     /*
1212                      * Extra instances should have been
1213                      * terminated beforehand, probably need
1214                      * to increase ProcessSlack parameter
1215                      */
1216                     ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1217                         "FastCGI: can't schedule the start of another (dynamic) server \"%s\" process: "
1218                         "exceeded dynamicMaxProcs (%d)", s->fs_path, dynamicMaxProcs);
1219                     goto NextJob;
1220                 }
1221
1222                 /* find next free slot */
1223                 for (i = 0; i < dynamicMaxClassProcs; i++)
1224                 {
1225                     if (s->procs[i].state == FCGI_START_STATE)
1226                     {
1227                         FCGIDBG2("ignore_job: slot (%d) is already scheduled for starting", i);
1228                         break;
1229                     }
1230                     else if (s->procs[i].state == FCGI_RUNNING_STATE)
1231                     {
1232                         continue;
1233                     }
1234
1235                     schedule_start(s, i);
1236                     break;
1237                 }
1238
1239 #ifdef FCGI_DEBUG
1240                 if (i >= dynamicMaxClassProcs) {
1241                     FCGIDBG1("ignore_job: slots are max'd");
1242                 }
1243 #endif
1244                 break;
1245             case FCGI_REQUEST_COMPLETE_JOB:
1246                 /* only record stats if we have a structure */
1247                 if (s) {
1248 #ifndef WIN32
1249                     s->totalConnTime += req_usec;
1250                     s->totalQueueTime += q_usec;
1251 #else
1252                     s->totalConnTime += cjob->start_time;
1253                     s->totalQueueTime += cjob->qsec;
1254 #endif
1255                 }
1256                 break;
1257         }
1258
1259 NextJob:
1260
1261 #ifdef WIN32
1262         /* Cleanup job data */
1263         free(cjob->fs_path);
1264         free(cjob->user);
1265         free(cjob->group);
1266         free(cjob);
1267         cjob = joblist;
1268 #endif
1269
1270         continue;
1271
1272 BagNewServer:
1273         if (sp) ap_destroy_pool(sp);
1274
1275 #ifdef WIN32
1276     free(cjob->fs_path);
1277     free(cjob);
1278     cjob = joblist;
1279 #endif
1280     }
1281
1282 #ifndef WIN32
1283     if (ptr1 == buf) {
1284         ap_log_error(FCGI_LOG_ERR_NOERRNO, fcgi_apache_main_server,
1285             "FastCGI: really bogus message: \"%s\"", ptr1);
1286         ptr1 += strlen(buf);
1287     }
1288
1289     buflen -= ptr1 - buf;
1290     if (buflen) {
1291         memmove(buf, ptr1, buflen);
1292     }
1293 #endif
1294
1295     ap_destroy_pool(tp);
1296 }
1297
1298 /*
1299  *----------------------------------------------------------------------
1300  *
1301  * dynamic_kill_idle_fs_procs
1302  *
1303  *      Implement a kill policy for the dynamic FastCGI applications.
1304  *      We also update the data structures to reflect the changes.
1305  *
1306  * Side effects:
1307  *      Processes are marked for deletion possibly killed.
1308  *
1309  *----------------------------------------------------------------------
1310  */
1311 static void dynamic_kill_idle_fs_procs(void)
1312 {
1313     fcgi_server *s;
1314     int victims = 0;
1315
1316     for (s = fcgi_servers;  s != NULL; s = s->next)
1317     {
1318         /*
1319          * server's smoothed running time, or if that's 0, the current total
1320          */
1321         unsigned long connTime;
1322
1323         /*
1324          * maximum number of microseconds that all of a server's running
1325          * processes together could have spent running since the last check
1326          */
1327         unsigned long totalTime;
1328
1329         /*
1330          * percentage, 0-100, of totalTime that the processes actually used
1331          */
1332         int loadFactor;
1333
1334         int i;
1335         int really_running = 0;
1336
1337         if (s->directive != APP_CLASS_DYNAMIC || s->numProcesses == 0)
1338         {
1339             continue;
1340         }
1341
1342         /* s->numProcesses includes pending kills so get the "active" count */
1343         for (i = 0; i < dynamicMaxClassProcs; ++i)
1344         {
1345             if (s->procs[i].state == FCGI_RUNNING_STATE) ++really_running;
1346         }
1347
1348         connTime = s->smoothConnTime ? s->smoothConnTime : s->totalConnTime;
1349         totalTime = really_running * (now - fcgi_dynamic_epoch) * 1000000 + 1;
1350
1351         loadFactor = 100 * connTime / totalTime;
1352
1353         if (really_running == 1)
1354         {
1355             if (loadFactor >= dynamicThreshold1)
1356             {
1357                 continue;
1358             }
1359         }
1360         else
1361         {
1362             int load = really_running / ( really_running - 1) * loadFactor;
1363
1364             if (load >= dynamicThresholdN)
1365             {
1366                 continue;
1367             }
1368         }
1369
1370         /*
1371          * Run through the procs to see if we can get away w/o waxing one.
1372          */
1373         for (i = 0; i < dynamicMaxClassProcs; ++i)
1374         {
1375             if (s->procs[i].state == FCGI_START_STATE)
1376             {
1377                 s->procs[i].state = FCGI_READY_STATE;
1378                 break;
1379             }
1380             else if (s->procs[i].state == FCGI_VICTIM_STATE)
1381             {
1382                 break;
1383             }
1384         }
1385
1386         if (i >= dynamicMaxClassProcs)
1387         {
1388             ServerProcess * procs = s->procs;
1389             int youngest = -1;
1390
1391             for (i = 0; i < dynamicMaxClassProcs; ++i)
1392             {
1393                 if (procs[i].state == FCGI_RUNNING_STATE)
1394                 {
1395                     if (youngest == -1 || procs[i].start_time >= procs[youngest].start_time)
1396                     {
1397                         youngest = i;
1398                     }
1399                 }
1400             }
1401
1402             if (youngest != -1)
1403             {
1404                 ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1405                     "FastCGI: (dynamic) server \"%s\" (pid %ld) termination signaled",
1406                     s->fs_path, (long) s->procs[youngest].pid);
1407
1408                 fcgi_kill(&s->procs[youngest], SIGTERM);
1409
1410                 victims++;
1411             }
1412
1413             /*
1414              * If the number of non-victims is less than or equal to
1415              * the minimum that may be running without being killed off,
1416              * don't select any more victims.
1417              */
1418             if (fcgi_dynamic_total_proc_count - victims <= dynamicMinProcs)
1419             {
1420                 break;
1421             }
1422         }
1423     }
1424 }
1425
1426 #ifdef WIN32
1427
1428 // This is a little bogus, there's gotta be a better way to do this
1429 // Can we use WaitForMultipleObjects()
1430 #define FCGI_PROC_WAIT_TIME 100
1431
1432 void child_wait_thread_main(void *dummy) {
1433     fcgi_server *s;
1434     DWORD dwRet = WAIT_TIMEOUT;
1435     int numChildren;
1436     int i;
1437     int waited;
1438
1439     while (!bTimeToDie) {
1440         waited = 0;
1441
1442         for (s = fcgi_servers; s != NULL; s = s->next) {
1443             if (s->directive == APP_CLASS_EXTERNAL || s->listenFd < 0) {
1444                 continue;
1445             }
1446             if (s->directive == APP_CLASS_DYNAMIC) {
1447                 numChildren = dynamicMaxClassProcs;
1448             }
1449             else {
1450                 numChildren = s->numProcesses;
1451             }
1452
1453             for (i=0; i < numChildren; i++) {
1454                 if (s->procs[i].handle != INVALID_HANDLE_VALUE)
1455                 {
1456                     DWORD exitStatus = 0;
1457
1458                     /* timeout is currently set for 100 miliecond */
1459                     /* it may need to be longer or user customizable */
1460                     dwRet = WaitForSingleObject(s->procs[i].handle, FCGI_PROC_WAIT_TIME);
1461
1462                     waited = 1;
1463
1464                     if (dwRet != WAIT_TIMEOUT && dwRet != WAIT_FAILED) {
1465                         /* a child fs has died */
1466                         /* mark the child as dead */
1467
1468                         if (s->directive == APP_CLASS_STANDARD) {
1469                             /* restart static app */
1470                             s->procs[i].state = FCGI_START_STATE;
1471                             s->numFailures++;
1472                         }
1473                         else {
1474                             s->numProcesses--;
1475                             fcgi_dynamic_total_proc_count--;
1476                             FCGIDBG2("-- fcgi_dynamic_total_proc_count=%d", fcgi_dynamic_total_proc_count);
1477
1478                             if (s->procs[i].state == FCGI_VICTIM_STATE) {
1479                                 s->procs[i].state = FCGI_KILLED_STATE;
1480                             }
1481                             else {
1482                                 /* dynamic app shouldn't have died or dynamicAutoUpdate killed it*/
1483                                 s->numFailures++;
1484
1485                                 if (dynamicAutoRestart || (s->numProcesses <= 0 && dynamicThreshold1 == 0)) {
1486                                     s->procs[i].state = FCGI_START_STATE;
1487                                 }
1488                                 else {
1489                                     s->procs[i].state = FCGI_READY_STATE;
1490                                 }
1491                             }
1492                         }
1493
1494                         GetExitCodeProcess(s->procs[i].handle, &exitStatus);
1495
1496                         ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1497                             "FastCGI:%s server \"%s\" (pid %d) terminated with exit with status '%d'",
1498                             (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1499                             s->fs_path, (long) s->procs[i].pid, exitStatus);
1500
1501                         CloseHandle(s->procs[i].handle);
1502                         s->procs[i].handle = INVALID_HANDLE_VALUE;
1503                         s->procs[i].pid = -1;
1504
1505                         /* wake up the main thread */
1506                         SetEvent(fcgi_event_handles[WAKE_EVENT]);
1507                     }
1508                 }
1509             }
1510         }
1511         Sleep(waited ? 0 : FCGI_PROC_WAIT_TIME);
1512     }
1513 }
1514 #endif
1515
1516 #ifndef WIN32
1517 static void setup_signals(void)
1518 {
1519     struct sigaction sa;
1520
1521     /* Setup handlers */
1522
1523     sa.sa_handler = signal_handler;
1524     sigemptyset(&sa.sa_mask);
1525     sa.sa_flags = 0;
1526
1527     if (sigaction(SIGTERM, &sa, NULL) < 0) {
1528         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
1529         "sigaction(SIGTERM) failed");
1530     }
1531     /* httpd restart */
1532     if (sigaction(SIGHUP, &sa, NULL) < 0) {
1533         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
1534         "sigaction(SIGHUP) failed");
1535     }
1536     /* httpd graceful restart */
1537     if (sigaction(SIGUSR1, &sa, NULL) < 0) {
1538         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
1539         "sigaction(SIGUSR1) failed");
1540     }
1541     /* read messages from request handlers - kill interval expired */
1542     if (sigaction(SIGALRM, &sa, NULL) < 0) {
1543         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
1544         "sigaction(SIGALRM) failed");
1545     }
1546     if (sigaction(SIGCHLD, &sa, NULL) < 0) {
1547         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
1548         "sigaction(SIGCHLD) failed");
1549     }
1550 }
1551 #endif
1552
1553 #if !defined(WIN32) && !defined(APACHE2)
1554 int fcgi_pm_main(void *dummy, child_info *info)
1555 #else
1556 void fcgi_pm_main(void *dummy)
1557 #endif
1558 {
1559     fcgi_server *s;
1560     unsigned int i;
1561     int read_ready = 0;
1562     int alarmLeft = 0;
1563
1564 #ifdef WIN32
1565     DWORD dwRet;
1566     HANDLE child_wait_thread = INVALID_HANDLE_VALUE;
1567 #else
1568     int callWaitPid, callDynamicProcs;
1569 #endif
1570
1571 #ifdef WIN32
1572     // Add SystemRoot to the dynamic environment
1573     char ** envp = dynamicEnvp;
1574     for (i = 0; *envp; ++i) {
1575         ++envp;
1576     }
1577     fcgi_config_set_env_var(fcgi_config_pool, dynamicEnvp, &i, "SystemRoot");
1578
1579 #else
1580
1581 #ifndef APACHE2
1582     reduce_privileges();
1583     change_process_name("fcgi-pm");
1584 #endif
1585
1586     close(fcgi_pm_pipe[1]);
1587     setup_signals();
1588
1589     if (fcgi_wrapper) {
1590         ap_log_error(FCGI_LOG_NOTICE_NOERRNO, fcgi_apache_main_server,
1591             "FastCGI: wrapper mechanism enabled (wrapper: %s)", fcgi_wrapper);
1592     }
1593 #endif
1594
1595     /* Initialize AppClass */
1596     for (s = fcgi_servers; s != NULL; s = s->next)
1597     {
1598         if (s->directive != APP_CLASS_STANDARD)
1599             continue;
1600
1601 #ifdef WIN32
1602         if (s->socket_path)
1603             s->listenFd = 0;
1604 #endif
1605
1606         for (i = 0; i < s->numProcesses; ++i)
1607             s->procs[i].state = FCGI_START_STATE;
1608     }
1609
1610 #ifdef WIN32
1611     child_wait_thread = (HANDLE) _beginthread(child_wait_thread_main, 0, NULL);
1612
1613     if (child_wait_thread == (HANDLE) -1)
1614     {
1615         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
1616             "FastCGI: failed to create process manager's wait thread!");
1617     }
1618
1619     ap_log_error(FCGI_LOG_NOTICE_NOERRNO, fcgi_apache_main_server,
1620         "FastCGI: process manager initialized");
1621 #else
1622     ap_log_error(FCGI_LOG_NOTICE_NOERRNO, fcgi_apache_main_server,
1623         "FastCGI: process manager initialized (pid %ld)", (long) getpid());
1624 #endif
1625
1626     now = time(NULL);
1627
1628     /*
1629      * Loop until SIGTERM
1630      */
1631     for (;;) {
1632         int sleepSeconds = min(dynamicKillInterval, dynamicUpdateInterval);
1633 #ifdef WIN32
1634         time_t expire;
1635 #else
1636         pid_t childPid;
1637         int waitStatus;
1638 #endif
1639         unsigned int numChildren;
1640
1641         /*
1642          * If we came out of sigsuspend() for any reason other than
1643          * SIGALRM, pick up where we left off.
1644          */
1645         if (alarmLeft)
1646             sleepSeconds = alarmLeft;
1647
1648         /*
1649          * Examine each configured AppClass for a process that needs
1650          * starting.  Compute the earliest time when the start should
1651          * be attempted, starting it now if the time has passed.  Also,
1652          * remember that we do NOT need to restart externally managed
1653          * FastCGI applications.
1654          */
1655         for (s = fcgi_servers; s != NULL; s = s->next)
1656         {
1657             if (s->directive == APP_CLASS_EXTERNAL)
1658                 continue;
1659
1660             numChildren = (s->directive == APP_CLASS_DYNAMIC)
1661                 ? dynamicMaxClassProcs
1662                 : s->numProcesses;
1663
1664             for (i = 0; i < numChildren; ++i)
1665             {
1666                 if (s->procs[i].pid <= 0 && s->procs[i].state == FCGI_START_STATE)
1667                 {
1668                     int restart = (s->procs[i].pid < 0);
1669                     time_t restartTime = s->restartTime;
1670
1671                     if (s->bad)
1672                     {
1673                         /* we've gone to using the badDelay, the only thing that
1674                            resets bad is when badDelay has expired.  but numFailures
1675                            is only just set below its threshold.  the proc's
1676                            start_times are all reset when the bad is.  the numFailures
1677                            is reset when we see an app run for a period */
1678
1679                         s->procs[i].start_time = 0;
1680                     }
1681
1682                     if (s->numFailures > MAX_FAILED_STARTS)
1683                     {
1684                         time_t last_start_time = s->procs[i].start_time;
1685
1686                         if (last_start_time && now - last_start_time > RUNTIME_SUCCESS_INTERVAL)
1687                         {
1688                             s->bad = 0;
1689                             s->numFailures = 0;
1690                         }
1691                         else
1692                         {
1693                             unsigned int j;
1694
1695                             for (j = 0; j < numChildren; ++j)
1696                             {
1697                                 if (s->procs[j].pid <= 0) continue;
1698                                 if (s->procs[j].state != FCGI_RUNNING_STATE) continue;
1699                                 if (s->procs[j].start_time == 0) continue;
1700                                 if (now - s->procs[j].start_time > RUNTIME_SUCCESS_INTERVAL) break;
1701                             }
1702
1703                             if (j >= numChildren)
1704                             {
1705                                 s->bad = 1;
1706                             }
1707                             else
1708                             {
1709                                 s->bad = 0;
1710                                 s->numFailures = 0;
1711                             }
1712                         }
1713                     }
1714
1715                     if (s->bad)
1716                     {
1717                         restartTime += FAILED_STARTS_DELAY;
1718                     }
1719                     else
1720                     {
1721                         restartTime += (restart) ? s->restartDelay : s->initStartDelay;
1722                     }
1723
1724                     if (restartTime <= now)
1725                     {
1726                         if (s->bad)
1727                         {
1728                             s->bad = 0;
1729                             s->numFailures = MAX_FAILED_STARTS;
1730                         }
1731
1732                         if (s->listenFd < 0 && init_listen_sock(s))
1733                         {
1734                             if (sleepSeconds > s->initStartDelay)
1735                                 sleepSeconds = s->initStartDelay;
1736                             break;
1737                         }
1738 #ifndef WIN32
1739                         if (caughtSigTerm) {
1740                             goto ProcessSigTerm;
1741                         }
1742 #endif
1743                         s->procs[i].pid = spawn_fs_process(s, &s->procs[i]);
1744                         if (s->procs[i].pid <= 0) {
1745                             ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
1746                                 "FastCGI: can't start%s server \"%s\": spawn_fs_process() failed",
1747                                 (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1748                                 s->fs_path);
1749
1750                             sleepSeconds = min(sleepSeconds,
1751                                 max((int) s->restartDelay, FCGI_MIN_EXEC_RETRY_DELAY));
1752
1753                             ap_assert(s->procs[i].pid < 0);
1754                             break;
1755                         }
1756
1757                         s->procs[i].start_time = now;
1758                         s->restartTime = now;
1759
1760                         if (s->startTime == 0) {
1761                             s->startTime = now;
1762                         }
1763
1764                         if (s->directive == APP_CLASS_DYNAMIC) {
1765                             s->numProcesses++;
1766                             fcgi_dynamic_total_proc_count++;
1767                             FCGIDBG2("++ fcgi_dynamic_total_proc_count=%d", fcgi_dynamic_total_proc_count);
1768                         }
1769
1770                         s->procs[i].state = FCGI_RUNNING_STATE;
1771
1772                         if (fcgi_wrapper) {
1773                             ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1774                                 "FastCGI:%s server \"%s\" (uid %ld, gid %ld) %sstarted (pid %ld)",
1775                                 (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1776                                 s->fs_path, (long) s->uid, (long) s->gid,
1777                                 restart ? "re" : "", (long) s->procs[i].pid);
1778                         }
1779                         else {
1780                             ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1781                                 "FastCGI:%s server \"%s\" %sstarted (pid %ld)",
1782                                 (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1783                                 s->fs_path, restart ? "re" : "", (long) s->procs[i].pid);
1784                         }
1785                         ap_assert(s->procs[i].pid > 0);
1786                     } else {
1787                         sleepSeconds = min(sleepSeconds, restartTime - now);
1788                     }
1789                 }
1790             }
1791         }
1792
1793 #ifndef WIN32
1794
1795         if(caughtSigTerm) {
1796             goto ProcessSigTerm;
1797         }
1798         if((!caughtSigChld) && (!caughtSigAlarm)) {
1799             fd_set rfds;
1800
1801             alarm(sleepSeconds);
1802
1803             FD_ZERO(&rfds);
1804             FD_SET(fcgi_pm_pipe[0], &rfds);
1805             read_ready = ap_select(fcgi_pm_pipe[0] + 1, &rfds, NULL, NULL, NULL);
1806
1807             alarmLeft = alarm(0);
1808         }
1809         callWaitPid = caughtSigChld;
1810         caughtSigChld = FALSE;
1811         callDynamicProcs = caughtSigAlarm;
1812         caughtSigAlarm = FALSE;
1813
1814         now = time(NULL);
1815
1816         /*
1817          * Dynamic fcgi process management
1818          */
1819         if((callDynamicProcs) || (!callWaitPid)) {
1820             dynamic_read_msgs(read_ready);
1821             if(fcgi_dynamic_epoch == 0) {
1822                 fcgi_dynamic_epoch = now;
1823             }
1824             if(((long)(now-fcgi_dynamic_epoch)>=dynamicKillInterval) ||
1825                     ((fcgi_dynamic_total_proc_count+dynamicProcessSlack)>=dynamicMaxProcs)) {
1826                 dynamic_kill_idle_fs_procs();
1827                 fcgi_dynamic_epoch = now;
1828             }
1829         }
1830
1831         if(!callWaitPid) {
1832             continue;
1833         }
1834
1835         /* We've caught SIGCHLD, so find out who it was using waitpid,
1836          * write a log message and update its data structure. */
1837
1838         for (;;) {
1839             if (caughtSigTerm)
1840                 goto ProcessSigTerm;
1841
1842             childPid = waitpid(-1, &waitStatus, WNOHANG);
1843
1844             if (childPid == -1 || childPid == 0)
1845                 break;
1846
1847             for (s = fcgi_servers; s != NULL; s = s->next) {
1848                 if (s->directive == APP_CLASS_EXTERNAL)
1849                     continue;
1850
1851                 if (s->directive == APP_CLASS_DYNAMIC)
1852                     numChildren = dynamicMaxClassProcs;
1853                 else
1854                     numChildren = s->numProcesses;
1855
1856                 for (i = 0; i < numChildren; i++) {
1857                     if (s->procs[i].pid == childPid)
1858                         goto ChildFound;
1859                 }
1860             }
1861
1862             /* TODO: print something about this unknown child */
1863             continue;
1864
1865 ChildFound:
1866             s->procs[i].pid = -1;
1867
1868             if (s->directive == APP_CLASS_STANDARD) {
1869                 /* Always restart static apps */
1870                 s->procs[i].state = FCGI_START_STATE;
1871                 s->numFailures++;
1872             }
1873             else {
1874                 s->numProcesses--;
1875                 fcgi_dynamic_total_proc_count--;
1876
1877                 if (s->procs[i].state == FCGI_VICTIM_STATE) {
1878                     s->procs[i].state = FCGI_KILLED_STATE;
1879                 }
1880                 else {
1881                     /* A dynamic app died or exited without provocation from the PM */
1882                     s->numFailures++;
1883
1884                     if (dynamicAutoRestart || (s->numProcesses <= 0 && dynamicThreshold1 == 0))
1885                         s->procs[i].state = FCGI_START_STATE;
1886                     else
1887                         s->procs[i].state = FCGI_READY_STATE;
1888                 }
1889             }
1890
1891             if (WIFEXITED(waitStatus)) {
1892                 ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1893                     "FastCGI:%s server \"%s\" (pid %ld) terminated by calling exit with status '%d'",
1894                     (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1895                     s->fs_path, (long) childPid, WEXITSTATUS(waitStatus));
1896             }
1897             else if (WIFSIGNALED(waitStatus)) {
1898                 ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1899                     "FastCGI:%s server \"%s\" (pid %ld) terminated due to uncaught signal '%d' (%s)%s",
1900                     (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1901                     s->fs_path, (long) childPid, WTERMSIG(waitStatus), get_signal_text(waitStatus),
1902 #ifdef WCOREDUMP
1903                     WCOREDUMP(waitStatus) ? ", a core file may have been generated" : "");
1904 #else
1905                     "");
1906 #endif
1907             }
1908             else if (WIFSTOPPED(waitStatus)) {
1909                 ap_log_error(FCGI_LOG_WARN_NOERRNO, fcgi_apache_main_server,
1910                     "FastCGI:%s server \"%s\" (pid %ld) stopped due to uncaught signal '%d' (%s)",
1911                     (s->directive == APP_CLASS_DYNAMIC) ? " (dynamic)" : "",
1912                     s->fs_path, (long) childPid, WTERMSIG(waitStatus), get_signal_text(waitStatus));
1913             }
1914         } /* for (;;), waitpid() */
1915
1916 #else /* WIN32 */
1917
1918         /* wait for an event to occur or timer expires */
1919         expire = time(NULL) + sleepSeconds;
1920         dwRet = WaitForMultipleObjects(3, (HANDLE *) fcgi_event_handles, FALSE, sleepSeconds * 1000);
1921
1922         if (dwRet == WAIT_FAILED) {
1923             /* There is something seriously wrong here */
1924             ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
1925                 "FastCGI: WaitForMultipleObjects() failed on event handles -- pm is shuting down");
1926                 bTimeToDie = TRUE;
1927         }
1928
1929         if (dwRet != WAIT_TIMEOUT) {
1930            now = time(NULL);
1931
1932            if (now < expire)
1933                alarmLeft = expire - now;
1934         }
1935
1936         /*
1937          * Dynamic fcgi process management
1938          */
1939         if ((dwRet == MBOX_EVENT) || (dwRet == WAIT_TIMEOUT)) {
1940             if (dwRet == MBOX_EVENT) {
1941                 read_ready = 1;
1942             }
1943
1944             now = time(NULL);
1945
1946             dynamic_read_msgs(read_ready);
1947
1948             if(fcgi_dynamic_epoch == 0) {
1949                 fcgi_dynamic_epoch = now;
1950             }
1951
1952             if ((now-fcgi_dynamic_epoch >= (int) dynamicKillInterval) ||
1953                ((fcgi_dynamic_total_proc_count+dynamicProcessSlack) >= dynamicMaxProcs)) {
1954                 dynamic_kill_idle_fs_procs();
1955                 fcgi_dynamic_epoch = now;
1956             }
1957             read_ready = 0;
1958         }
1959         else if (dwRet == WAKE_EVENT) {
1960             continue;
1961         }
1962         else if (dwRet == TERM_EVENT) {
1963             ap_log_error(FCGI_LOG_INFO_NOERRNO, fcgi_apache_main_server,
1964                 "FastCGI: Termination event received process manager shutting down");
1965
1966             bTimeToDie = TRUE;
1967             dwRet = WaitForSingleObject(child_wait_thread, INFINITE);
1968
1969             goto ProcessSigTerm;
1970         }
1971         else {
1972             // Have an received an unknown event - should not happen
1973             ap_log_error(FCGI_LOG_CRIT, fcgi_apache_main_server,
1974                 "FastCGI: WaitForMultipleobjects() return an unrecognized event");
1975
1976             bTimeToDie = TRUE;
1977             dwRet = WaitForSingleObject(child_wait_thread, INFINITE);
1978
1979             goto ProcessSigTerm;
1980         }
1981
1982 #endif /* WIN32 */
1983
1984     } /* for (;;), the whole shoot'n match */
1985
1986 ProcessSigTerm:
1987     /*
1988      * Kill off the children, then exit.
1989      */
1990     shutdown_all();
1991
1992 #ifdef WIN32
1993     return;
1994 #else
1995     exit(0);
1996 #endif
1997 }
1998
1999 #ifdef WIN32
2000 int fcgi_pm_add_job(fcgi_pm_job *new_job)
2001 {
2002     int rv = WaitForSingleObject(fcgi_dynamic_mbox_mutex, FCGI_MBOX_MUTEX_TIMEOUT);
2003
2004     if (rv != WAIT_OBJECT_0 && rv != WAIT_ABANDONED)
2005     {
2006         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
2007             "FastCGI: failed to aquire the dynamic mbox mutex - something is broke?!");
2008         return -1;
2009     }
2010
2011     new_job->next = fcgi_dynamic_mbox;
2012     fcgi_dynamic_mbox = new_job;
2013
2014     if (! ReleaseMutex(fcgi_dynamic_mbox_mutex))
2015     {
2016         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
2017             "FastCGI: failed to release the dynamic mbox mutex - something is broke?!");
2018     }
2019
2020     return 0;
2021 }
2022 #endif