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