?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix top_dir instructions
[mod_fastcgi.git] / mod_fastcgi.c
blob9be0cdedc995c919fb7ad2f9c87c0eb3bc637c85
1 /*
2 * mod_fastcgi.c --
3 *
4 * Apache server module for FastCGI.
5 *
6 * $Id: mod_fastcgi.c,v 1.136 2002/07/29 00:07:28 robs Exp $
7 *
8 * Copyright (c) 1995-1996 Open Market, Inc.
9 *
10 * See the file "LICENSE.TERMS" for information on usage and redistribution
11 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
12 *
13 *
14 * Patches for Apache-1.1 provided by
15 * Ralf S. Engelschall
16 * <rse@en.muc.de>
17 *
18 * Patches for Linux provided by
19 * Scott Langley
20 * <langles@vote-smart.org>
21 *
22 * Patches for suexec handling by
23 * Brian Grossman <brian@SoftHome.net> and
24 * Rob Saccoccio <robs@ipass.net>
25 */
26
27 /*
28 * Module design notes.
29 *
30 * 1. Restart cleanup.
31 *
32 * mod_fastcgi spawns several processes: one process manager process
33 * and several application processes. None of these processes
34 * handle SIGHUP, so they just go away when the Web server performs
35 * a restart (as Apache does every time it starts.)
36 *
37 * In order to allow the process manager to properly cleanup the
38 * running fastcgi processes (without being disturbed by Apache),
39 * an intermediate process was introduced. The diagram is as follows;
40 *
41 * ApacheWS --> MiddleProc --> ProcMgr --> FCGI processes
42 *
43 * On a restart, ApacheWS sends a SIGKILL to MiddleProc and then
44 * collects it via waitpid(). The ProcMgr periodically checks for
45 * its parent (via getppid()) and if it does not have one, as in
46 * case when MiddleProc has terminated, ProcMgr issues a SIGTERM
47 * to all FCGI processes, waitpid()s on them and then exits, so it
48 * can be collected by init(1). Doing it any other way (short of
49 * changing Apache API), results either in inconsistent results or
50 * in generation of zombie processes.
51 *
52 * XXX: How does Apache 1.2 implement "gentle" restart
53 * that does not disrupt current connections? How does
54 * gentle restart interact with restart cleanup?
55 *
56 * 2. Request timeouts.
57 *
58 * Earlier versions of this module used ap_soft_timeout() rather than
59 * ap_hard_timeout() and ate FastCGI server output until it completed.
60 * This precluded the FastCGI server from having to implement a
61 * SIGPIPE handler, but meant hanging the application longer than
62 * necessary. SIGPIPE handler now must be installed in ALL FastCGI
63 * applications. The handler should abort further processing and go
64 * back into the accept() loop.
65 *
66 * Although using ap_soft_timeout() is better than ap_hard_timeout()
67 * we have to be more careful about SIGINT handling and subsequent
68 * processing, so, for now, make it hard.
69 */
70
71
72 #include "fcgi.h"
73
74 #ifndef timersub
75 #define timersub(a, b, result) \
76 do { \
77 (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
78 (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
79 if ((result)->tv_usec < 0) { \
80 --(result)->tv_sec; \
81 (result)->tv_usec += 1000000; \
82 } \
83 } while (0)
84 #endif
85
86 /*
87 * Global variables
88 */
89
90 pool *fcgi_config_pool; /* the config pool */
91 server_rec *fcgi_apache_main_server;
92
93 const char *fcgi_wrapper = NULL; /* wrapper path */
94 uid_t fcgi_user_id; /* the run uid of Apache & PM */
95 gid_t fcgi_group_id; /* the run gid of Apache & PM */
96
97 fcgi_server *fcgi_servers = NULL; /* AppClasses */
98
99 char *fcgi_socket_dir = DEFAULT_SOCK_DIR; /* default FastCgiIpcDir */
100
101 char *fcgi_dynamic_dir = NULL; /* directory for the dynamic
102 * fastcgi apps' sockets */
103
104 #ifdef WIN32
105
106 #pragma warning( disable : 4706 4100 4127)
107 fcgi_pm_job *fcgi_dynamic_mbox = NULL;
108 HANDLE *fcgi_dynamic_mbox_mutex = NULL;
109 HANDLE fcgi_pm_thread = INVALID_HANDLE_VALUE;
110
111 #else
112
113 int fcgi_pm_pipe[2] = { -1, -1 };
114 pid_t fcgi_pm_pid = -1;
115
116 #endif
117
118 char *fcgi_empty_env = NULL;
119
120 u_int dynamicMaxProcs = FCGI_DEFAULT_MAX_PROCS;
121 int dynamicMinProcs = FCGI_DEFAULT_MIN_PROCS;
122 int dynamicMaxClassProcs = FCGI_DEFAULT_MAX_CLASS_PROCS;
123 u_int dynamicKillInterval = FCGI_DEFAULT_KILL_INTERVAL;
124 u_int dynamicUpdateInterval = FCGI_DEFAULT_UPDATE_INTERVAL;
125 float dynamicGain = FCGI_DEFAULT_GAIN;
126 int dynamicThreshold1 = FCGI_DEFAULT_THRESHOLD_1;
127 int dynamicThresholdN = FCGI_DEFAULT_THRESHOLD_N;
128 u_int dynamicPleaseStartDelay = FCGI_DEFAULT_START_PROCESS_DELAY;
129 u_int dynamicAppConnectTimeout = FCGI_DEFAULT_APP_CONN_TIMEOUT;
130 char **dynamicEnvp = &fcgi_empty_env;
131 u_int dynamicProcessSlack = FCGI_DEFAULT_PROCESS_SLACK;
132 int dynamicAutoRestart = FCGI_DEFAULT_RESTART_DYNAMIC;
133 int dynamicAutoUpdate = FCGI_DEFAULT_AUTOUPDATE;
134 int dynamicFlush = FCGI_FLUSH;
135 u_int dynamicListenQueueDepth = FCGI_DEFAULT_LISTEN_Q;
136 u_int dynamicInitStartDelay = DEFAULT_INIT_START_DELAY;
137 u_int dynamicRestartDelay = FCGI_DEFAULT_RESTART_DELAY;
138 array_header *dynamic_pass_headers = NULL;
139 u_int dynamic_idle_timeout = FCGI_DEFAULT_IDLE_TIMEOUT;
140
141 /*******************************************************************************
142 * Construct a message and write it to the pm_pipe.
143 */
144 static void send_to_pm(const char id, const char * const fs_path,
145 const char *user, const char * const group, const unsigned long q_usec,
146 const unsigned long req_usec)
147 {
148 #ifdef WIN32
149 fcgi_pm_job *job = NULL;
150
151 if (!(job = (fcgi_pm_job *) malloc(sizeof(fcgi_pm_job))))
152 return;
153 #else
154 static int failed_count = 0;
155 int buflen = 0;
156 char buf[FCGI_MAX_MSG_LEN];
157 #endif
158
159 if (strlen(fs_path) > FCGI_MAXPATH) {
160 ap_log_error(FCGI_LOG_ERR_NOERRNO, fcgi_apache_main_server,
161 "FastCGI: the path \"%s\" is too long (>%d) for a dynamic server", fs_path, FCGI_MAXPATH);
162 return;
163 }
164
165 switch(id) {
166
167 case FCGI_SERVER_START_JOB:
168 case FCGI_SERVER_RESTART_JOB:
169 #ifdef WIN32
170 job->id = id;
171 job->fs_path = strdup(fs_path);
172 job->user = strdup(user);
173 job->group = strdup(group);
174 job->qsec = 0L;
175 job->start_time = 0L;
176 #else
177 buflen = sprintf(buf, "%c %s %s %s*", id, fs_path, user, group);
178 #endif
179 break;
180
181 case FCGI_REQUEST_TIMEOUT_JOB:
182 #ifdef WIN32
183 job->id = id;
184 job->fs_path = strdup(fs_path);
185 job->user = strdup(user);
186 job->group = strdup(group);
187 job->qsec = 0L;
188 job->start_time = 0L;
189 #else
190 buflen = sprintf(buf, "%c %s %s %s*", id, fs_path, user, group);
191 #endif
192 break;
193
194 case FCGI_REQUEST_COMPLETE_JOB:
195 #ifdef WIN32
196 job->id = id;
197 job->fs_path = strdup(fs_path);
198 job->qsec = q_usec;
199 job->start_time = req_usec;
200 job->user = strdup(user);
201 job->group = strdup(group);
202 #else
203 buflen = sprintf(buf, "%c %s %s %s %lu %lu*", id, fs_path, user, group, q_usec, req_usec);
204 #endif
205 break;
206 }
207
208 #ifdef WIN32
209 if (fcgi_pm_add_job(job)) return;
210
211 SetEvent(fcgi_event_handles[MBOX_EVENT]);
212 #else
213 ap_assert(buflen <= FCGI_MAX_MSG_LEN);
214
215 /* There is no apache flag or function that can be used to id
216 * restart/shutdown pending so ignore the first few failures as
217 * once it breaks it will stay broke */
218 if (write(fcgi_pm_pipe[1], (const void *)buf, buflen) != buflen
219 && failed_count++ > 10)
220 {
221 ap_log_error(FCGI_LOG_WARN, fcgi_apache_main_server,
222 "FastCGI: write() to PM failed (ignore if a restart or shutdown is pending)");
223 }
224 #endif
225 }
226
227 /*
228 *----------------------------------------------------------------------
229 *
230 * init_module
231 *
232 * An Apache module initializer, called by the Apache core
233 * after reading the server config.
234 *
235 * Start the process manager no matter what, since there may be a
236 * request for dynamic FastCGI applications without any being
237 * configured as static applications. Also, check for the existence
238 * and create if necessary a subdirectory into which all dynamic
239 * sockets will go.
240 *
241 *----------------------------------------------------------------------
242 */
243 #ifdef APACHE2
244 static apcb_t init_module(apr_pool_t * p, apr_pool_t * plog,
245 apr_pool_t * tp, server_rec * s)
246 #else
247 static apcb_t init_module(server_rec *s, pool *p)
248 #endif
249 {
250 const char *err;
251
252 /* Register to reset to default values when the config pool is cleaned */
253 ap_block_alarms();
254 ap_register_cleanup(p, NULL, fcgi_config_reset_globals, ap_null_cleanup);
255 ap_unblock_alarms();
256
257 #ifdef APACHE2
258 ap_add_version_component(p, "mod_fastcgi/" MOD_FASTCGI_VERSION);
259 #else
260 ap_add_version_component("mod_fastcgi/" MOD_FASTCGI_VERSION);
261 #endif
262
263 fcgi_config_set_fcgi_uid_n_gid(1);
264
265 /* keep these handy */
266 fcgi_config_pool = p;
267 fcgi_apache_main_server = s;
268
269 #ifndef WIN32
270 /* Create Unix/Domain socket directory */
271 if ((err = fcgi_config_make_dir(p, fcgi_socket_dir)))
272 ap_log_error(FCGI_LOG_ERR, s, "FastCGI: %s", err);
273 #endif
274
275 /* Create Dynamic directory */
276 if ((err = fcgi_config_make_dynamic_dir(p, 1)))
277 ap_log_error(FCGI_LOG_ERR, s, "FastCGI: %s", err);
278
279 #ifndef WIN32
280 /* Spawn the PM only once. Under Unix, Apache calls init() routines
281 * twice, once before detach() and once after. Win32 doesn't detach.
282 * Under DSO, DSO modules are unloaded between the two init() calls.
283 * Under Unix, the -X switch causes two calls to init() but no detach
284 * (but all subprocesses are wacked so the PM is toasted anyway)! */
285
286 #ifndef APACHE2
287 if (ap_standalone && ap_restart_time == 0)
288 return;
289 #endif
290
291 /* Create the pipe for comm with the PM */
292 if (pipe(fcgi_pm_pipe) < 0) {
293 ap_log_error(FCGI_LOG_ERR, s, "FastCGI: pipe() failed");
294 }
295
296 /* Start the Process Manager */
297
298 #ifdef APACHE2
299 {
300 apr_proc_t * proc = apr_palloc(p, sizeof(*proc));
301 apr_status_t rv;
302
303 rv = apr_proc_fork(proc, tp);
304
305 if (rv == APR_INCHILD)
306 {
307 /* child */
308 fcgi_pm_main(NULL);
309 exit(1);
310 }
311 else if (rv != APR_INPARENT)
312 {
313 return rv;
314 }
315
316 /* parent */
317
318 apr_pool_note_subprocess(p, proc, APR_KILL_ONLY_ONCE);
319 }
320 #else /* !APACHE2 */
321
322 fcgi_pm_pid = ap_spawn_child(p, fcgi_pm_main, NULL, kill_only_once, NULL, NULL, NULL);
323 if (fcgi_pm_pid <= 0) {
324 ap_log_error(FCGI_LOG_ALERT, s,
325 "FastCGI: can't start the process manager, spawn_child() failed");
326 }
327
328 #endif /* !APACHE2 */
329
330 close(fcgi_pm_pipe[0]);
331
332 #endif /* !WIN32 */
333
334 return APCB_OK;
335 }
336
337 #ifdef APACHE2
338 static apcb_t fcgi_child_exit(void * dc)
339 #else
340 static apcb_t fcgi_child_exit(server_rec *dc0, pool *dc1)
341 #endif
342 {
343 #ifdef WIN32
344 /* Signal the PM thread to exit*/
345 SetEvent(fcgi_event_handles[TERM_EVENT]);
346
347 /* Waiting on pm thread to exit */
348 WaitForSingleObject(fcgi_pm_thread, INFINITE);
349 #endif
350
351 return APCB_OK;
352 }
353
354 #ifdef APACHE2
355 static void fcgi_child_init(apr_pool_t * p, server_rec * dc)
356 #else
357 static void fcgi_child_init(server_rec *dc, pool *p)
358 #endif
359 {
360 #ifdef WIN32
361 /* Create the MBOX, TERM, and WAKE event handlers */
362 fcgi_event_handles[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
363 if (fcgi_event_handles[0] == NULL) {
364 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
365 "FastCGI: CreateEvent() failed");
366 }
367 fcgi_event_handles[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
368 if (fcgi_event_handles[1] == NULL) {
369 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
370 "FastCGI: CreateEvent() failed");
371 }
372 fcgi_event_handles[2] = CreateEvent(NULL, FALSE, FALSE, NULL);
373 if (fcgi_event_handles[2] == NULL) {
374 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
375 "FastCGI: CreateEvent() failed");
376 }
377
378 /* Create the mbox mutex (PM - request threads) */
379 fcgi_dynamic_mbox_mutex = CreateMutex(NULL, FALSE, NULL);
380 if (fcgi_dynamic_mbox_mutex == NULL) {
381 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
382 "FastCGI: CreateMutex() failed");
383 }
384
385 /* Spawn of the process manager thread */
386 fcgi_pm_thread = (HANDLE) _beginthread(fcgi_pm_main, 0, NULL);
387 if (fcgi_pm_thread == (HANDLE) -1) {
388 ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
389 "_beginthread() failed to spawn the process manager");
390 }
391
392 #ifdef APACHE2
393 apr_pool_cleanup_register(p, NULL, fcgi_child_exit, fcgi_child_exit);
394 #endif
395 #endif
396 }
397
398 /*
399 *----------------------------------------------------------------------
400 *
401 * get_header_line --
402 *
403 * Terminate a line: scan to the next newline, scan back to the
404 * first non-space character and store a terminating zero. Return
405 * the next character past the end of the newline.
406 *
407 * If the end of the string is reached, ASSERT!
408 *
409 * If the FIRST character(s) in the line are '\n' or "\r\n", the
410 * first character is replaced with a NULL and next character
411 * past the newline is returned. NOTE: this condition supercedes
412 * the processing of RFC-822 continuation lines.
413 *
414 * If continuation is set to 'TRUE', then it parses a (possible)
415 * sequence of RFC-822 continuation lines.
416 *
417 * Results:
418 * As above.
419 *
420 * Side effects:
421 * Termination byte stored in string.
422 *
423 *----------------------------------------------------------------------
424 */
425 static char *get_header_line(char *start, int continuation)
426 {
427 char *p = start;
428 char *end = start;
429
430 if(p[0] == '\r' && p[1] == '\n') { /* If EOL in 1st 2 chars */
431 p++; /* point to \n and stop */
432 } else if(*p != '\n') {
433 if(continuation) {
434 while(*p != '\0') {
435 if(*p == '\n' && p[1] != ' ' && p[1] != '\t')
436 break;
437 p++;
438 }
439 } else {
440 while(*p != '\0' && *p != '\n') {
441 p++;
442 }
443 }
444 }
445
446 ap_assert(*p != '\0');
447 end = p;
448 end++;
449
450 /*
451 * Trim any trailing whitespace.
452 */
453 while(isspace((unsigned char)p[-1]) && p > start) {
454 p--;
455 }
456
457 *p = '\0';
458 return end;
459 }
460
461 /*
462 *----------------------------------------------------------------------
463 *
464 * process_headers --
465 *
466 * Call with r->parseHeader == SCAN_CGI_READING_HEADERS
467 * and initial script output in fr->header.
468 *
469 * If the initial script output does not include the header
470 * terminator ("\r\n\r\n") process_headers returns with no side
471 * effects, to be called again when more script output
472 * has been appended to fr->header.
473 *
474 * If the initial script output includes the header terminator,
475 * process_headers parses the headers and determines whether or
476 * not the remaining script output will be sent to the client.
477 * If so, process_headers sends the HTTP response headers to the
478 * client and copies any non-header script output to the output
479 * buffer reqOutbuf.
480 *
481 * Results:
482 * none.
483 *
484 * Side effects:
485 * May set r->parseHeader to:
486 * SCAN_CGI_FINISHED -- headers parsed, returning script response
487 * SCAN_CGI_BAD_HEADER -- malformed header from script
488 * SCAN_CGI_INT_REDIRECT -- handler should perform internal redirect
489 * SCAN_CGI_SRV_REDIRECT -- handler should return REDIRECT
490 *
491 *----------------------------------------------------------------------
492 */
493
494 static const char *process_headers(request_rec *r, fcgi_request *fr)
495 {
496 char *p, *next, *name, *value;
497 int len, flag;
498 int hasContentType, hasStatus, hasLocation;
499
500 ap_assert(fr->parseHeader == SCAN_CGI_READING_HEADERS);
501
502 if (fr->header == NULL)
503 return NULL;
504
505 /*
506 * Do we have the entire header? Scan for the blank line that
507 * terminates the header.
508 */
509 p = (char *)fr->header->elts;
510 len = fr->header->nelts;
511 flag = 0;
512 while(len-- && flag < 2) {
513 switch(*p) {
514 case '\r':
515 break;
516 case '\n':
517 flag++;
518 break;
519 case '\0':
520 case '\v':
521 case '\f':
522 name = "Invalid Character";
523 goto BadHeader;
524 break;
525 default:
526 flag = 0;
527 break;
528 }
529 p++;
530 }
531
532 /* Return (to be called later when we have more data)
533 * if we don't have an entire header. */
534 if (flag < 2)
535 return NULL;
536
537 /*
538 * Parse all the headers.
539 */
540 fr->parseHeader = SCAN_CGI_FINISHED;
541 hasContentType = hasStatus = hasLocation = FALSE;
542 next = (char *)fr->header->elts;
543 for(;;) {
544 next = get_header_line(name = next, TRUE);
545 if (*name == '\0') {
546 break;
547 }
548 if ((p = strchr(name, ':')) == NULL) {
549 goto BadHeader;
550 }
551 value = p + 1;
552 while (p != name && isspace((unsigned char)*(p - 1))) {
553 p--;
554 }
555 if (p == name) {
556 goto BadHeader;
557 }
558 *p = '\0';
559 if (strpbrk(name, " \t") != NULL) {
560 *p = ' ';
561 goto BadHeader;
562 }
563 while (isspace((unsigned char)*value)) {
564 value++;
565 }
566
567 if (strcasecmp(name, "Status") == 0) {
568 int statusValue = strtol(value, NULL, 10);
569
570 if (hasStatus) {
571 goto DuplicateNotAllowed;
572 }
573 if (statusValue < 0) {
574 fr->parseHeader = SCAN_CGI_BAD_HEADER;
575 return ap_psprintf(r->pool, "invalid Status '%s'", value);
576 }
577 hasStatus = TRUE;
578 r->status = statusValue;
579 r->status_line = ap_pstrdup(r->pool, value);
580 continue;
581 }
582
583 if (fr->role == FCGI_RESPONDER) {
584 if (strcasecmp(name, "Content-type") == 0) {
585 if (hasContentType) {
586 goto DuplicateNotAllowed;
587 }
588 hasContentType = TRUE;
589 r->content_type = ap_pstrdup(r->pool, value);
590 continue;
591 }
592
593 if (strcasecmp(name, "Location") == 0) {
594 if (hasLocation) {
595 goto DuplicateNotAllowed;
596 }
597 hasLocation = TRUE;
598 ap_table_set(r->headers_out, "Location", value);
599 continue;
600 }
601
602 /* If the script wants them merged, it can do it */
603 ap_table_add(r->err_headers_out, name, value);
604 continue;
605 }
606 else {
607 ap_table_add(fr->authHeaders, name, value);
608 }
609 }
610
611 if (fr->role != FCGI_RESPONDER)
612 return NULL;
613
614 /*
615 * Who responds, this handler or Apache?
616 */
617 if (hasLocation) {
618 const char *location = ap_table_get(r->headers_out, "Location");
619 /*
620 * Based on internal redirect handling in mod_cgi.c...
621 *
622 * If a script wants to produce its own Redirect
623 * body, it now has to explicitly *say* "Status: 302"
624 */
625 if (r->status == 200) {
626 if(location[0] == '/') {
627 /*
628 * Location is an relative path. This handler will
629 * consume all script output, then have Apache perform an
630 * internal redirect.
631 */
632 fr->parseHeader = SCAN_CGI_INT_REDIRECT;
633 return NULL;
634 } else {
635 /*
636 * Location is an absolute URL. If the script didn't
637 * produce a Content-type header, this handler will
638 * consume all script output and then have Apache generate
639 * its standard redirect response. Otherwise this handler
640 * will transmit the script's response.
641 */
642 fr->parseHeader = SCAN_CGI_SRV_REDIRECT;
643 return NULL;
644 }
645 }
646 }
647 /*
648 * We're responding. Send headers, buffer excess script output.
649 */
650 ap_send_http_header(r);
651
652 /* We need to reinstate our timeout, send_http_header() kill()s it */
653 ap_hard_timeout("FastCGI request processing", r);
654
655 if (r->header_only)
656 return NULL;
657
658 len = fr->header->nelts - (next - fr->header->elts);
659 ap_assert(len >= 0);
660 ap_assert(BufferLength(fr->clientOutputBuffer) == 0);
661 if (BufferFree(fr->clientOutputBuffer) < len) {
662 fr->clientOutputBuffer = fcgi_buf_new(r->pool, len);
663 }
664 ap_assert(BufferFree(fr->clientOutputBuffer) >= len);
665 if (len > 0) {
666 int sent = fcgi_buf_add_block(fr->clientOutputBuffer, next, len);
667 ap_assert(sent == len);
668 }
669 return NULL;
670
671 BadHeader:
672 /* Log first line of a multi-line header */
673 if ((p = strpbrk(name, "\r\n")) != NULL)
674 *p = '\0';
675 fr->parseHeader = SCAN_CGI_BAD_HEADER;
676 return ap_psprintf(r->pool, "malformed header '%s'", name);
677
678 DuplicateNotAllowed:
679 fr->parseHeader = SCAN_CGI_BAD_HEADER;
680 return ap_psprintf(r->pool, "duplicate header '%s'", name);
681 }
682
683 /*
684 * Read from the client filling both the FastCGI server buffer and the
685 * client buffer with the hopes of buffering the client data before
686 * making the connect() to the FastCGI server. This prevents slow
687 * clients from keeping the FastCGI server in processing longer than is
688 * necessary.
689 */
690 static int read_from_client_n_queue(fcgi_request *fr)
691 {
692 char *end;
693 int count;
694 long int countRead;
695
696 while (BufferFree(fr->clientInputBuffer) > 0 || BufferFree(fr->serverOutputBuffer) > 0) {
697 fcgi_protocol_queue_client_buffer(fr);
698
699 if (fr->expectingClientContent <= 0)
700 return OK;
701
702 fcgi_buf_get_free_block_info(fr->clientInputBuffer, &end, &count);
703 if (count == 0)
704 return OK;
705
706 if ((countRead = ap_get_client_block(fr->r, end, count)) < 0)
707 return -1;
708
709 if (countRead == 0) {
710 fr->expectingClientContent = 0;
711 }
712 else {
713 fcgi_buf_add_update(fr->clientInputBuffer, countRead);
714 ap_reset_timeout(fr->r);
715 }
716 }
717 return OK;
718 }
719
720 static int write_to_client(fcgi_request *fr)
721 {
722 char *begin;
723 int count;
724 int rv;
725 #ifdef APACHE2
726 apr_bucket * bkt;
727 apr_bucket_brigade * bde;
728 apr_bucket_alloc_t * const bkt_alloc = fr->r->connection->bucket_alloc;
729 #endif
730
731 fcgi_buf_get_block_info(fr->clientOutputBuffer, &begin, &count);
732 if (count == 0)
733 return OK;
734
735 /* If fewer than count bytes are written, an error occured.
736 * ap_bwrite() typically forces a flushed write to the client, this
737 * effectively results in a block (and short packets) - it should
738 * be fixed, but I didn't win much support for the idea on new-httpd.
739 * So, without patching Apache, the best way to deal with this is
740 * to size the fcgi_bufs to hold all of the script output (within
741 * reason) so the script can be released from having to wait around
742 * for the transmission to the client to complete. */
743
744 #ifdef APACHE2
745
746 bde = apr_brigade_create(fr->r->pool, bkt_alloc);
747 bkt = apr_bucket_transient_create(begin, count, bkt_alloc);
748 APR_BRIGADE_INSERT_TAIL(bde, bkt);
749
750 if (fr->fs ? fr->fs->flush : dynamicFlush)
751 {
752 bkt = apr_bucket_flush_create(bkt_alloc);
753 APR_BRIGADE_INSERT_TAIL(bde, bkt);
754 }
755
756 rv = ap_pass_brigade(fr->r->output_filters, bde);
757
758 #elif defined(RUSSIAN_APACHE)
759
760 rv = (ap_rwrite(begin, count, fr->r) != count);
761
762 #else
763
764 rv = (ap_bwrite(fr->r->connection->client, begin, count) != count);
765
766 #endif
767
768 if (rv)
769 {
770 ap_log_rerror(FCGI_LOG_INFO_NOERRNO, fr->r,
771 "FastCGI: client stopped connection before send body completed");
772 return -1;
773 }
774
775 #ifndef APACHE2
776
777 ap_reset_timeout(fr->r);
778
779 /* Don't bother with a wrapped buffer, limiting exposure to slow
780 * clients. The BUFF routines don't allow a writev from above,
781 * and don't always memcpy to minimize small write()s, this should
782 * be fixed, but I didn't win much support for the idea on
783 * new-httpd - I'll have to _prove_ its a problem first.. */
784
785 /* The default behaviour used to be to flush with every write, but this
786 * can tie up the FastCGI server longer than is necessary so its an option now */
787
788 if (fr->fs ? fr->fs->flush : dynamicFlush)
789 {
790 #ifdef RUSSIAN_APACHE
791 rv = ap_rflush(fr->r);
792 #else
793 rv = ap_bflush(fr->r->connection->client);
794 #endif
795
796 if (rv)
797 {
798 ap_log_rerror(FCGI_LOG_INFO_NOERRNO, fr->r,
799 "FastCGI: client stopped connection before send body completed");
800 return -1;
801 }
802
803 ap_reset_timeout(fr->r);
804 }
805
806 #endif /* !APACHE2 */
807
808 fcgi_buf_toss(fr->clientOutputBuffer, count);
809 return OK;
810 }
811
812 /*******************************************************************************
813 * Determine the user and group the wrapper should be called with.
814 * Based on code in Apache's create_argv_cmd() (util_script.c).
815 */
816 static void set_uid_n_gid(request_rec *r, const char **user, const char **group)
817 {
818 if (fcgi_wrapper == NULL) {
819 *user = "-";
820 *group = "-";
821 return;
822 }
823
824 if (strncmp("/~", r->uri, 2) == 0) {
825 /* its a user dir uri, just send the ~user, and leave it to the PM */
826 char *end = strchr(r->uri + 2, '/');
827
828 if (end)
829 *user = memcpy(ap_pcalloc(r->pool, end - r->uri), r->uri + 1, end - r->uri - 1);
830 else
831 *user = ap_pstrdup(r->pool, r->uri + 1);
832 *group = "-";
833 }
834 else {
835 *user = ap_psprintf(r->pool, "%ld", (long) fcgi_util_get_server_uid(r->server));
836 *group = ap_psprintf(r->pool, "%ld", (long) fcgi_util_get_server_gid(r->server));
837 }
838 }
839
840 static void send_request_complete(fcgi_request *fr)
841 {
842 if (fr->completeTime.tv_sec)
843 {
844 struct timeval qtime, rtime;
845
846 timersub(&fr->queueTime, &fr->startTime, &qtime);
847 timersub(&fr->completeTime, &fr->queueTime, &rtime);
848
849 send_to_pm(FCGI_REQUEST_COMPLETE_JOB, fr->fs_path,
850 fr->user, fr->group,
851 qtime.tv_sec * 1000000 + qtime.tv_usec,
852 rtime.tv_sec * 1000000 + rtime.tv_usec);
853 }
854 }
855
856 #ifdef WIN32
857
858 static int set_nonblocking(const fcgi_request * fr, int nonblocking)
859 {
860 if (fr->using_npipe_io)
861 {
862 if (nonblocking)
863 {
864 DWORD mode = PIPE_NOWAIT | PIPE_READMODE_BYTE;
865 if (SetNamedPipeHandleState((HANDLE) fr->fd, &mode, NULL, NULL) == 0)
866 {
867 ap_log_rerror(FCGI_LOG_ERR, fr->r,
868 "FastCGI: SetNamedPipeHandleState() failed");
869 return -1;
870 }
871 }
872 }
873 else
874 {
875 unsigned long ioctl_arg = (nonblocking) ? 1 : 0;
876 if (ioctlsocket(fr->fd, FIONBIO, &ioctl_arg) != 0)
877 {
878 errno = WSAGetLastError();
879 ap_log_rerror(FCGI_LOG_ERR_ERRNO, fr->r,
880 "FastCGI: ioctlsocket() failed");
881 return -1;
882 }
883 }
884
885 return 0;
886 }
887
888 #else
889
890 static int set_nonblocking(const fcgi_request * fr, int nonblocking)
891 {
892 int nb_flag = 0;
893 int fd_flags = fcntl(fr->fd, F_GETFL, 0);
894
895 if (fd_flags < 0) return -1;
896
897 #if defined(O_NONBLOCK)
898 nb_flag = O_NONBLOCK;
899 #elif defined(O_NDELAY)
900 nb_flag = O_NDELAY;
901 #elif defined(FNDELAY)
902 nb_flag = FNDELAY;
903 #else
904 #error "TODO - don't read from app until all data from client is posted."
905 #endif
906
907 fd_flags = (nonblocking) ? (fd_flags | nb_flag) : (fd_flags & ~nb_flag);
908
909 return fcntl(fr->fd, F_SETFL, fd_flags);
910 }
911
912 #endif
913
914 /*******************************************************************************
915 * Close the connection to the FastCGI server. This is normally called by
916 * do_work(), but may also be called as in request pool cleanup.
917 */
918 static void close_connection_to_fs(fcgi_request *fr)
919 {
920 #ifdef WIN32
921
922 if (fr->fd != INVALID_SOCKET)
923 {
924 set_nonblocking(fr, FALSE);
925
926 if (fr->using_npipe_io)
927 {
928 CloseHandle((HANDLE) fr->fd);
929 }
930 else
931 {
932 /* abort the connection entirely */
933 struct linger linger = {0, 0};
934 setsockopt(fr->fd, SOL_SOCKET, SO_LINGER, (void *) &linger, sizeof(linger));
935 closesocket(fr->fd);
936 }
937
938 fr->fd = INVALID_SOCKET;
939
940 #else /* ! WIN32 */
941
942 if (fr->fd >= 0)
943 {
944 struct linger linger = {0, 0};
945 set_nonblocking(fr, FALSE);
946 /* abort the connection entirely */
947 setsockopt(fr->fd, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger));
948 close(fr->fd);
949 fr->fd = -1;
950
951 #endif /* ! WIN32 */
952
953 if (fr->dynamic && fr->keepReadingFromFcgiApp == FALSE)
954 {
955 /* XXX FCGI_REQUEST_COMPLETE_JOB is only sent for requests which complete
956 * normally WRT the fcgi app. There is no data sent for
957 * connect() timeouts or requests which complete abnormally.
958 * KillDynamicProcs() and RemoveRecords() need to be looked at
959 * to be sure they can reasonably handle these cases before
960 * sending these sort of stats - theres some funk in there.
961 */
962 if (fcgi_util_ticks(&fr->completeTime) < 0)
963 {
964 /* there's no point to aborting the request, just log it */
965 ap_log_error(FCGI_LOG_ERR, fr->r->server, "FastCGI: can't get time of day");
966 }
967 }
968 }
969 }
970
971 /*******************************************************************************
972 * Connect to the FastCGI server.
973 */
974 static int open_connection_to_fs(fcgi_request *fr)
975 {
976 struct timeval tval;
977 fd_set write_fds, read_fds;
978 int status;
979 request_rec * const r = fr->r;
980 pool * const rp = r->pool;
981 const char *socket_path = NULL;
982 struct sockaddr *socket_addr = NULL;
983 int socket_addr_len = 0;
984 #ifndef WIN32
985 const char *err = NULL;
986 #endif
987
988 /* Create the connection point */
989 if (fr->dynamic)
990 {
991 socket_path = fcgi_util_socket_hash_filename(rp, fr->fs_path, fr->user, fr->group);
992 socket_path = fcgi_util_socket_make_path_absolute(rp, socket_path, 1);
993
994 #ifndef WIN32
995 err = fcgi_util_socket_make_domain_addr(rp, (struct sockaddr_un **)&socket_addr,
996 &socket_addr_len, socket_path);
997 if (err) {
998 ap_log_rerror(FCGI_LOG_ERR, r,
999 "FastCGI: failed to connect to server \"%s\": "
1000 "%s", fr->fs_path, err);
1001 return FCGI_FAILED;
1002 }
1003 #endif
1004 }
1005 else
1006 {
1007 #ifdef WIN32
1008 if (fr->fs->dest_addr != NULL) {
1009 socket_addr = fr->fs->dest_addr;
1010 }
1011 else if (fr->fs->socket_addr) {
1012 socket_addr = fr->fs->socket_addr;
1013 }
1014 else {
1015 socket_path = fr->fs->socket_path;
1016 }
1017 #else
1018 socket_addr = fr->fs->socket_addr;
1019 #endif
1020 socket_addr_len = fr->fs->socket_addr_len;
1021 }
1022
1023 if (fr->dynamic)
1024 {
1025 #ifdef WIN32
1026 if (fr->fs && fr->fs->restartTime)
1027 #else
1028 struct stat sock_stat;
1029
1030 if (stat(socket_path, &sock_stat) == 0)
1031 #endif
1032 {
1033 // It exists
1034 if (dynamicAutoUpdate)
1035 {
1036 struct stat app_stat;
1037
1038 /* TODO: follow sym links */
1039
1040 if (stat(fr->fs_path, &app_stat) == 0)
1041 {
1042 #ifdef WIN32
1043 if (fr->fs->startTime < app_stat.st_mtime)
1044 #else
1045 if (sock_stat.st_mtime < app_stat.st_mtime)
1046 #endif
1047 {
1048 #ifndef WIN32
1049 struct timeval tv = {1, 0};
1050 #endif
1051 /*
1052 * There's a newer one, request a restart.
1053 */
1054 send_to_pm(FCGI_SERVER_RESTART_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1055
1056 #ifdef WIN32
1057 Sleep(1000);
1058 #else
1059 /* Avoid sleep/alarm interactions */
1060 ap_select(0, NULL, NULL, NULL, &tv);
1061 #endif
1062 }
1063 }
1064 }
1065 }
1066 else
1067 {
1068 send_to_pm(FCGI_SERVER_START_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1069
1070 /* Wait until it looks like its running */
1071
1072 for (;;)
1073 {
1074 #ifdef WIN32
1075 Sleep(1000);
1076
1077 fr->fs = fcgi_util_fs_get_by_id(fr->fs_path, 0, 0);
1078
1079 if (fr->fs && fr->fs->restartTime)
1080 #else
1081 struct timeval tv = {1, 0};
1082
1083 /* Avoid sleep/alarm interactions */
1084 ap_select(0, NULL, NULL, NULL, &tv);
1085
1086 if (stat(socket_path, &sock_stat) == 0)
1087 #endif
1088 {
1089 break;
1090 }
1091 }
1092 }
1093 }
1094
1095 #ifdef WIN32
1096 if (socket_path)
1097 {
1098 BOOL ready;
1099 DWORD connect_time;
1100 int rv;
1101 HANDLE wait_npipe_mutex;
1102 DWORD interval;
1103 DWORD max_connect_time = FCGI_NAMED_PIPE_CONNECT_TIMEOUT;
1104
1105 fr->using_npipe_io = TRUE;
1106
1107 if (fr->dynamic)
1108 {
1109 interval = dynamicPleaseStartDelay * 1000;
1110
1111 if (dynamicAppConnectTimeout) {
1112 max_connect_time = dynamicAppConnectTimeout;
1113 }
1114 }
1115 else
1116 {
1117 interval = FCGI_NAMED_PIPE_CONNECT_TIMEOUT * 1000;
1118
1119 if (fr->fs->appConnectTimeout) {
1120 max_connect_time = fr->fs->appConnectTimeout;
1121 }
1122 }
1123
1124 fcgi_util_ticks(&fr->startTime);
1125
1126 {
1127 // xxx this handle should live somewhere (see CloseHandle()s below too)
1128 char * wait_npipe_mutex_name, * cp;
1129 wait_npipe_mutex_name = cp = ap_pstrdup(rp, socket_path);
1130 while ((cp = strchr(cp, '\\'))) *cp = '/';
1131
1132 wait_npipe_mutex = CreateMutex(NULL, FALSE, wait_npipe_mutex_name);
1133 }
1134
1135 if (wait_npipe_mutex == NULL)
1136 {
1137 ap_log_rerror(FCGI_LOG_ERR, r,
1138 "FastCGI: failed to connect to server \"%s\": "
1139 "can't create the WaitNamedPipe mutex", fr->fs_path);
1140 return FCGI_FAILED;
1141 }
1142
1143 SetLastError(ERROR_SUCCESS);
1144
1145 rv = WaitForSingleObject(wait_npipe_mutex, max_connect_time * 1000);
1146
1147 if (rv == WAIT_TIMEOUT || rv == WAIT_FAILED)
1148 {
1149 if (fr->dynamic)
1150 {
1151 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1152 }
1153 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
1154 "FastCGI: failed to connect to server \"%s\": "
1155 "wait for a npipe instance failed", fr->fs_path);
1156 FCGIDBG3("interval=%d, max_connect_time=%d", interval, max_connect_time);
1157 CloseHandle(wait_npipe_mutex);
1158 return FCGI_FAILED;
1159 }
1160
1161 fcgi_util_ticks(&fr->queueTime);
1162
1163 connect_time = fr->queueTime.tv_sec - fr->startTime.tv_sec;
1164
1165 if (fr->dynamic)
1166 {
1167 if (connect_time >= interval)
1168 {
1169 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1170 FCGIDBG4("connect_time=%d, interval=%d, max_connect_time=%d", connect_time, interval, max_connect_time);
1171 }
1172 if (max_connect_time - connect_time < interval)
1173 {
1174 interval = max_connect_time - connect_time;
1175 }
1176 }
1177 else
1178 {
1179 interval -= connect_time * 1000;
1180 }
1181
1182 for (;;)
1183 {
1184 ready = WaitNamedPipe(socket_path, interval);
1185
1186 if (ready)
1187 {
1188 fr->fd = (SOCKET) CreateFile(socket_path,
1189 GENERIC_READ | GENERIC_WRITE,
1190 FILE_SHARE_READ | FILE_SHARE_WRITE,
1191 NULL, // no security attributes
1192 OPEN_EXISTING, // opens existing pipe
1193 FILE_FLAG_OVERLAPPED,
1194 NULL); // no template file
1195
1196 if (fr->fd != (SOCKET) INVALID_HANDLE_VALUE)
1197 {
1198 ReleaseMutex(wait_npipe_mutex);
1199 CloseHandle(wait_npipe_mutex);
1200 fcgi_util_ticks(&fr->queueTime);
1201 FCGIDBG2("got npipe connect: %s", fr->fs_path);
1202 return FCGI_OK;
1203 }
1204
1205 if (GetLastError() != ERROR_PIPE_BUSY
1206 && GetLastError() != ERROR_FILE_NOT_FOUND)
1207 {
1208 ap_log_rerror(FCGI_LOG_ERR, r,
1209 "FastCGI: failed to connect to server \"%s\": "
1210 "CreateFile() failed", fr->fs_path);
1211 break;
1212 }
1213
1214 FCGIDBG2("missed npipe connect: %s", fr->fs_path);
1215 }
1216
1217 if (fr->dynamic)
1218 {
1219 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1220 }
1221
1222 fcgi_util_ticks(&fr->queueTime);
1223
1224 connect_time = fr->queueTime.tv_sec - fr->startTime.tv_sec;
1225
1226 FCGIDBG5("interval=%d, max_connect_time=%d, connect_time=%d, ready=%d", interval, max_connect_time, connect_time, ready);
1227
1228 if (connect_time >= max_connect_time)
1229 {
1230 ap_log_rerror(FCGI_LOG_ERR, r,
1231 "FastCGI: failed to connect to server \"%s\": "
1232 "CreateFile()/WaitNamedPipe() timed out", fr->fs_path);
1233 break;
1234 }
1235 }
1236
1237 ReleaseMutex(wait_npipe_mutex);
1238 CloseHandle(wait_npipe_mutex);
1239 fr->fd = INVALID_SOCKET;
1240 return FCGI_FAILED;
1241 }
1242
1243 #endif
1244
1245 /* Create the socket */
1246 fr->fd = socket(socket_addr->sa_family, SOCK_STREAM, 0);
1247
1248 #ifdef WIN32
1249 if (fr->fd == INVALID_SOCKET) {
1250 errno = WSAGetLastError(); // Not sure this is going to work as expected
1251 #else
1252 if (fr->fd < 0) {
1253 #endif
1254 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
1255 "FastCGI: failed to connect to server \"%s\": "
1256 "socket() failed", fr->fs_path);
1257 return FCGI_FAILED;
1258 }
1259
1260 #ifndef WIN32
1261 if (fr->fd >= FD_SETSIZE) {
1262 ap_log_rerror(FCGI_LOG_ERR, r,
1263 "FastCGI: failed to connect to server \"%s\": "
1264 "socket file descriptor (%u) is larger than "
1265 "FD_SETSIZE (%u), you probably need to rebuild Apache with a "
1266 "larger FD_SETSIZE", fr->fs_path, fr->fd, FD_SETSIZE);
1267 return FCGI_FAILED;
1268 }
1269 #endif
1270
1271 /* If appConnectTimeout is non-zero, setup do a non-blocking connect */
1272 if ((fr->dynamic && dynamicAppConnectTimeout) || (!fr->dynamic && fr->fs->appConnectTimeout)) {
1273 set_nonblocking(fr, TRUE);
1274 }
1275
1276 if (fr->dynamic) {
1277 fcgi_util_ticks(&fr->startTime);
1278 }
1279
1280 /* Connect */
1281 if (connect(fr->fd, (struct sockaddr *)socket_addr, socket_addr_len) == 0)
1282 goto ConnectionComplete;
1283
1284 #ifdef WIN32
1285
1286 errno = WSAGetLastError();
1287 if (errno != WSAEWOULDBLOCK) {
1288 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
1289 "FastCGI: failed to connect to server \"%s\": "
1290 "connect() failed", fr->fs_path);
1291 return FCGI_FAILED;
1292 }
1293
1294 #else
1295
1296 /* ECONNREFUSED means the listen queue is full (or there isn't one).
1297 * With dynamic I can at least make sure the PM knows this is occuring */
1298 if (fr->dynamic && errno == ECONNREFUSED) {
1299 /* @@@ This might be better as some other "kind" of message */
1300 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1301
1302 errno = ECONNREFUSED;
1303 }
1304
1305 if (errno != EINPROGRESS) {
1306 ap_log_rerror(FCGI_LOG_ERR, r,
1307 "FastCGI: failed to connect to server \"%s\": "
1308 "connect() failed", fr->fs_path);
1309 return FCGI_FAILED;
1310 }
1311
1312 #endif
1313
1314 /* The connect() is non-blocking */
1315
1316 errno = 0;
1317
1318 if (fr->dynamic) {
1319 do {
1320 FD_ZERO(&write_fds);
1321 FD_SET(fr->fd, &write_fds);
1322 read_fds = write_fds;
1323 tval.tv_sec = dynamicPleaseStartDelay;
1324 tval.tv_usec = 0;
1325
1326 status = ap_select((fr->fd+1), &read_fds, &write_fds, NULL, &tval);
1327 if (status < 0)
1328 break;
1329
1330 fcgi_util_ticks(&fr->queueTime);
1331
1332 if (status > 0)
1333 break;
1334
1335 /* select() timed out */
1336 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1337 } while ((fr->queueTime.tv_sec - fr->startTime.tv_sec) < (int)dynamicAppConnectTimeout);
1338
1339 /* XXX These can be moved down when dynamic vars live is a struct */
1340 if (status == 0) {
1341 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
1342 "FastCGI: failed to connect to server \"%s\": "
1343 "connect() timed out (appConnTimeout=%dsec)",
1344 fr->fs_path, dynamicAppConnectTimeout);
1345 return FCGI_FAILED;
1346 }
1347 } /* dynamic */
1348 else {
1349 tval.tv_sec = fr->fs->appConnectTimeout;
1350 tval.tv_usec = 0;
1351 FD_ZERO(&write_fds);
1352 FD_SET(fr->fd, &write_fds);
1353 read_fds = write_fds;
1354
1355 status = ap_select((fr->fd+1), &read_fds, &write_fds, NULL, &tval);
1356
1357 if (status == 0) {
1358 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
1359 "FastCGI: failed to connect to server \"%s\": "
1360 "connect() timed out (appConnTimeout=%dsec)",
1361 fr->fs_path, dynamicAppConnectTimeout);
1362 return FCGI_FAILED;
1363 }
1364 } /* !dynamic */
1365
1366 if (status < 0) {
1367 #ifdef WIN32
1368 errno = WSAGetLastError();
1369 #endif
1370 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
1371 "FastCGI: failed to connect to server \"%s\": "
1372 "select() failed", fr->fs_path);
1373 return FCGI_FAILED;
1374 }
1375
1376 if (FD_ISSET(fr->fd, &write_fds) || FD_ISSET(fr->fd, &read_fds)) {
1377 int error = 0;
1378 NET_SIZE_T len = sizeof(error);
1379
1380 if (getsockopt(fr->fd, SOL_SOCKET, SO_ERROR, (char *)&error, &len) < 0) {
1381 /* Solaris pending error */
1382 #ifdef WIN32
1383 errno = WSAGetLastError();
1384 #endif
1385 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
1386 "FastCGI: failed to connect to server \"%s\": "
1387 "select() failed (Solaris pending error)", fr->fs_path);
1388 return FCGI_FAILED;
1389 }
1390
1391 if (error != 0) {
1392 /* Berkeley-derived pending error */
1393 errno = error;
1394 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
1395 "FastCGI: failed to connect to server \"%s\": "
1396 "select() failed (pending error)", fr->fs_path);
1397 return FCGI_FAILED;
1398 }
1399 }
1400 else {
1401 #ifdef WIN32
1402 errno = WSAGetLastError();
1403 #endif
1404 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
1405 "FastCGI: failed to connect to server \"%s\": "
1406 "select() error - THIS CAN'T HAPPEN!", fr->fs_path);
1407 return FCGI_FAILED;
1408 }
1409
1410 ConnectionComplete:
1411 /* Return to blocking mode if it was set up */
1412 if ((fr->dynamic && dynamicAppConnectTimeout) || (!fr->dynamic && fr->fs->appConnectTimeout)) {
1413 set_nonblocking(fr, FALSE);
1414 }
1415
1416 #ifdef TCP_NODELAY
1417 if (socket_addr->sa_family == AF_INET) {
1418 /* We shouldn't be sending small packets and there's no application
1419 * level ack of the data we send, so disable Nagle */
1420 int set = 1;
1421 setsockopt(fr->fd, IPPROTO_TCP, TCP_NODELAY, (char *)&set, sizeof(set));
1422 }
1423 #endif
1424
1425 return FCGI_OK;
1426 }
1427
1428 static void sink_client_data(fcgi_request *fr)
1429 {
1430 char *base;
1431 int size;
1432
1433 fcgi_buf_reset(fr->clientInputBuffer);
1434 fcgi_buf_get_free_block_info(fr->clientInputBuffer, &base, &size);
1435 while (ap_get_client_block(fr->r, base, size) > 0);
1436 }
1437
1438 static apcb_t cleanup(void *data)
1439 {
1440 fcgi_request * const fr = (fcgi_request *) data;
1441
1442 if (fr == NULL) return APCB_OK;
1443
1444 /* its more than likely already run, but... */
1445 close_connection_to_fs(fr);
1446
1447 send_request_complete(fr);
1448
1449 if (fr->fs_stderr_len) {
1450 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, fr->r,
1451 "FastCGI: server \"%s\" stderr: %s", fr->fs_path, fr->fs_stderr);
1452 }
1453
1454 return APCB_OK;
1455 }
1456
1457 #ifdef WIN32
1458 static int npipe_io(fcgi_request * const fr)
1459 {
1460 request_rec * const r = fr->r;
1461 enum
1462 {
1463 STATE_ENV_SEND,
1464 STATE_CLIENT_RECV,
1465 STATE_SERVER_SEND,
1466 STATE_SERVER_RECV,
1467 STATE_CLIENT_SEND,
1468 STATE_CLIENT_ERROR,
1469 STATE_ERROR
1470 }
1471 state = STATE_ENV_SEND;
1472 env_status env_status;
1473 int client_recv;
1474 int dynamic_first_recv = fr->dynamic;
1475 int idle_timeout = fr->dynamic ? dynamic_idle_timeout : fr->fs->idle_timeout;
1476 int send_pending = 0;
1477 int recv_pending = 0;
1478 int client_send = 0;
1479 int rv;
1480 OVERLAPPED rov;
1481 OVERLAPPED sov;
1482 HANDLE events[2];
1483 struct timeval timeout;
1484 struct timeval dynamic_last_io_time = {0, 0};
1485 int did_io = 1;
1486 pool * const rp = r->pool;
1487
1488 DWORD recv_count = 0;
1489
1490 if (fr->role == FCGI_RESPONDER)
1491 {
1492 client_recv = (fr->expectingClientContent != 0);
1493 }
1494
1495 idle_timeout = fr->dynamic ? dynamic_idle_timeout : fr->fs->idle_timeout;
1496
1497 env_status.envp = NULL;
1498
1499 events[0] = CreateEvent(NULL, TRUE, FALSE, NULL);
1500 events[1] = CreateEvent(NULL, TRUE, FALSE, NULL);
1501 sov.hEvent = events[0];
1502 rov.hEvent = events[1];
1503
1504 if (fr->dynamic)
1505 {
1506 dynamic_last_io_time = fr->startTime;
1507
1508 if (dynamicAppConnectTimeout)
1509 {
1510 struct timeval qwait;
1511 timersub(&fr->queueTime, &fr->startTime, &qwait);
1512 dynamic_first_recv = qwait.tv_sec / dynamicPleaseStartDelay + 1;
1513 }
1514 }
1515
1516 ap_hard_timeout("FastCGI request processing", r);
1517
1518 while (state != STATE_CLIENT_SEND)
1519 {
1520 DWORD msec_timeout;
1521
1522 switch (state)
1523 {
1524 case STATE_ENV_SEND:
1525
1526 if (fcgi_protocol_queue_env(r, fr, &env_status) == 0)
1527 {
1528 goto SERVER_SEND;
1529 }
1530
1531 state = STATE_CLIENT_RECV;
1532
1533 /* fall through */
1534
1535 case STATE_CLIENT_RECV:
1536
1537 if (read_from_client_n_queue(fr) != OK)
1538 {
1539 state = STATE_CLIENT_ERROR;
1540 break;
1541 }
1542
1543 if (fr->eofSent)
1544 {
1545 state = STATE_SERVER_SEND;
1546 }
1547
1548 /* fall through */
1549
1550 SERVER_SEND:
1551
1552 case STATE_SERVER_SEND:
1553
1554 if (! send_pending && BufferLength(fr->serverOutputBuffer))
1555 {
1556 Buffer * b = fr->serverOutputBuffer;
1557 DWORD sent, len;
1558
1559 len = min(b->length, b->data + b->size - b->begin);
1560
1561 if (WriteFile((HANDLE) fr->fd, b->begin, len, &sent, &sov))
1562 {
1563 fcgi_buf_removed(b, sent);
1564 ResetEvent(sov.hEvent);
1565 }
1566 else if (GetLastError() == ERROR_IO_PENDING)
1567 {
1568 send_pending = 1;
1569 }
1570 else
1571 {
1572 ap_log_rerror(FCGI_LOG_ERR, r, "FastCGI: comm with server "
1573 "\"%s\" aborted: WriteFile() failed", fr->fs_path);
1574 state = STATE_ERROR;
1575 break;
1576 }
1577 }
1578
1579 /* fall through */
1580
1581 case STATE_SERVER_RECV:
1582
1583 /*
1584 * Only get more data when the serverInputBuffer is empty.
1585 * Otherwise we may already have the END_REQUEST buffered
1586 * (but not processed) and a read on a closed named pipe
1587 * results in an error that is normally abnormal.
1588 */
1589 if (! recv_pending && BufferLength(fr->serverInputBuffer) == 0)
1590 {
1591 Buffer * b = fr->serverInputBuffer;
1592 DWORD rcvd, len;
1593
1594 len = min(b->size - b->length, b->data + b->size - b->end);
1595
1596 if (ReadFile((HANDLE) fr->fd, b->end, len, &rcvd, &rov))
1597 {
1598 fcgi_buf_added(b, rcvd);
1599 recv_count += rcvd;
1600 ResetEvent(rov.hEvent);
1601 if (dynamic_first_recv)
1602 {
1603 dynamic_first_recv = 0;
1604 }
1605 }
1606 else if (GetLastError() == ERROR_IO_PENDING)
1607 {
1608 recv_pending = 1;
1609 }
1610 else if (GetLastError() == ERROR_HANDLE_EOF)
1611 {
1612 fr->keepReadingFromFcgiApp = FALSE;
1613 state = STATE_CLIENT_SEND;
1614 ResetEvent(rov.hEvent);
1615 break;
1616 }
1617 else if (GetLastError() == ERROR_NO_DATA)
1618 {
1619 break;
1620 }
1621 else
1622 {
1623 ap_log_rerror(FCGI_LOG_ERR, r, "FastCGI: comm with server "
1624 "\"%s\" aborted: ReadFile() failed", fr->fs_path);
1625 state = STATE_ERROR;
1626 break;
1627 }
1628 }
1629
1630 /* fall through */
1631
1632 case STATE_CLIENT_SEND:
1633
1634 if (client_send || ! BufferFree(fr->clientOutputBuffer))
1635 {
1636 if (write_to_client(fr))
1637 {
1638 state = STATE_CLIENT_ERROR;
1639 break;
1640 }
1641
1642 client_send = 0;
1643 }
1644
1645 break;
1646
1647 default:
1648
1649 ap_assert(0);
1650 }
1651
1652 if (state == STATE_CLIENT_ERROR || state == STATE_ERROR)
1653 {
1654 break;
1655 }
1656
1657 /* setup the io timeout */
1658
1659 if (BufferLength(fr->clientOutputBuffer))
1660 {
1661 /* don't let client data sit too long, it might be a push */
1662 timeout.tv_sec = 0;
1663 timeout.tv_usec = 100000;
1664 }
1665 else if (dynamic_first_recv)
1666 {
1667 int delay;
1668 struct timeval qwait;
1669
1670 fcgi_util_ticks(&fr->queueTime);
1671
1672 if (did_io)
1673 {
1674 /* a send() succeeded last pass */
1675 dynamic_last_io_time = fr->queueTime;
1676 }
1677 else
1678 {
1679 /* timed out last pass */
1680 struct timeval idle_time;
1681
1682 timersub(&fr->queueTime, &dynamic_last_io_time, &idle_time);
1683
1684 if (idle_time.tv_sec > idle_timeout)
1685 {
1686 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1687 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: comm "
1688 "with (dynamic) server \"%s\" aborted: (first read) "
1689 "idle timeout (%d sec)", fr->fs_path, idle_timeout);
1690 state = STATE_ERROR;
1691 break;
1692 }
1693 }
1694
1695 timersub(&fr->queueTime, &fr->startTime, &qwait);
1696
1697 delay = dynamic_first_recv * dynamicPleaseStartDelay;
1698
1699 if (qwait.tv_sec < delay)
1700 {
1701 timeout.tv_sec = delay;
1702 timeout.tv_usec = 100000; /* fudge for select() slop */
1703 timersub(&timeout, &qwait, &timeout);
1704 }
1705 else
1706 {
1707 /* Killed time somewhere.. client read? */
1708 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1709 dynamic_first_recv = qwait.tv_sec / dynamicPleaseStartDelay + 1;
1710 timeout.tv_sec = dynamic_first_recv * dynamicPleaseStartDelay;
1711 timeout.tv_usec = 100000; /* fudge for select() slop */
1712 timersub(&timeout, &qwait, &timeout);
1713 }
1714 }
1715 else
1716 {
1717 timeout.tv_sec = idle_timeout;
1718 timeout.tv_usec = 0;
1719 }
1720
1721 /* require a pended recv otherwise the app can deadlock */
1722 if (recv_pending)
1723 {
1724 msec_timeout = timeout.tv_sec * 1000 + timeout.tv_usec / 1000;
1725
1726 rv = WaitForMultipleObjects(2, events, FALSE, msec_timeout);
1727
1728 if (rv == WAIT_TIMEOUT)
1729 {
1730 did_io = 0;
1731
1732 if (BufferLength(fr->clientOutputBuffer))
1733 {
1734 client_send = 1;
1735 }
1736 else if (dynamic_first_recv)
1737 {
1738 struct timeval qwait;
1739
1740 fcgi_util_ticks(&fr->queueTime);
1741 timersub(&fr->queueTime, &fr->startTime, &qwait);
1742
1743 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
1744
1745 dynamic_first_recv = qwait.tv_sec / dynamicPleaseStartDelay + 1;
1746 }
1747 else
1748 {
1749 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: comm with "
1750 "server \"%s\" aborted: idle timeout (%d sec)",
1751 fr->fs_path, idle_timeout);
1752 state = STATE_ERROR;
1753 break;
1754 }
1755 }
1756 else
1757 {
1758 int i = rv - WAIT_OBJECT_0;
1759
1760 did_io = 1;
1761
1762 if (i == 0)
1763 {
1764 DWORD sent;
1765
1766 if (GetOverlappedResult((HANDLE) fr->fd, &sov, &sent, FALSE))
1767 {
1768 send_pending = 0;
1769 ResetEvent(sov.hEvent);
1770 fcgi_buf_removed(fr->serverOutputBuffer, sent);
1771 }
1772 else
1773 {
1774 ap_log_rerror(FCGI_LOG_ERR, r, "FastCGI: comm with server "
1775 "\"%s\" aborted: GetOverlappedResult() failed", fr->fs_path);
1776 state = STATE_ERROR;
1777 break;
1778 }
1779 }
1780 else
1781 {
1782 DWORD rcvd;
1783
1784 ap_assert(i == 1);
1785
1786 recv_pending = 0;
1787 ResetEvent(rov.hEvent);
1788
1789 if (GetOverlappedResult((HANDLE) fr->fd, &rov, &rcvd, FALSE))
1790 {
1791 fcgi_buf_added(fr->serverInputBuffer, rcvd);
1792 if (dynamic_first_recv)
1793 {
1794 dynamic_first_recv = 0;
1795 }
1796 }
1797 else
1798 {
1799 ap_log_rerror(FCGI_LOG_ERR, r, "FastCGI: comm with server "
1800 "\"%s\" aborted: GetOverlappedResult() failed", fr->fs_path);
1801 state = STATE_ERROR;
1802 break;
1803 }
1804 }
1805 }
1806 }
1807
1808 if (fcgi_protocol_dequeue(rp, fr))
1809 {
1810 state = STATE_ERROR;
1811 break;
1812 }
1813
1814 if (fr->parseHeader == SCAN_CGI_READING_HEADERS)
1815 {
1816 const char * err = process_headers(r, fr);
1817 if (err)
1818 {
1819 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
1820 "FastCGI: comm with server \"%s\" aborted: "
1821 "error parsing headers: %s", fr->fs_path, err);
1822 state = STATE_ERROR;
1823 break;
1824 }
1825 }
1826
1827 if (fr->exitStatusSet)
1828 {
1829 fr->keepReadingFromFcgiApp = FALSE;
1830 state = STATE_CLIENT_SEND;
1831 break;
1832 }
1833 }
1834
1835 if (! fr->exitStatusSet || ! fr->eofSent)
1836 {
1837 CancelIo((HANDLE) fr->fd);
1838 }
1839
1840 CloseHandle(rov.hEvent);
1841 CloseHandle(sov.hEvent);
1842
1843 return (state == STATE_ERROR);
1844 }
1845 #endif /* WIN32 */
1846
1847 static int socket_io(fcgi_request * const fr)
1848 {
1849 enum
1850 {
1851 STATE_SOCKET_NONE,
1852 STATE_ENV_SEND,
1853 STATE_CLIENT_RECV,
1854 STATE_SERVER_SEND,
1855 STATE_SERVER_RECV,
1856 STATE_CLIENT_SEND,
1857 STATE_ERROR,
1858 STATE_CLIENT_ERROR
1859 }
1860 state = STATE_ENV_SEND;
1861
1862 request_rec * const r = fr->r;
1863
1864 struct timeval timeout;
1865 struct timeval dynamic_last_io_time = {0, 0};
1866 fd_set read_set;
1867 fd_set write_set;
1868 int nfds = fr->fd + 1;
1869 int select_status = 1;
1870 int idle_timeout;
1871 int rv;
1872 int dynamic_first_recv = fr->dynamic ? 1 : 0;
1873 int client_send = FALSE;
1874 int client_recv = FALSE;
1875 env_status env;
1876 pool *rp = r->pool;
1877
1878 if (fr->role == FCGI_RESPONDER)
1879 {
1880 client_recv = (fr->expectingClientContent != 0);
1881 }
1882
1883 idle_timeout = fr->dynamic ? dynamic_idle_timeout : fr->fs->idle_timeout;
1884
1885 env.envp = NULL;
1886
1887 if (fr->dynamic)
1888 {
1889 dynamic_last_io_time = fr->startTime;
1890
1891 if (dynamicAppConnectTimeout)
1892 {
1893 struct timeval qwait;
1894 timersub(&fr->queueTime, &fr->startTime, &qwait);
1895 dynamic_first_recv = qwait.tv_sec / dynamicPleaseStartDelay + 1;
1896 }
1897 }
1898
1899 ap_hard_timeout("FastCGI request processing", r);
1900
1901 set_nonblocking(fr, TRUE);
1902
1903 for (;;)
1904 {
1905 FD_ZERO(&read_set);
1906 FD_ZERO(&write_set);
1907
1908 switch (state)
1909 {
1910 case STATE_ENV_SEND:
1911
1912 if (fcgi_protocol_queue_env(r, fr, &env) == 0)
1913 {
1914 goto SERVER_SEND;
1915 }
1916
1917 state = STATE_CLIENT_RECV;
1918
1919 /* fall through */
1920
1921 case STATE_CLIENT_RECV:
1922
1923 if (read_from_client_n_queue(fr))
1924 {
1925 state = STATE_CLIENT_ERROR;
1926 break;
1927 }
1928
1929 if (fr->eofSent)
1930 {
1931 state = STATE_SERVER_SEND;
1932 }
1933
1934 /* fall through */
1935
1936 SERVER_SEND:
1937
1938 case STATE_SERVER_SEND:
1939
1940 if (BufferLength(fr->serverOutputBuffer))
1941 {
1942 FD_SET(fr->fd, &write_set);
1943 }
1944 else
1945 {
1946 ap_assert(fr->eofSent);
1947 state = STATE_SERVER_RECV;
1948 }
1949
1950 /* fall through */
1951
1952 case STATE_SERVER_RECV:
1953
1954 FD_SET(fr->fd, &read_set);
1955
1956 /* fall through */
1957
1958 case STATE_CLIENT_SEND:
1959
1960 if (client_send || ! BufferFree(fr->clientOutputBuffer))
1961 {
1962 if (write_to_client(fr))
1963 {
1964 state = STATE_CLIENT_ERROR;
1965 break;
1966 }
1967
1968 client_send = 0;
1969 }
1970
1971 break;
1972
1973 case STATE_ERROR:
1974 case STATE_CLIENT_ERROR:
1975
1976 break;
1977
1978 default:
1979
1980 ap_assert(0);
1981 }
1982
1983 if (state == STATE_CLIENT_ERROR || state == STATE_ERROR)
1984 {
1985 break;
1986 }
1987
1988 /* setup the io timeout */
1989
1990 if (BufferLength(fr->clientOutputBuffer))
1991 {
1992 /* don't let client data sit too long, it might be a push */
1993 timeout.tv_sec = 0;
1994 timeout.tv_usec = 100000;
1995 }
1996 else if (dynamic_first_recv)
1997 {
1998 int delay;
1999 struct timeval qwait;
2000
2001 fcgi_util_ticks(&fr->queueTime);
2002
2003 if (select_status)
2004 {
2005 /* a send() succeeded last pass */
2006 dynamic_last_io_time = fr->queueTime;
2007 }
2008 else
2009 {
2010 /* timed out last pass */
2011 struct timeval idle_time;
2012
2013 timersub(&fr->queueTime, &dynamic_last_io_time, &idle_time);
2014
2015 if (idle_time.tv_sec > idle_timeout)
2016 {
2017 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
2018 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: comm "
2019 "with (dynamic) server \"%s\" aborted: (first read) "
2020 "idle timeout (%d sec)", fr->fs_path, idle_timeout);
2021 state = STATE_ERROR;
2022 break;
2023 }
2024 }
2025
2026 timersub(&fr->queueTime, &fr->startTime, &qwait);
2027
2028 delay = dynamic_first_recv * dynamicPleaseStartDelay;
2029
2030 FCGIDBG5("qwait=%ld.%06ld delay=%d first_recv=%d", qwait.tv_sec, qwait.tv_usec, delay, dynamic_first_recv);
2031
2032 if (qwait.tv_sec < delay)
2033 {
2034 timeout.tv_sec = delay;
2035 timeout.tv_usec = 100000; /* fudge for select() slop */
2036 timersub(&timeout, &qwait, &timeout);
2037 }
2038 else
2039 {
2040 /* Killed time somewhere.. client read? */
2041 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
2042 dynamic_first_recv = qwait.tv_sec / dynamicPleaseStartDelay + 1;
2043 timeout.tv_sec = dynamic_first_recv * dynamicPleaseStartDelay;
2044 timeout.tv_usec = 100000; /* fudge for select() slop */
2045 timersub(&timeout, &qwait, &timeout);
2046 }
2047 }
2048 else
2049 {
2050 timeout.tv_sec = idle_timeout;
2051 timeout.tv_usec = 0;
2052 }
2053
2054 /* wait on the socket */
2055 select_status = ap_select(nfds, &read_set, &write_set, NULL, &timeout);
2056
2057 if (select_status < 0)
2058 {
2059 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r, "FastCGI: comm with server "
2060 "\"%s\" aborted: select() failed", fr->fs_path);
2061 state = STATE_ERROR;
2062 break;
2063 }
2064
2065 if (select_status == 0)
2066 {
2067 /* select() timeout */
2068
2069 if (BufferLength(fr->clientOutputBuffer))
2070 {
2071 if (fr->role == FCGI_RESPONDER)
2072 {
2073 client_send = TRUE;
2074 }
2075 }
2076 else if (dynamic_first_recv)
2077 {
2078 struct timeval qwait;
2079
2080 fcgi_util_ticks(&fr->queueTime);
2081 timersub(&fr->queueTime, &fr->startTime, &qwait);
2082
2083 send_to_pm(FCGI_REQUEST_TIMEOUT_JOB, fr->fs_path, fr->user, fr->group, 0, 0);
2084
2085 dynamic_first_recv = qwait.tv_sec / dynamicPleaseStartDelay + 1;
2086 continue;
2087 }
2088 else
2089 {
2090 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: comm with "
2091 "server \"%s\" aborted: idle timeout (%d sec)",
2092 fr->fs_path, idle_timeout);
2093 state = STATE_ERROR;
2094 }
2095 }
2096
2097 if (FD_ISSET(fr->fd, &write_set))
2098 {
2099 /* send to the server */
2100
2101 rv = fcgi_buf_socket_send(fr->serverOutputBuffer, fr->fd);
2102
2103 if (rv < 0)
2104 {
2105 ap_log_rerror(FCGI_LOG_ERR, r, "FastCGI: comm with server "
2106 "\"%s\" aborted: write failed", fr->fs_path);
2107 state = STATE_ERROR;
2108 break;
2109 }
2110 }
2111
2112 if (FD_ISSET(fr->fd, &read_set))
2113 {
2114 /* recv from the server */
2115
2116 if (dynamic_first_recv)
2117 {
2118 dynamic_first_recv = 0;
2119 fcgi_util_ticks(&fr->queueTime);
2120 }
2121
2122 rv = fcgi_buf_socket_recv(fr->serverInputBuffer, fr->fd);
2123
2124 if (rv < 0)
2125 {
2126 ap_log_rerror(FCGI_LOG_ERR, r, "FastCGI: comm with server "
2127 "\"%s\" aborted: read failed", fr->fs_path);
2128 state = STATE_ERROR;
2129 break;
2130 }
2131
2132 if (rv == 0)
2133 {
2134 fr->keepReadingFromFcgiApp = FALSE;
2135 state = STATE_CLIENT_SEND;
2136 break;
2137 }
2138 }
2139
2140 if (fcgi_protocol_dequeue(rp, fr))
2141 {
2142 state = STATE_ERROR;
2143 break;
2144 }
2145
2146 if (fr->parseHeader == SCAN_CGI_READING_HEADERS)
2147 {
2148 const char * err = process_headers(r, fr);
2149 if (err)
2150 {
2151 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2152 "FastCGI: comm with server \"%s\" aborted: "
2153 "error parsing headers: %s", fr->fs_path, err);
2154 state = STATE_ERROR;
2155 break;
2156 }
2157 }
2158
2159 if (fr->exitStatusSet)
2160 {
2161 fr->keepReadingFromFcgiApp = FALSE;
2162 state = STATE_CLIENT_SEND;
2163 break;
2164 }
2165 }
2166
2167 return (state == STATE_ERROR);
2168 }
2169
2170
2171 /*----------------------------------------------------------------------
2172 * This is the core routine for moving data between the FastCGI
2173 * application and the Web server's client.
2174 */
2175 static int do_work(request_rec * const r, fcgi_request * const fr)
2176 {
2177 int rv;
2178 pool *rp = r->pool;
2179
2180 fcgi_protocol_queue_begin_request(fr);
2181
2182 if (fr->role == FCGI_RESPONDER)
2183 {
2184 rv = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR);
2185 if (rv != OK)
2186 {
2187 ap_kill_timeout(r);
2188 return rv;
2189 }
2190
2191 fr->expectingClientContent = ap_should_client_block(r);
2192 }
2193
2194 ap_block_alarms();
2195 ap_register_cleanup(rp, (void *)fr, cleanup, ap_null_cleanup);
2196 ap_unblock_alarms();
2197
2198 ap_hard_timeout("connect() to FastCGI server", r);
2199
2200 /* Connect to the FastCGI Application */
2201 if (open_connection_to_fs(fr) != FCGI_OK)
2202 {
2203 ap_kill_timeout(r);
2204 return HTTP_INTERNAL_SERVER_ERROR;
2205 }
2206
2207 #ifdef WIN32
2208 if (fr->using_npipe_io)
2209 {
2210 rv = npipe_io(fr);
2211 }
2212 else
2213 #endif
2214 {
2215 rv = socket_io(fr);
2216 }
2217
2218 /* comm with the server is done */
2219 close_connection_to_fs(fr);
2220
2221 if (fr->role == FCGI_RESPONDER)
2222 {
2223 sink_client_data(fr);
2224 }
2225
2226 while (rv == 0 && BufferLength(fr->serverInputBuffer) || BufferLength(fr->clientOutputBuffer))
2227 {
2228 if (fcgi_protocol_dequeue(rp, fr))
2229 {
2230 rv = HTTP_INTERNAL_SERVER_ERROR;
2231 }
2232
2233 if (fr->parseHeader == SCAN_CGI_READING_HEADERS)
2234 {
2235 const char * err = process_headers(r, fr);
2236 if (err)
2237 {
2238 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2239 "FastCGI: comm with server \"%s\" aborted: "
2240 "error parsing headers: %s", fr->fs_path, err);
2241 rv = HTTP_INTERNAL_SERVER_ERROR;
2242 }
2243 }
2244
2245 if (fr->role == FCGI_RESPONDER)
2246 {
2247 if (write_to_client(fr))
2248 {
2249 break;
2250 }
2251 }
2252 else
2253 {
2254 fcgi_buf_reset(fr->clientOutputBuffer);
2255 }
2256 }
2257
2258 switch (fr->parseHeader)
2259 {
2260 case SCAN_CGI_FINISHED:
2261
2262 if (fr->role == FCGI_RESPONDER)
2263 {
2264 /* RUSSIAN_APACHE requires rflush() over bflush() */
2265 ap_rflush(r);
2266 #ifndef APACHE2
2267 ap_bgetopt(r->connection->client, BO_BYTECT, &r->bytes_sent);
2268 #endif
2269 }
2270
2271 /* fall through */
2272
2273 case SCAN_CGI_INT_REDIRECT:
2274 case SCAN_CGI_SRV_REDIRECT:
2275
2276 break;
2277
2278 case SCAN_CGI_READING_HEADERS:
2279
2280 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: incomplete headers "
2281 "(%d bytes) received from server \"%s\"", fr->header->nelts, fr->fs_path);
2282
2283 /* fall through */
2284
2285 case SCAN_CGI_BAD_HEADER:
2286
2287 rv = HTTP_INTERNAL_SERVER_ERROR;
2288 break;
2289
2290 default:
2291
2292 ap_assert(0);
2293 rv = HTTP_INTERNAL_SERVER_ERROR;
2294 }
2295
2296 ap_kill_timeout(r);
2297 return rv;
2298 }
2299
2300 static fcgi_request *create_fcgi_request(request_rec * const r, const char *fs_path)
2301 {
2302 struct stat *my_finfo;
2303 pool * const p = r->pool;
2304 fcgi_server *fs;
2305 fcgi_request * const fr = (fcgi_request *)ap_pcalloc(p, sizeof(fcgi_request));
2306
2307 #ifndef APACHE2
2308 if (fs_path)
2309 {
2310 #endif
2311 my_finfo = (struct stat *)ap_palloc(p, sizeof(struct stat));
2312 if (stat(fs_path, my_finfo) < 0) {
2313 ap_log_rerror(FCGI_LOG_ERR_ERRNO, r,
2314 "FastCGI: stat() of \"%s\" failed", fs_path);
2315 return NULL;
2316 }
2317 #ifndef APACHE2
2318 }
2319 else {
2320 my_finfo = &r->finfo;
2321 fs_path = r->filename;
2322 }
2323 #endif
2324
2325 fs = fcgi_util_fs_get_by_id(fs_path, fcgi_util_get_server_uid(r->server),
2326 fcgi_util_get_server_gid(r->server));
2327 if (fs == NULL) {
2328 /* Its a request for a dynamic FastCGI application */
2329 const char * const err =
2330 fcgi_util_fs_is_path_ok(p, fs_path, my_finfo);
2331
2332 if (err) {
2333 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: invalid (dynamic) server \"%s\": %s", fs_path, err);
2334 return NULL;
2335 }
2336 }
2337
2338 fr->serverInputBuffer = fcgi_buf_new(p, SERVER_BUFSIZE);
2339 fr->serverOutputBuffer = fcgi_buf_new(p, SERVER_BUFSIZE);
2340 fr->clientInputBuffer = fcgi_buf_new(p, SERVER_BUFSIZE);
2341 fr->clientOutputBuffer = fcgi_buf_new(p, SERVER_BUFSIZE);
2342 fr->erBufPtr = fcgi_buf_new(p, sizeof(FCGI_EndRequestBody) + 1);
2343 fr->gotHeader = FALSE;
2344 fr->parseHeader = SCAN_CGI_READING_HEADERS;
2345 fr->header = ap_make_array(p, 1, 1);
2346 fr->fs_stderr = NULL;
2347 fr->r = r;
2348 fr->readingEndRequestBody = FALSE;
2349 fr->exitStatus = 0;
2350 fr->exitStatusSet = FALSE;
2351 fr->requestId = 1; /* anything but zero is OK here */
2352 fr->eofSent = FALSE;
2353 fr->role = FCGI_RESPONDER;
2354 fr->expectingClientContent = FALSE;
2355 fr->keepReadingFromFcgiApp = TRUE;
2356 fr->fs = fs;
2357 fr->fs_path = fs_path;
2358 fr->authHeaders = ap_make_table(p, 10);
2359 #ifdef WIN32
2360 fr->fd = INVALID_SOCKET;
2361 fr->dynamic = ((fs == NULL) || (fs->directive == APP_CLASS_DYNAMIC)) ? TRUE : FALSE;
2362 fr->using_npipe_io = FALSE;
2363 #else
2364 fr->dynamic = (fs == NULL) ? TRUE : FALSE;
2365 fr->fd = -1;
2366 #endif
2367
2368 set_uid_n_gid(r, &fr->user, &fr->group);
2369
2370 return fr;
2371 }
2372
2373 /*
2374 *----------------------------------------------------------------------
2375 *
2376 * handler --
2377 *
2378 * This routine gets called for a request that corresponds to
2379 * a FastCGI connection. It performs the request synchronously.
2380 *
2381 * Results:
2382 * Final status of request: OK or NOT_FOUND or HTTP_INTERNAL_SERVER_ERROR.
2383 *
2384 * Side effects:
2385 * Request performed.
2386 *
2387 *----------------------------------------------------------------------
2388 */
2389
2390 /* Stolen from mod_cgi.c..
2391 * KLUDGE --- for back-combatibility, we don't have to check ExecCGI
2392 * in ScriptAliased directories, which means we need to know if this
2393 * request came through ScriptAlias or not... so the Alias module
2394 * leaves a note for us.
2395 */
2396 static int apache_is_scriptaliased(request_rec *r)
2397 {
2398 const char *t = ap_table_get(r->notes, "alias-forced-type");
2399 return t && (!strcasecmp(t, "cgi-script"));
2400 }
2401
2402 /* If a script wants to produce its own Redirect body, it now
2403 * has to explicitly *say* "Status: 302". If it wants to use
2404 * Apache redirects say "Status: 200". See process_headers().
2405 */
2406 static int post_process_for_redirects(request_rec * const r,
2407 const fcgi_request * const fr)
2408 {
2409 switch(fr->parseHeader) {
2410 case SCAN_CGI_INT_REDIRECT:
2411
2412 /* @@@ There are still differences between the handling in
2413 * mod_cgi and mod_fastcgi. This needs to be revisited.
2414 */
2415 /* We already read the message body (if any), so don't allow
2416 * the redirected request to think it has one. We can ignore
2417 * Transfer-Encoding, since we used REQUEST_CHUNKED_ERROR.
2418 */
2419 r->method = "GET";
2420 r->method_number = M_GET;
2421 ap_table_unset(r->headers_in, "Content-length");
2422
2423 ap_internal_redirect_handler(ap_table_get(r->headers_out, "Location"), r);
2424 return OK;
2425
2426 case SCAN_CGI_SRV_REDIRECT:
2427 return HTTP_MOVED_TEMPORARILY;
2428
2429 default:
2430 return OK;
2431 }
2432 }
2433
2434 /******************************************************************************
2435 * Process fastcgi-script requests. Based on mod_cgi::cgi_handler().
2436 */
2437 static int content_handler(request_rec *r)
2438 {
2439 fcgi_request *fr = NULL;
2440 int ret;
2441
2442 #ifdef APACHE2
2443
2444 if (strcmp(r->handler, "fastcgi-script"))
2445 return DECLINED;
2446
2447 /* Setup a new FastCGI request */
2448 if ((fr = create_fcgi_request(r, r->filename)) == NULL)
2449 return HTTP_INTERNAL_SERVER_ERROR;
2450
2451 #else
2452
2453 /* Setup a new FastCGI request */
2454 if ((fr = create_fcgi_request(r, NULL)) == NULL)
2455 return HTTP_INTERNAL_SERVER_ERROR;
2456
2457 #endif
2458
2459 /* If its a dynamic invocation, make sure scripts are OK here */
2460 if (fr->dynamic && !(ap_allow_options(r) & OPT_EXECCGI) && !apache_is_scriptaliased(r)) {
2461 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2462 "FastCGI: \"ExecCGI Option\" is off in this directory: %s", r->uri);
2463 return HTTP_INTERNAL_SERVER_ERROR;
2464 }
2465
2466 /* Process the fastcgi-script request */
2467 if ((ret = do_work(r, fr)) != OK)
2468 return ret;
2469
2470 /* Special case redirects */
2471 ret = post_process_for_redirects(r, fr);
2472
2473 return ret;
2474 }
2475
2476
2477 static int post_process_auth_passed_header(table *t, const char *key, const char * const val)
2478 {
2479 if (strncasecmp(key, "Variable-", 9) == 0)
2480 key += 9;
2481
2482 ap_table_setn(t, key, val);
2483 return 1;
2484 }
2485
2486 static int post_process_auth_passed_compat_header(table *t, const char *key, const char * const val)
2487 {
2488 if (strncasecmp(key, "Variable-", 9) == 0)
2489 ap_table_setn(t, key + 9, val);
2490
2491 return 1;
2492 }
2493
2494 static int post_process_auth_failed_header(table * const t, const char * const key, const char * const val)
2495 {
2496 ap_table_setn(t, key, val);
2497 return 1;
2498 }
2499
2500 static void post_process_auth(fcgi_request * const fr, const int passed)
2501 {
2502 request_rec * const r = fr->r;
2503
2504 /* Restore the saved subprocess_env because we muddied ours up */
2505 r->subprocess_env = fr->saved_subprocess_env;
2506
2507 if (passed) {
2508 if (fr->auth_compat) {
2509 ap_table_do((int (*)(void *, const char *, const char *))post_process_auth_passed_compat_header,
2510 (void *)r->subprocess_env, fr->authHeaders, NULL);
2511 }
2512 else {
2513 ap_table_do((int (*)(void *, const char *, const char *))post_process_auth_passed_header,
2514 (void *)r->subprocess_env, fr->authHeaders, NULL);
2515 }
2516 }
2517 else {
2518 ap_table_do((int (*)(void *, const char *, const char *))post_process_auth_failed_header,
2519 (void *)r->err_headers_out, fr->authHeaders, NULL);
2520 }
2521
2522 /* @@@ Restore these.. its a hack until I rewrite the header handling */
2523 r->status = HTTP_OK;
2524 r->status_line = NULL;
2525 }
2526
2527 static int check_user_authentication(request_rec *r)
2528 {
2529 int res, authenticated = 0;
2530 const char *password;
2531 fcgi_request *fr;
2532 const fcgi_dir_config * const dir_config =
2533 (const fcgi_dir_config *)ap_get_module_config(r->per_dir_config, &fastcgi_module);
2534
2535 if (dir_config->authenticator == NULL)
2536 return DECLINED;
2537
2538 /* Get the user password */
2539 if ((res = ap_get_basic_auth_pw(r, &password)) != OK)
2540 return res;
2541
2542 if ((fr = create_fcgi_request(r, dir_config->authenticator)) == NULL)
2543 return HTTP_INTERNAL_SERVER_ERROR;
2544
2545 /* Save the existing subprocess_env, because we're gonna muddy it up */
2546 fr->saved_subprocess_env = ap_copy_table(r->pool, r->subprocess_env);
2547
2548 ap_table_setn(r->subprocess_env, "REMOTE_PASSWD", password);
2549 ap_table_setn(r->subprocess_env, "FCGI_APACHE_ROLE", "AUTHENTICATOR");
2550
2551 /* The FastCGI Protocol doesn't differentiate authentication */
2552 fr->role = FCGI_AUTHORIZER;
2553
2554 /* Do we need compatibility mode? */
2555 fr->auth_compat = (dir_config->authenticator_options & FCGI_COMPAT);
2556
2557 if ((res = do_work(r, fr)) != OK)
2558 goto AuthenticationFailed;
2559
2560 authenticated = (r->status == 200);
2561 post_process_auth(fr, authenticated);
2562
2563 /* A redirect shouldn't be allowed during the authentication phase */
2564 if (ap_table_get(r->headers_out, "Location") != NULL) {
2565 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2566 "FastCGI: FastCgiAuthenticator \"%s\" redirected (not allowed)",
2567 dir_config->authenticator);
2568 goto AuthenticationFailed;
2569 }
2570
2571 if (authenticated)
2572 return OK;
2573
2574 AuthenticationFailed:
2575 if (!(dir_config->authenticator_options & FCGI_AUTHORITATIVE))
2576 return DECLINED;
2577
2578 /* @@@ Probably should support custom_responses */
2579 ap_note_basic_auth_failure(r);
2580 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2581 "FastCGI: authentication failed for user \"%s\": %s",
2582 #ifdef APACHE2
2583 r->user, r->uri);
2584 #else
2585 r->connection->user, r->uri);
2586 #endif
2587
2588 return (res == OK) ? HTTP_UNAUTHORIZED : res;
2589 }
2590
2591 static int check_user_authorization(request_rec *r)
2592 {
2593 int res, authorized = 0;
2594 fcgi_request *fr;
2595 const fcgi_dir_config * const dir_config =
2596 (const fcgi_dir_config *)ap_get_module_config(r->per_dir_config, &fastcgi_module);
2597
2598 if (dir_config->authorizer == NULL)
2599 return DECLINED;
2600
2601 /* @@@ We should probably honor the existing parameters to the require directive
2602 * as well as allow the definition of new ones (or use the basename of the
2603 * FastCGI server and pass the rest of the directive line), but for now keep
2604 * it simple. */
2605
2606 if ((fr = create_fcgi_request(r, dir_config->authorizer)) == NULL)
2607 return HTTP_INTERNAL_SERVER_ERROR;
2608
2609 /* Save the existing subprocess_env, because we're gonna muddy it up */
2610 fr->saved_subprocess_env = ap_copy_table(r->pool, r->subprocess_env);
2611
2612 ap_table_setn(r->subprocess_env, "FCGI_APACHE_ROLE", "AUTHORIZER");
2613
2614 fr->role = FCGI_AUTHORIZER;
2615
2616 /* Do we need compatibility mode? */
2617 fr->auth_compat = (dir_config->authenticator_options & FCGI_COMPAT);
2618
2619 if ((res = do_work(r, fr)) != OK)
2620 goto AuthorizationFailed;
2621
2622 authorized = (r->status == 200);
2623 post_process_auth(fr, authorized);
2624
2625 /* A redirect shouldn't be allowed during the authorization phase */
2626 if (ap_table_get(r->headers_out, "Location") != NULL) {
2627 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2628 "FastCGI: FastCgiAuthorizer \"%s\" redirected (not allowed)",
2629 dir_config->authorizer);
2630 goto AuthorizationFailed;
2631 }
2632
2633 if (authorized)
2634 return OK;
2635
2636 AuthorizationFailed:
2637 if (!(dir_config->authorizer_options & FCGI_AUTHORITATIVE))
2638 return DECLINED;
2639
2640 /* @@@ Probably should support custom_responses */
2641 ap_note_basic_auth_failure(r);
2642 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2643 "FastCGI: authorization failed for user \"%s\": %s",
2644 #ifdef APACHE2
2645 r->user, r->uri);
2646 #else
2647 r->connection->user, r->uri);
2648 #endif
2649
2650 return (res == OK) ? HTTP_UNAUTHORIZED : res;
2651 }
2652
2653 static int check_access(request_rec *r)
2654 {
2655 int res, access_allowed = 0;
2656 fcgi_request *fr;
2657 const fcgi_dir_config * const dir_config =
2658 (fcgi_dir_config *)ap_get_module_config(r->per_dir_config, &fastcgi_module);
2659
2660 if (dir_config == NULL || dir_config->access_checker == NULL)
2661 return DECLINED;
2662
2663 if ((fr = create_fcgi_request(r, dir_config->access_checker)) == NULL)
2664 return HTTP_INTERNAL_SERVER_ERROR;
2665
2666 /* Save the existing subprocess_env, because we're gonna muddy it up */
2667 fr->saved_subprocess_env = ap_copy_table(r->pool, r->subprocess_env);
2668
2669 ap_table_setn(r->subprocess_env, "FCGI_APACHE_ROLE", "ACCESS_CHECKER");
2670
2671 /* The FastCGI Protocol doesn't differentiate access control */
2672 fr->role = FCGI_AUTHORIZER;
2673
2674 /* Do we need compatibility mode? */
2675 fr->auth_compat = (dir_config->authenticator_options & FCGI_COMPAT);
2676
2677 if ((res = do_work(r, fr)) != OK)
2678 goto AccessFailed;
2679
2680 access_allowed = (r->status == 200);
2681 post_process_auth(fr, access_allowed);
2682
2683 /* A redirect shouldn't be allowed during the access check phase */
2684 if (ap_table_get(r->headers_out, "Location") != NULL) {
2685 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r,
2686 "FastCGI: FastCgiAccessChecker \"%s\" redirected (not allowed)",
2687 dir_config->access_checker);
2688 goto AccessFailed;
2689 }
2690
2691 if (access_allowed)
2692 return OK;
2693
2694 AccessFailed:
2695 if (!(dir_config->access_checker_options & FCGI_AUTHORITATIVE))
2696 return DECLINED;
2697
2698 /* @@@ Probably should support custom_responses */
2699 ap_log_rerror(FCGI_LOG_ERR_NOERRNO, r, "FastCGI: access denied: %s", r->uri);
2700 return (res == OK) ? HTTP_FORBIDDEN : res;
2701 }
2702
2703 #ifndef APACHE2
2704
2705 # define AP_INIT_RAW_ARGS(directive, func, mconfig, where, help) \
2706 { directive, func, mconfig, where, RAW_ARGS, help }
2707 # define AP_INIT_TAKE1(directive, func, mconfig, where, help) \
2708 { directive, func, mconfig, where, TAKE1, help }
2709 # define AP_INIT_TAKE12(directive, func, mconfig, where, help) \
2710 { directive, func, mconfig, where, TAKE12, help }
2711 # define AP_INIT_FLAG(directive, func, mconfig, where, help) \
2712 { directive, func, mconfig, where, FLAG, help }
2713
2714 #endif
2715
2716 static const command_rec fastcgi_cmds[] =
2717 {
2718 AP_INIT_RAW_ARGS("AppClass", fcgi_config_new_static_server, NULL, RSRC_CONF, NULL),
2719 AP_INIT_RAW_ARGS("FastCgiServer", fcgi_config_new_static_server, NULL, RSRC_CONF, NULL),
2720
2721 AP_INIT_RAW_ARGS("ExternalAppClass", fcgi_config_new_external_server, NULL, RSRC_CONF, NULL),
2722 AP_INIT_RAW_ARGS("FastCgiExternalServer", fcgi_config_new_external_server, NULL, RSRC_CONF, NULL),
2723
2724 AP_INIT_TAKE1("FastCgiIpcDir", fcgi_config_set_socket_dir, NULL, RSRC_CONF, NULL),
2725
2726 AP_INIT_TAKE1("FastCgiSuexec", fcgi_config_set_wrapper, NULL, RSRC_CONF, NULL),
2727 AP_INIT_TAKE1("FastCgiWrapper", fcgi_config_set_wrapper, NULL, RSRC_CONF, NULL),
2728
2729 AP_INIT_RAW_ARGS("FCGIConfig", fcgi_config_set_config, NULL, RSRC_CONF, NULL),
2730 AP_INIT_RAW_ARGS("FastCgiConfig", fcgi_config_set_config, NULL, RSRC_CONF, NULL),
2731
2732 AP_INIT_TAKE12("FastCgiAuthenticator", fcgi_config_new_auth_server,
2733 (void *)FCGI_AUTH_TYPE_AUTHENTICATOR, ACCESS_CONF,
2734 "a fastcgi-script path (absolute or relative to ServerRoot) followed by an optional -compat"),
2735 AP_INIT_FLAG("FastCgiAuthenticatorAuthoritative", fcgi_config_set_authoritative_slot,
2736 (void *)XtOffsetOf(fcgi_dir_config, authenticator_options), ACCESS_CONF,
2737 "Set to 'off' to allow authentication to be passed along to lower modules upon failure"),
2738
2739 AP_INIT_TAKE12("FastCgiAuthorizer", fcgi_config_new_auth_server,
2740 (void *)FCGI_AUTH_TYPE_AUTHORIZER, ACCESS_CONF,
2741 "a fastcgi-script path (absolute or relative to ServerRoot) followed by an optional -compat"),
2742 AP_INIT_FLAG("FastCgiAuthorizerAuthoritative", fcgi_config_set_authoritative_slot,
2743 (void *)XtOffsetOf(fcgi_dir_config, authorizer_options), ACCESS_CONF,
2744 "Set to 'off' to allow authorization to be passed along to lower modules upon failure"),
2745
2746 AP_INIT_TAKE12("FastCgiAccessChecker", fcgi_config_new_auth_server,
2747 (void *)FCGI_AUTH_TYPE_ACCESS_CHECKER, ACCESS_CONF,
2748 "a fastcgi-script path (absolute or relative to ServerRoot) followed by an optional -compat"),
2749 AP_INIT_FLAG("FastCgiAccessCheckerAuthoritative", fcgi_config_set_authoritative_slot,
2750 (void *)XtOffsetOf(fcgi_dir_config, access_checker_options), ACCESS_CONF,
2751 "Set to 'off' to allow access control to be passed along to lower modules upon failure"),
2752 { NULL }
2753 };
2754
2755 #ifdef APACHE2
2756
2757 static void register_hooks(apr_pool_t * p)
2758 {
2759 // ap_hook_pre_config(x_pre_config, NULL, NULL, APR_HOOK_MIDDLE);
2760 ap_hook_post_config(init_module, NULL, NULL, APR_HOOK_MIDDLE);
2761 ap_hook_child_init(fcgi_child_init, NULL, NULL, APR_HOOK_MIDDLE);
2762 ap_hook_handler(content_handler, NULL, NULL, APR_HOOK_MIDDLE);
2763 ap_hook_check_user_id(check_user_authentication, NULL, NULL, APR_HOOK_MIDDLE);
2764 ap_hook_access_checker(check_access, NULL, NULL, APR_HOOK_MIDDLE);
2765 ap_hook_auth_checker(check_user_authorization, NULL, NULL, APR_HOOK_MIDDLE);
2766 }
2767
2768 module AP_MODULE_DECLARE_DATA fastcgi_module =
2769 {
2770 STANDARD20_MODULE_STUFF,
2771 fcgi_config_create_dir_config, /* per-directory config creator */
2772 NULL, /* dir config merger */
2773 NULL, /* server config creator */
2774 NULL, /* server config merger */
2775 fastcgi_cmds, /* command table */
2776 register_hooks, /* set up other request processing hooks */
2777 };
2778
2779 #else /* !APACHE2 */
2780
2781 handler_rec fastcgi_handlers[] = {
2782 { FCGI_MAGIC_TYPE, content_handler },
2783 { "fastcgi-script", content_handler },
2784 { NULL }
2785 };
2786
2787 module MODULE_VAR_EXPORT fastcgi_module = {
2788 STANDARD_MODULE_STUFF,
2789 init_module, /* initializer */
2790 fcgi_config_create_dir_config, /* per-dir config creator */
2791 NULL, /* per-dir config merger (default: override) */
2792 NULL, /* per-server config creator */
2793 NULL, /* per-server config merger (default: override) */
2794 fastcgi_cmds, /* command table */
2795 fastcgi_handlers, /* [9] content handlers */
2796 NULL, /* [2] URI-to-filename translation */
2797 check_user_authentication, /* [5] authenticate user_id */
2798 check_user_authorization, /* [6] authorize user_id */
2799 check_access, /* [4] check access (based on src & http headers) */
2800 NULL, /* [7] check/set MIME type */
2801 NULL, /* [8] fixups */
2802 NULL, /* [10] logger */
2803 NULL, /* [3] header-parser */
2804 fcgi_child_init, /* process initialization */
2805 fcgi_child_exit, /* process exit/cleanup */
2806 NULL /* [1] post read-request handling */
2807 };
2808
2809 #endif /* !APACHE2 */
FastCGI Apache module