Annotation of embedaddon/lighttpd/src/mod_fastcgi.c, revision 1.1
1.1 ! misho 1: #include "buffer.h"
! 2: #include "server.h"
! 3: #include "keyvalue.h"
! 4: #include "log.h"
! 5:
! 6: #include "http_chunk.h"
! 7: #include "fdevent.h"
! 8: #include "connections.h"
! 9: #include "response.h"
! 10: #include "joblist.h"
! 11:
! 12: #include "plugin.h"
! 13:
! 14: #include "inet_ntop_cache.h"
! 15: #include "stat_cache.h"
! 16: #include "status_counter.h"
! 17:
! 18: #include <sys/types.h>
! 19: #include <unistd.h>
! 20: #include <errno.h>
! 21: #include <fcntl.h>
! 22: #include <string.h>
! 23: #include <stdlib.h>
! 24: #include <ctype.h>
! 25: #include <assert.h>
! 26: #include <signal.h>
! 27:
! 28: #ifdef HAVE_FASTCGI_FASTCGI_H
! 29: # include <fastcgi/fastcgi.h>
! 30: #else
! 31: # ifdef HAVE_FASTCGI_H
! 32: # include <fastcgi.h>
! 33: # else
! 34: # include "fastcgi.h"
! 35: # endif
! 36: #endif /* HAVE_FASTCGI_FASTCGI_H */
! 37:
! 38: #include <stdio.h>
! 39:
! 40: #ifdef HAVE_SYS_FILIO_H
! 41: # include <sys/filio.h>
! 42: #endif
! 43:
! 44: #include "sys-socket.h"
! 45:
! 46: #ifdef HAVE_SYS_UIO_H
! 47: #include <sys/uio.h>
! 48: #endif
! 49: #ifdef HAVE_SYS_WAIT_H
! 50: #include <sys/wait.h>
! 51: #endif
! 52:
! 53: #include "version.h"
! 54:
! 55: #define FCGI_ENV_ADD_CHECK(ret, con) \
! 56: if (ret == -1) { \
! 57: con->http_status = 400; \
! 58: con->file_finished = 1; \
! 59: return -1; \
! 60: };
! 61:
! 62: /*
! 63: *
! 64: * TODO:
! 65: *
! 66: * - add timeout for a connect to a non-fastcgi process
! 67: * (use state_timestamp + state)
! 68: *
! 69: */
! 70:
! 71: typedef struct fcgi_proc {
! 72: size_t id; /* id will be between 1 and max_procs */
! 73: buffer *unixsocket; /* config.socket + "-" + id */
! 74: unsigned port; /* config.port + pno */
! 75:
! 76: buffer *connection_name; /* either tcp:<host>:<port> or unix:<socket> for debugging purposes */
! 77:
! 78: pid_t pid; /* PID of the spawned process (0 if not spawned locally) */
! 79:
! 80:
! 81: size_t load; /* number of requests waiting on this process */
! 82:
! 83: size_t requests; /* see max_requests */
! 84: struct fcgi_proc *prev, *next; /* see first */
! 85:
! 86: time_t disabled_until; /* this proc is disabled until, use something else until then */
! 87:
! 88: int is_local;
! 89:
! 90: enum {
! 91: PROC_STATE_UNSET, /* init-phase */
! 92: PROC_STATE_RUNNING, /* alive */
! 93: PROC_STATE_OVERLOADED, /* listen-queue is full,
! 94: don't send anything to this proc for the next 2 seconds */
! 95: PROC_STATE_DIED_WAIT_FOR_PID, /* */
! 96: PROC_STATE_DIED, /* marked as dead, should be restarted */
! 97: PROC_STATE_KILLED /* was killed as we don't have the load anymore */
! 98: } state;
! 99: } fcgi_proc;
! 100:
! 101: typedef struct {
! 102: /* the key that is used to reference this value */
! 103: buffer *id;
! 104:
! 105: /* list of processes handling this extension
! 106: * sorted by lowest load
! 107: *
! 108: * whenever a job is done move it up in the list
! 109: * until it is sorted, move it down as soon as the
! 110: * job is started
! 111: */
! 112: fcgi_proc *first;
! 113: fcgi_proc *unused_procs;
! 114:
! 115: /*
! 116: * spawn at least min_procs, at max_procs.
! 117: *
! 118: * as soon as the load of the first entry
! 119: * is max_load_per_proc we spawn a new one
! 120: * and add it to the first entry and give it
! 121: * the load
! 122: *
! 123: */
! 124:
! 125: unsigned short max_procs;
! 126: size_t num_procs; /* how many procs are started */
! 127: size_t active_procs; /* how many of them are really running, i.e. state = PROC_STATE_RUNNING */
! 128:
! 129: /*
! 130: * time after a disabled remote connection is tried to be re-enabled
! 131: *
! 132: *
! 133: */
! 134:
! 135: unsigned short disable_time;
! 136:
! 137: /*
! 138: * some fastcgi processes get a little bit larger
! 139: * than wanted. max_requests_per_proc kills a
! 140: * process after a number of handled requests.
! 141: *
! 142: */
! 143: size_t max_requests_per_proc;
! 144:
! 145:
! 146: /* config */
! 147:
! 148: /*
! 149: * host:port
! 150: *
! 151: * if host is one of the local IP adresses the
! 152: * whole connection is local
! 153: *
! 154: * if port is not 0, and host is not specified,
! 155: * "localhost" (INADDR_LOOPBACK) is assumed.
! 156: *
! 157: */
! 158: buffer *host;
! 159: unsigned short port;
! 160:
! 161: /*
! 162: * Unix Domain Socket
! 163: *
! 164: * instead of TCP/IP we can use Unix Domain Sockets
! 165: * - more secure (you have fileperms to play with)
! 166: * - more control (on locally)
! 167: * - more speed (no extra overhead)
! 168: */
! 169: buffer *unixsocket;
! 170:
! 171: /* if socket is local we can start the fastcgi
! 172: * process ourself
! 173: *
! 174: * bin-path is the path to the binary
! 175: *
! 176: * check min_procs and max_procs for the number
! 177: * of process to start up
! 178: */
! 179: buffer *bin_path;
! 180:
! 181: /* bin-path is set bin-environment is taken to
! 182: * create the environement before starting the
! 183: * FastCGI process
! 184: *
! 185: */
! 186: array *bin_env;
! 187:
! 188: array *bin_env_copy;
! 189:
! 190: /*
! 191: * docroot-translation between URL->phys and the
! 192: * remote host
! 193: *
! 194: * reasons:
! 195: * - different dir-layout if remote
! 196: * - chroot if local
! 197: *
! 198: */
! 199: buffer *docroot;
! 200:
! 201: /*
! 202: * fastcgi-mode:
! 203: * - responser
! 204: * - authorizer
! 205: *
! 206: */
! 207: unsigned short mode;
! 208:
! 209: /*
! 210: * check_local tells you if the phys file is stat()ed
! 211: * or not. FastCGI doesn't care if the service is
! 212: * remote. If the web-server side doesn't contain
! 213: * the fastcgi-files we should not stat() for them
! 214: * and say '404 not found'.
! 215: */
! 216: unsigned short check_local;
! 217:
! 218: /*
! 219: * append PATH_INFO to SCRIPT_FILENAME
! 220: *
! 221: * php needs this if cgi.fix_pathinfo is provided
! 222: *
! 223: */
! 224:
! 225: unsigned short break_scriptfilename_for_php;
! 226:
! 227: /*
! 228: * workaround for program when prefix="/"
! 229: *
! 230: * rule to build PATH_INFO is hardcoded for when check_local is disabled
! 231: * enable this option to use the workaround
! 232: *
! 233: */
! 234:
! 235: unsigned short fix_root_path_name;
! 236:
! 237: /*
! 238: * If the backend includes X-LIGHTTPD-send-file in the response
! 239: * we use the value as filename and ignore the content.
! 240: *
! 241: */
! 242: unsigned short allow_xsendfile;
! 243:
! 244: ssize_t load; /* replace by host->load */
! 245:
! 246: size_t max_id; /* corresponds most of the time to
! 247: num_procs.
! 248:
! 249: only if a process is killed max_id waits for the process itself
! 250: to die and decrements it afterwards */
! 251:
! 252: buffer *strip_request_uri;
! 253:
! 254: unsigned short kill_signal; /* we need a setting for this as libfcgi
! 255: applications prefer SIGUSR1 while the
! 256: rest of the world would use SIGTERM
! 257: *sigh* */
! 258: } fcgi_extension_host;
! 259:
! 260: /*
! 261: * one extension can have multiple hosts assigned
! 262: * one host can spawn additional processes on the same
! 263: * socket (if we control it)
! 264: *
! 265: * ext -> host -> procs
! 266: * 1:n 1:n
! 267: *
! 268: * if the fastcgi process is remote that whole goes down
! 269: * to
! 270: *
! 271: * ext -> host -> procs
! 272: * 1:n 1:1
! 273: *
! 274: * in case of PHP and FCGI_CHILDREN we have again a procs
! 275: * but we don't control it directly.
! 276: *
! 277: */
! 278:
! 279: typedef struct {
! 280: buffer *key; /* like .php */
! 281:
! 282: int note_is_sent;
! 283: int last_used_ndx;
! 284:
! 285: fcgi_extension_host **hosts;
! 286:
! 287: size_t used;
! 288: size_t size;
! 289: } fcgi_extension;
! 290:
! 291: typedef struct {
! 292: fcgi_extension **exts;
! 293:
! 294: size_t used;
! 295: size_t size;
! 296: } fcgi_exts;
! 297:
! 298:
! 299: typedef struct {
! 300: fcgi_exts *exts;
! 301:
! 302: array *ext_mapping;
! 303:
! 304: unsigned int debug;
! 305: } plugin_config;
! 306:
! 307: typedef struct {
! 308: char **ptr;
! 309:
! 310: size_t size;
! 311: size_t used;
! 312: } char_array;
! 313:
! 314: /* generic plugin data, shared between all connections */
! 315: typedef struct {
! 316: PLUGIN_DATA;
! 317:
! 318: buffer *fcgi_env;
! 319:
! 320: buffer *path;
! 321: buffer *parse_response;
! 322:
! 323: buffer *statuskey;
! 324:
! 325: plugin_config **config_storage;
! 326:
! 327: plugin_config conf; /* this is only used as long as no handler_ctx is setup */
! 328: } plugin_data;
! 329:
! 330: /* connection specific data */
! 331: typedef enum {
! 332: FCGI_STATE_UNSET,
! 333: FCGI_STATE_INIT,
! 334: FCGI_STATE_CONNECT_DELAYED,
! 335: FCGI_STATE_PREPARE_WRITE,
! 336: FCGI_STATE_WRITE,
! 337: FCGI_STATE_READ
! 338: } fcgi_connection_state_t;
! 339:
! 340: typedef struct {
! 341: fcgi_proc *proc;
! 342: fcgi_extension_host *host;
! 343: fcgi_extension *ext;
! 344:
! 345: fcgi_connection_state_t state;
! 346: time_t state_timestamp;
! 347:
! 348: int reconnects; /* number of reconnect attempts */
! 349:
! 350: chunkqueue *rb; /* read queue */
! 351: chunkqueue *wb; /* write queue */
! 352:
! 353: buffer *response_header;
! 354:
! 355: size_t request_id;
! 356: int fd; /* fd to the fastcgi process */
! 357: int fde_ndx; /* index into the fd-event buffer */
! 358:
! 359: pid_t pid;
! 360: int got_proc;
! 361:
! 362: int send_content_body;
! 363:
! 364: plugin_config conf;
! 365:
! 366: connection *remote_conn; /* dumb pointer */
! 367: plugin_data *plugin_data; /* dumb pointer */
! 368: } handler_ctx;
! 369:
! 370:
! 371: /* ok, we need a prototype */
! 372: static handler_t fcgi_handle_fdevent(server *srv, void *ctx, int revents);
! 373:
! 374: static void reset_signals(void) {
! 375: #ifdef SIGTTOU
! 376: signal(SIGTTOU, SIG_DFL);
! 377: #endif
! 378: #ifdef SIGTTIN
! 379: signal(SIGTTIN, SIG_DFL);
! 380: #endif
! 381: #ifdef SIGTSTP
! 382: signal(SIGTSTP, SIG_DFL);
! 383: #endif
! 384: signal(SIGHUP, SIG_DFL);
! 385: signal(SIGPIPE, SIG_DFL);
! 386: signal(SIGUSR1, SIG_DFL);
! 387: }
! 388:
! 389: static void fastcgi_status_copy_procname(buffer *b, fcgi_extension_host *host, fcgi_proc *proc) {
! 390: buffer_copy_string_len(b, CONST_STR_LEN("fastcgi.backend."));
! 391: buffer_append_string_buffer(b, host->id);
! 392: if (proc) {
! 393: buffer_append_string_len(b, CONST_STR_LEN("."));
! 394: buffer_append_long(b, proc->id);
! 395: }
! 396: }
! 397:
! 398: static void fcgi_proc_load_inc(server *srv, handler_ctx *hctx) {
! 399: plugin_data *p = hctx->plugin_data;
! 400: hctx->proc->load++;
! 401:
! 402: status_counter_inc(srv, CONST_STR_LEN("fastcgi.active-requests"));
! 403:
! 404: fastcgi_status_copy_procname(p->statuskey, hctx->host, hctx->proc);
! 405: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".load"));
! 406:
! 407: status_counter_set(srv, CONST_BUF_LEN(p->statuskey), hctx->proc->load);
! 408: }
! 409:
! 410: static void fcgi_proc_load_dec(server *srv, handler_ctx *hctx) {
! 411: plugin_data *p = hctx->plugin_data;
! 412: hctx->proc->load--;
! 413:
! 414: status_counter_dec(srv, CONST_STR_LEN("fastcgi.active-requests"));
! 415:
! 416: fastcgi_status_copy_procname(p->statuskey, hctx->host, hctx->proc);
! 417: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".load"));
! 418:
! 419: status_counter_set(srv, CONST_BUF_LEN(p->statuskey), hctx->proc->load);
! 420: }
! 421:
! 422: static void fcgi_host_assign(server *srv, handler_ctx *hctx, fcgi_extension_host *host) {
! 423: plugin_data *p = hctx->plugin_data;
! 424: hctx->host = host;
! 425: hctx->host->load++;
! 426:
! 427: fastcgi_status_copy_procname(p->statuskey, hctx->host, NULL);
! 428: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".load"));
! 429:
! 430: status_counter_set(srv, CONST_BUF_LEN(p->statuskey), hctx->host->load);
! 431: }
! 432:
! 433: static void fcgi_host_reset(server *srv, handler_ctx *hctx) {
! 434: plugin_data *p = hctx->plugin_data;
! 435: hctx->host->load--;
! 436:
! 437: fastcgi_status_copy_procname(p->statuskey, hctx->host, NULL);
! 438: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".load"));
! 439:
! 440: status_counter_set(srv, CONST_BUF_LEN(p->statuskey), hctx->host->load);
! 441:
! 442: hctx->host = NULL;
! 443: }
! 444:
! 445: static void fcgi_host_disable(server *srv, handler_ctx *hctx) {
! 446: plugin_data *p = hctx->plugin_data;
! 447:
! 448: if (hctx->host->disable_time || hctx->proc->is_local) {
! 449: if (hctx->proc->state == PROC_STATE_RUNNING) hctx->host->active_procs--;
! 450: hctx->proc->disabled_until = srv->cur_ts + hctx->host->disable_time;
! 451: hctx->proc->state = hctx->proc->is_local ? PROC_STATE_DIED_WAIT_FOR_PID : PROC_STATE_DIED;
! 452:
! 453: if (p->conf.debug) {
! 454: log_error_write(srv, __FILE__, __LINE__, "sds",
! 455: "backend disabled for", hctx->host->disable_time, "seconds");
! 456: }
! 457: }
! 458: }
! 459:
! 460: static int fastcgi_status_init(server *srv, buffer *b, fcgi_extension_host *host, fcgi_proc *proc) {
! 461: #define CLEAN(x) \
! 462: fastcgi_status_copy_procname(b, host, proc); \
! 463: buffer_append_string_len(b, CONST_STR_LEN(x)); \
! 464: status_counter_set(srv, CONST_BUF_LEN(b), 0);
! 465:
! 466: CLEAN(".disabled");
! 467: CLEAN(".died");
! 468: CLEAN(".overloaded");
! 469: CLEAN(".connected");
! 470: CLEAN(".load");
! 471:
! 472: #undef CLEAN
! 473:
! 474: #define CLEAN(x) \
! 475: fastcgi_status_copy_procname(b, host, NULL); \
! 476: buffer_append_string_len(b, CONST_STR_LEN(x)); \
! 477: status_counter_set(srv, CONST_BUF_LEN(b), 0);
! 478:
! 479: CLEAN(".load");
! 480:
! 481: #undef CLEAN
! 482:
! 483: return 0;
! 484: }
! 485:
! 486: static handler_ctx * handler_ctx_init(void) {
! 487: handler_ctx * hctx;
! 488:
! 489: hctx = calloc(1, sizeof(*hctx));
! 490: assert(hctx);
! 491:
! 492: hctx->fde_ndx = -1;
! 493:
! 494: hctx->response_header = buffer_init();
! 495:
! 496: hctx->request_id = 0;
! 497: hctx->state = FCGI_STATE_INIT;
! 498: hctx->proc = NULL;
! 499:
! 500: hctx->fd = -1;
! 501:
! 502: hctx->reconnects = 0;
! 503: hctx->send_content_body = 1;
! 504:
! 505: hctx->rb = chunkqueue_init();
! 506: hctx->wb = chunkqueue_init();
! 507:
! 508: return hctx;
! 509: }
! 510:
! 511: static void handler_ctx_free(server *srv, handler_ctx *hctx) {
! 512: if (hctx->host) {
! 513: fcgi_host_reset(srv, hctx);
! 514: }
! 515:
! 516: buffer_free(hctx->response_header);
! 517:
! 518: chunkqueue_free(hctx->rb);
! 519: chunkqueue_free(hctx->wb);
! 520:
! 521: free(hctx);
! 522: }
! 523:
! 524: static fcgi_proc *fastcgi_process_init(void) {
! 525: fcgi_proc *f;
! 526:
! 527: f = calloc(1, sizeof(*f));
! 528: f->unixsocket = buffer_init();
! 529: f->connection_name = buffer_init();
! 530:
! 531: f->prev = NULL;
! 532: f->next = NULL;
! 533:
! 534: return f;
! 535: }
! 536:
! 537: static void fastcgi_process_free(fcgi_proc *f) {
! 538: if (!f) return;
! 539:
! 540: fastcgi_process_free(f->next);
! 541:
! 542: buffer_free(f->unixsocket);
! 543: buffer_free(f->connection_name);
! 544:
! 545: free(f);
! 546: }
! 547:
! 548: static fcgi_extension_host *fastcgi_host_init(void) {
! 549: fcgi_extension_host *f;
! 550:
! 551: f = calloc(1, sizeof(*f));
! 552:
! 553: f->id = buffer_init();
! 554: f->host = buffer_init();
! 555: f->unixsocket = buffer_init();
! 556: f->docroot = buffer_init();
! 557: f->bin_path = buffer_init();
! 558: f->bin_env = array_init();
! 559: f->bin_env_copy = array_init();
! 560: f->strip_request_uri = buffer_init();
! 561:
! 562: return f;
! 563: }
! 564:
! 565: static void fastcgi_host_free(fcgi_extension_host *h) {
! 566: if (!h) return;
! 567:
! 568: buffer_free(h->id);
! 569: buffer_free(h->host);
! 570: buffer_free(h->unixsocket);
! 571: buffer_free(h->docroot);
! 572: buffer_free(h->bin_path);
! 573: buffer_free(h->strip_request_uri);
! 574: array_free(h->bin_env);
! 575: array_free(h->bin_env_copy);
! 576:
! 577: fastcgi_process_free(h->first);
! 578: fastcgi_process_free(h->unused_procs);
! 579:
! 580: free(h);
! 581:
! 582: }
! 583:
! 584: static fcgi_exts *fastcgi_extensions_init(void) {
! 585: fcgi_exts *f;
! 586:
! 587: f = calloc(1, sizeof(*f));
! 588:
! 589: return f;
! 590: }
! 591:
! 592: static void fastcgi_extensions_free(fcgi_exts *f) {
! 593: size_t i;
! 594:
! 595: if (!f) return;
! 596:
! 597: for (i = 0; i < f->used; i++) {
! 598: fcgi_extension *fe;
! 599: size_t j;
! 600:
! 601: fe = f->exts[i];
! 602:
! 603: for (j = 0; j < fe->used; j++) {
! 604: fcgi_extension_host *h;
! 605:
! 606: h = fe->hosts[j];
! 607:
! 608: fastcgi_host_free(h);
! 609: }
! 610:
! 611: buffer_free(fe->key);
! 612: free(fe->hosts);
! 613:
! 614: free(fe);
! 615: }
! 616:
! 617: free(f->exts);
! 618:
! 619: free(f);
! 620: }
! 621:
! 622: static int fastcgi_extension_insert(fcgi_exts *ext, buffer *key, fcgi_extension_host *fh) {
! 623: fcgi_extension *fe;
! 624: size_t i;
! 625:
! 626: /* there is something */
! 627:
! 628: for (i = 0; i < ext->used; i++) {
! 629: if (buffer_is_equal(key, ext->exts[i]->key)) {
! 630: break;
! 631: }
! 632: }
! 633:
! 634: if (i == ext->used) {
! 635: /* filextension is new */
! 636: fe = calloc(1, sizeof(*fe));
! 637: assert(fe);
! 638: fe->key = buffer_init();
! 639: fe->last_used_ndx = -1;
! 640: buffer_copy_string_buffer(fe->key, key);
! 641:
! 642: /* */
! 643:
! 644: if (ext->size == 0) {
! 645: ext->size = 8;
! 646: ext->exts = malloc(ext->size * sizeof(*(ext->exts)));
! 647: assert(ext->exts);
! 648: } else if (ext->used == ext->size) {
! 649: ext->size += 8;
! 650: ext->exts = realloc(ext->exts, ext->size * sizeof(*(ext->exts)));
! 651: assert(ext->exts);
! 652: }
! 653: ext->exts[ext->used++] = fe;
! 654: } else {
! 655: fe = ext->exts[i];
! 656: }
! 657:
! 658: if (fe->size == 0) {
! 659: fe->size = 4;
! 660: fe->hosts = malloc(fe->size * sizeof(*(fe->hosts)));
! 661: assert(fe->hosts);
! 662: } else if (fe->size == fe->used) {
! 663: fe->size += 4;
! 664: fe->hosts = realloc(fe->hosts, fe->size * sizeof(*(fe->hosts)));
! 665: assert(fe->hosts);
! 666: }
! 667:
! 668: fe->hosts[fe->used++] = fh;
! 669:
! 670: return 0;
! 671:
! 672: }
! 673:
! 674: INIT_FUNC(mod_fastcgi_init) {
! 675: plugin_data *p;
! 676:
! 677: p = calloc(1, sizeof(*p));
! 678:
! 679: p->fcgi_env = buffer_init();
! 680:
! 681: p->path = buffer_init();
! 682: p->parse_response = buffer_init();
! 683:
! 684: p->statuskey = buffer_init();
! 685:
! 686: return p;
! 687: }
! 688:
! 689:
! 690: FREE_FUNC(mod_fastcgi_free) {
! 691: plugin_data *p = p_d;
! 692:
! 693: UNUSED(srv);
! 694:
! 695: buffer_free(p->fcgi_env);
! 696: buffer_free(p->path);
! 697: buffer_free(p->parse_response);
! 698: buffer_free(p->statuskey);
! 699:
! 700: if (p->config_storage) {
! 701: size_t i, j, n;
! 702: for (i = 0; i < srv->config_context->used; i++) {
! 703: plugin_config *s = p->config_storage[i];
! 704: fcgi_exts *exts;
! 705:
! 706: if (!s) continue;
! 707:
! 708: exts = s->exts;
! 709:
! 710: for (j = 0; j < exts->used; j++) {
! 711: fcgi_extension *ex;
! 712:
! 713: ex = exts->exts[j];
! 714:
! 715: for (n = 0; n < ex->used; n++) {
! 716: fcgi_proc *proc;
! 717: fcgi_extension_host *host;
! 718:
! 719: host = ex->hosts[n];
! 720:
! 721: for (proc = host->first; proc; proc = proc->next) {
! 722: if (proc->pid != 0) {
! 723: kill(proc->pid, host->kill_signal);
! 724: }
! 725:
! 726: if (proc->is_local &&
! 727: !buffer_is_empty(proc->unixsocket)) {
! 728: unlink(proc->unixsocket->ptr);
! 729: }
! 730: }
! 731:
! 732: for (proc = host->unused_procs; proc; proc = proc->next) {
! 733: if (proc->pid != 0) {
! 734: kill(proc->pid, host->kill_signal);
! 735: }
! 736: if (proc->is_local &&
! 737: !buffer_is_empty(proc->unixsocket)) {
! 738: unlink(proc->unixsocket->ptr);
! 739: }
! 740: }
! 741: }
! 742: }
! 743:
! 744: fastcgi_extensions_free(s->exts);
! 745: array_free(s->ext_mapping);
! 746:
! 747: free(s);
! 748: }
! 749: free(p->config_storage);
! 750: }
! 751:
! 752: free(p);
! 753:
! 754: return HANDLER_GO_ON;
! 755: }
! 756:
! 757: static int env_add(char_array *env, const char *key, size_t key_len, const char *val, size_t val_len) {
! 758: char *dst;
! 759: size_t i;
! 760:
! 761: if (!key || !val) return -1;
! 762:
! 763: dst = malloc(key_len + val_len + 3);
! 764: memcpy(dst, key, key_len);
! 765: dst[key_len] = '=';
! 766: memcpy(dst + key_len + 1, val, val_len);
! 767: dst[key_len + 1 + val_len] = '\0';
! 768:
! 769: for (i = 0; i < env->used; i++) {
! 770: if (0 == strncmp(dst, env->ptr[i], key_len + 1)) {
! 771: /* don't care about free as we are in a forked child which is going to exec(...) */
! 772: /* free(env->ptr[i]); */
! 773: env->ptr[i] = dst;
! 774: return 0;
! 775: }
! 776: }
! 777:
! 778: if (env->size == 0) {
! 779: env->size = 16;
! 780: env->ptr = malloc(env->size * sizeof(*env->ptr));
! 781: } else if (env->size == env->used + 1) {
! 782: env->size += 16;
! 783: env->ptr = realloc(env->ptr, env->size * sizeof(*env->ptr));
! 784: }
! 785:
! 786: env->ptr[env->used++] = dst;
! 787:
! 788: return 0;
! 789: }
! 790:
! 791: static int parse_binpath(char_array *env, buffer *b) {
! 792: char *start;
! 793: size_t i;
! 794: /* search for spaces */
! 795:
! 796: start = b->ptr;
! 797: for (i = 0; i < b->used - 1; i++) {
! 798: switch(b->ptr[i]) {
! 799: case ' ':
! 800: case '\t':
! 801: /* a WS, stop here and copy the argument */
! 802:
! 803: if (env->size == 0) {
! 804: env->size = 16;
! 805: env->ptr = malloc(env->size * sizeof(*env->ptr));
! 806: } else if (env->size == env->used) {
! 807: env->size += 16;
! 808: env->ptr = realloc(env->ptr, env->size * sizeof(*env->ptr));
! 809: }
! 810:
! 811: b->ptr[i] = '\0';
! 812:
! 813: env->ptr[env->used++] = start;
! 814:
! 815: start = b->ptr + i + 1;
! 816: break;
! 817: default:
! 818: break;
! 819: }
! 820: }
! 821:
! 822: if (env->size == 0) {
! 823: env->size = 16;
! 824: env->ptr = malloc(env->size * sizeof(*env->ptr));
! 825: } else if (env->size == env->used) { /* we need one extra for the terminating NULL */
! 826: env->size += 16;
! 827: env->ptr = realloc(env->ptr, env->size * sizeof(*env->ptr));
! 828: }
! 829:
! 830: /* the rest */
! 831: env->ptr[env->used++] = start;
! 832:
! 833: if (env->size == 0) {
! 834: env->size = 16;
! 835: env->ptr = malloc(env->size * sizeof(*env->ptr));
! 836: } else if (env->size == env->used) { /* we need one extra for the terminating NULL */
! 837: env->size += 16;
! 838: env->ptr = realloc(env->ptr, env->size * sizeof(*env->ptr));
! 839: }
! 840:
! 841: /* terminate */
! 842: env->ptr[env->used++] = NULL;
! 843:
! 844: return 0;
! 845: }
! 846:
! 847: static int fcgi_spawn_connection(server *srv,
! 848: plugin_data *p,
! 849: fcgi_extension_host *host,
! 850: fcgi_proc *proc) {
! 851: int fcgi_fd;
! 852: int socket_type, status;
! 853: struct timeval tv = { 0, 100 * 1000 };
! 854: #ifdef HAVE_SYS_UN_H
! 855: struct sockaddr_un fcgi_addr_un;
! 856: #endif
! 857: struct sockaddr_in fcgi_addr_in;
! 858: struct sockaddr *fcgi_addr;
! 859:
! 860: socklen_t servlen;
! 861:
! 862: #ifndef HAVE_FORK
! 863: return -1;
! 864: #endif
! 865:
! 866: if (p->conf.debug) {
! 867: log_error_write(srv, __FILE__, __LINE__, "sdb",
! 868: "new proc, socket:", proc->port, proc->unixsocket);
! 869: }
! 870:
! 871: if (!buffer_is_empty(proc->unixsocket)) {
! 872: memset(&fcgi_addr, 0, sizeof(fcgi_addr));
! 873:
! 874: #ifdef HAVE_SYS_UN_H
! 875: fcgi_addr_un.sun_family = AF_UNIX;
! 876: strcpy(fcgi_addr_un.sun_path, proc->unixsocket->ptr);
! 877:
! 878: #ifdef SUN_LEN
! 879: servlen = SUN_LEN(&fcgi_addr_un);
! 880: #else
! 881: /* stevens says: */
! 882: servlen = proc->unixsocket->used + sizeof(fcgi_addr_un.sun_family);
! 883: #endif
! 884: socket_type = AF_UNIX;
! 885: fcgi_addr = (struct sockaddr *) &fcgi_addr_un;
! 886:
! 887: buffer_copy_string_len(proc->connection_name, CONST_STR_LEN("unix:"));
! 888: buffer_append_string_buffer(proc->connection_name, proc->unixsocket);
! 889:
! 890: #else
! 891: log_error_write(srv, __FILE__, __LINE__, "s",
! 892: "ERROR: Unix Domain sockets are not supported.");
! 893: return -1;
! 894: #endif
! 895: } else {
! 896: fcgi_addr_in.sin_family = AF_INET;
! 897:
! 898: if (buffer_is_empty(host->host)) {
! 899: fcgi_addr_in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
! 900: } else {
! 901: struct hostent *he;
! 902:
! 903: /* set a useful default */
! 904: fcgi_addr_in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
! 905:
! 906:
! 907: if (NULL == (he = gethostbyname(host->host->ptr))) {
! 908: log_error_write(srv, __FILE__, __LINE__,
! 909: "sdb", "gethostbyname failed: ",
! 910: h_errno, host->host);
! 911: return -1;
! 912: }
! 913:
! 914: if (he->h_addrtype != AF_INET) {
! 915: log_error_write(srv, __FILE__, __LINE__, "sd", "addr-type != AF_INET: ", he->h_addrtype);
! 916: return -1;
! 917: }
! 918:
! 919: if (he->h_length != sizeof(struct in_addr)) {
! 920: log_error_write(srv, __FILE__, __LINE__, "sd", "addr-length != sizeof(in_addr): ", he->h_length);
! 921: return -1;
! 922: }
! 923:
! 924: memcpy(&(fcgi_addr_in.sin_addr.s_addr), he->h_addr_list[0], he->h_length);
! 925:
! 926: }
! 927: fcgi_addr_in.sin_port = htons(proc->port);
! 928: servlen = sizeof(fcgi_addr_in);
! 929:
! 930: socket_type = AF_INET;
! 931: fcgi_addr = (struct sockaddr *) &fcgi_addr_in;
! 932:
! 933: buffer_copy_string_len(proc->connection_name, CONST_STR_LEN("tcp:"));
! 934: if (!buffer_is_empty(host->host)) {
! 935: buffer_append_string_buffer(proc->connection_name, host->host);
! 936: } else {
! 937: buffer_append_string_len(proc->connection_name, CONST_STR_LEN("localhost"));
! 938: }
! 939: buffer_append_string_len(proc->connection_name, CONST_STR_LEN(":"));
! 940: buffer_append_long(proc->connection_name, proc->port);
! 941: }
! 942:
! 943: if (-1 == (fcgi_fd = socket(socket_type, SOCK_STREAM, 0))) {
! 944: log_error_write(srv, __FILE__, __LINE__, "ss",
! 945: "failed:", strerror(errno));
! 946: return -1;
! 947: }
! 948:
! 949: if (-1 == connect(fcgi_fd, fcgi_addr, servlen)) {
! 950: /* server is not up, spawn it */
! 951: pid_t child;
! 952: int val;
! 953:
! 954: if (errno != ENOENT &&
! 955: !buffer_is_empty(proc->unixsocket)) {
! 956: unlink(proc->unixsocket->ptr);
! 957: }
! 958:
! 959: close(fcgi_fd);
! 960:
! 961: /* reopen socket */
! 962: if (-1 == (fcgi_fd = socket(socket_type, SOCK_STREAM, 0))) {
! 963: log_error_write(srv, __FILE__, __LINE__, "ss",
! 964: "socket failed:", strerror(errno));
! 965: return -1;
! 966: }
! 967:
! 968: val = 1;
! 969: if (setsockopt(fcgi_fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
! 970: log_error_write(srv, __FILE__, __LINE__, "ss",
! 971: "socketsockopt failed:", strerror(errno));
! 972: return -1;
! 973: }
! 974:
! 975: /* create socket */
! 976: if (-1 == bind(fcgi_fd, fcgi_addr, servlen)) {
! 977: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 978: "bind failed for:",
! 979: proc->connection_name,
! 980: strerror(errno));
! 981: return -1;
! 982: }
! 983:
! 984: if (-1 == listen(fcgi_fd, 1024)) {
! 985: log_error_write(srv, __FILE__, __LINE__, "ss",
! 986: "listen failed:", strerror(errno));
! 987: return -1;
! 988: }
! 989:
! 990: #ifdef HAVE_FORK
! 991: switch ((child = fork())) {
! 992: case 0: {
! 993: size_t i = 0;
! 994: char *c;
! 995: char_array env;
! 996: char_array arg;
! 997:
! 998: /* create environment */
! 999: env.ptr = NULL;
! 1000: env.size = 0;
! 1001: env.used = 0;
! 1002:
! 1003: arg.ptr = NULL;
! 1004: arg.size = 0;
! 1005: arg.used = 0;
! 1006:
! 1007: if(fcgi_fd != FCGI_LISTENSOCK_FILENO) {
! 1008: close(FCGI_LISTENSOCK_FILENO);
! 1009: dup2(fcgi_fd, FCGI_LISTENSOCK_FILENO);
! 1010: close(fcgi_fd);
! 1011: }
! 1012:
! 1013: /* we don't need the client socket */
! 1014: for (i = 3; i < 256; i++) {
! 1015: close(i);
! 1016: }
! 1017:
! 1018: /* build clean environment */
! 1019: if (host->bin_env_copy->used) {
! 1020: for (i = 0; i < host->bin_env_copy->used; i++) {
! 1021: data_string *ds = (data_string *)host->bin_env_copy->data[i];
! 1022: char *ge;
! 1023:
! 1024: if (NULL != (ge = getenv(ds->value->ptr))) {
! 1025: env_add(&env, CONST_BUF_LEN(ds->value), ge, strlen(ge));
! 1026: }
! 1027: }
! 1028: } else {
! 1029: for (i = 0; environ[i]; i++) {
! 1030: char *eq;
! 1031:
! 1032: if (NULL != (eq = strchr(environ[i], '='))) {
! 1033: env_add(&env, environ[i], eq - environ[i], eq+1, strlen(eq+1));
! 1034: }
! 1035: }
! 1036: }
! 1037:
! 1038: /* create environment */
! 1039: for (i = 0; i < host->bin_env->used; i++) {
! 1040: data_string *ds = (data_string *)host->bin_env->data[i];
! 1041:
! 1042: env_add(&env, CONST_BUF_LEN(ds->key), CONST_BUF_LEN(ds->value));
! 1043: }
! 1044:
! 1045: for (i = 0; i < env.used; i++) {
! 1046: /* search for PHP_FCGI_CHILDREN */
! 1047: if (0 == strncmp(env.ptr[i], "PHP_FCGI_CHILDREN=", sizeof("PHP_FCGI_CHILDREN=") - 1)) break;
! 1048: }
! 1049:
! 1050: /* not found, add a default */
! 1051: if (i == env.used) {
! 1052: env_add(&env, CONST_STR_LEN("PHP_FCGI_CHILDREN"), CONST_STR_LEN("1"));
! 1053: }
! 1054:
! 1055: env.ptr[env.used] = NULL;
! 1056:
! 1057: parse_binpath(&arg, host->bin_path);
! 1058:
! 1059: /* chdir into the base of the bin-path,
! 1060: * search for the last / */
! 1061: if (NULL != (c = strrchr(arg.ptr[0], '/'))) {
! 1062: *c = '\0';
! 1063:
! 1064: /* change to the physical directory */
! 1065: if (-1 == chdir(arg.ptr[0])) {
! 1066: *c = '/';
! 1067: log_error_write(srv, __FILE__, __LINE__, "sss", "chdir failed:", strerror(errno), arg.ptr[0]);
! 1068: }
! 1069: *c = '/';
! 1070: }
! 1071:
! 1072: reset_signals();
! 1073:
! 1074: /* exec the cgi */
! 1075: execve(arg.ptr[0], arg.ptr, env.ptr);
! 1076:
! 1077: /* log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1078: "execve failed for:", host->bin_path, strerror(errno)); */
! 1079:
! 1080: exit(errno);
! 1081:
! 1082: break;
! 1083: }
! 1084: case -1:
! 1085: /* error */
! 1086: break;
! 1087: default:
! 1088: /* father */
! 1089:
! 1090: /* wait */
! 1091: select(0, NULL, NULL, NULL, &tv);
! 1092:
! 1093: switch (waitpid(child, &status, WNOHANG)) {
! 1094: case 0:
! 1095: /* child still running after timeout, good */
! 1096: break;
! 1097: case -1:
! 1098: /* no PID found ? should never happen */
! 1099: log_error_write(srv, __FILE__, __LINE__, "ss",
! 1100: "pid not found:", strerror(errno));
! 1101: return -1;
! 1102: default:
! 1103: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1104: "the fastcgi-backend", host->bin_path, "failed to start:");
! 1105: /* the child should not terminate at all */
! 1106: if (WIFEXITED(status)) {
! 1107: log_error_write(srv, __FILE__, __LINE__, "sdb",
! 1108: "child exited with status",
! 1109: WEXITSTATUS(status), host->bin_path);
! 1110: log_error_write(srv, __FILE__, __LINE__, "s",
! 1111: "If you're trying to run your app as a FastCGI backend, make sure you're using the FastCGI-enabled version.\n"
! 1112: "If this is PHP on Gentoo, add 'fastcgi' to the USE flags.");
! 1113: } else if (WIFSIGNALED(status)) {
! 1114: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1115: "terminated by signal:",
! 1116: WTERMSIG(status));
! 1117:
! 1118: if (WTERMSIG(status) == 11) {
! 1119: log_error_write(srv, __FILE__, __LINE__, "s",
! 1120: "to be exact: it segfaulted, crashed, died, ... you get the idea." );
! 1121: log_error_write(srv, __FILE__, __LINE__, "s",
! 1122: "If this is PHP, try removing the bytecode caches for now and try again.");
! 1123: }
! 1124: } else {
! 1125: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1126: "child died somehow:",
! 1127: status);
! 1128: }
! 1129: return -1;
! 1130: }
! 1131:
! 1132: /* register process */
! 1133: proc->pid = child;
! 1134: proc->is_local = 1;
! 1135:
! 1136: break;
! 1137: }
! 1138: #endif
! 1139: } else {
! 1140: proc->is_local = 0;
! 1141: proc->pid = 0;
! 1142:
! 1143: if (p->conf.debug) {
! 1144: log_error_write(srv, __FILE__, __LINE__, "sb",
! 1145: "(debug) socket is already used; won't spawn:",
! 1146: proc->connection_name);
! 1147: }
! 1148: }
! 1149:
! 1150: proc->state = PROC_STATE_RUNNING;
! 1151: host->active_procs++;
! 1152:
! 1153: close(fcgi_fd);
! 1154:
! 1155: return 0;
! 1156: }
! 1157:
! 1158:
! 1159: SETDEFAULTS_FUNC(mod_fastcgi_set_defaults) {
! 1160: plugin_data *p = p_d;
! 1161: data_unset *du;
! 1162: size_t i = 0;
! 1163: buffer *fcgi_mode = buffer_init();
! 1164:
! 1165: config_values_t cv[] = {
! 1166: { "fastcgi.server", NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
! 1167: { "fastcgi.debug", NULL, T_CONFIG_INT , T_CONFIG_SCOPE_CONNECTION }, /* 1 */
! 1168: { "fastcgi.map-extensions", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
! 1169: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
! 1170: };
! 1171:
! 1172: p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
! 1173:
! 1174: for (i = 0; i < srv->config_context->used; i++) {
! 1175: plugin_config *s;
! 1176: array *ca;
! 1177:
! 1178: s = malloc(sizeof(plugin_config));
! 1179: s->exts = fastcgi_extensions_init();
! 1180: s->debug = 0;
! 1181: s->ext_mapping = array_init();
! 1182:
! 1183: cv[0].destination = s->exts;
! 1184: cv[1].destination = &(s->debug);
! 1185: cv[2].destination = s->ext_mapping;
! 1186:
! 1187: p->config_storage[i] = s;
! 1188: ca = ((data_config *)srv->config_context->data[i])->value;
! 1189:
! 1190: if (0 != config_insert_values_global(srv, ca, cv)) {
! 1191: return HANDLER_ERROR;
! 1192: }
! 1193:
! 1194: /*
! 1195: * <key> = ( ... )
! 1196: */
! 1197:
! 1198: if (NULL != (du = array_get_element(ca, "fastcgi.server"))) {
! 1199: size_t j;
! 1200: data_array *da = (data_array *)du;
! 1201:
! 1202: if (du->type != TYPE_ARRAY) {
! 1203: log_error_write(srv, __FILE__, __LINE__, "sss",
! 1204: "unexpected type for key: ", "fastcgi.server", "array of strings");
! 1205:
! 1206: return HANDLER_ERROR;
! 1207: }
! 1208:
! 1209:
! 1210: /*
! 1211: * fastcgi.server = ( "<ext>" => ( ... ),
! 1212: * "<ext>" => ( ... ) )
! 1213: */
! 1214:
! 1215: for (j = 0; j < da->value->used; j++) {
! 1216: size_t n;
! 1217: data_array *da_ext = (data_array *)da->value->data[j];
! 1218:
! 1219: if (da->value->data[j]->type != TYPE_ARRAY) {
! 1220: log_error_write(srv, __FILE__, __LINE__, "sssbs",
! 1221: "unexpected type for key: ", "fastcgi.server",
! 1222: "[", da->value->data[j]->key, "](string)");
! 1223:
! 1224: return HANDLER_ERROR;
! 1225: }
! 1226:
! 1227: /*
! 1228: * da_ext->key == name of the extension
! 1229: */
! 1230:
! 1231: /*
! 1232: * fastcgi.server = ( "<ext>" =>
! 1233: * ( "<host>" => ( ... ),
! 1234: * "<host>" => ( ... )
! 1235: * ),
! 1236: * "<ext>" => ... )
! 1237: */
! 1238:
! 1239: for (n = 0; n < da_ext->value->used; n++) {
! 1240: data_array *da_host = (data_array *)da_ext->value->data[n];
! 1241:
! 1242: fcgi_extension_host *host;
! 1243:
! 1244: config_values_t fcv[] = {
! 1245: { "host", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
! 1246: { "docroot", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
! 1247: { "mode", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
! 1248: { "socket", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 3 */
! 1249: { "bin-path", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 4 */
! 1250:
! 1251: { "check-local", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 5 */
! 1252: { "port", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 6 */
! 1253: { "max-procs", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 7 */
! 1254: { "disable-time", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 8 */
! 1255:
! 1256: { "bin-environment", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 9 */
! 1257: { "bin-copy-environment", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 10 */
! 1258:
! 1259: { "broken-scriptfilename", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 11 */
! 1260: { "allow-x-send-file", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 12 */
! 1261: { "strip-request-uri", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 13 */
! 1262: { "kill-signal", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 14 */
! 1263: { "fix-root-scriptname", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 15 */
! 1264:
! 1265: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
! 1266: };
! 1267:
! 1268: if (da_host->type != TYPE_ARRAY) {
! 1269: log_error_write(srv, __FILE__, __LINE__, "ssSBS",
! 1270: "unexpected type for key:",
! 1271: "fastcgi.server",
! 1272: "[", da_host->key, "](string)");
! 1273:
! 1274: return HANDLER_ERROR;
! 1275: }
! 1276:
! 1277: host = fastcgi_host_init();
! 1278: buffer_reset(fcgi_mode);
! 1279:
! 1280: buffer_copy_string_buffer(host->id, da_host->key);
! 1281:
! 1282: host->check_local = 1;
! 1283: host->max_procs = 4;
! 1284: host->mode = FCGI_RESPONDER;
! 1285: host->disable_time = 1;
! 1286: host->break_scriptfilename_for_php = 0;
! 1287: host->allow_xsendfile = 0; /* handle X-LIGHTTPD-send-file */
! 1288: host->kill_signal = SIGTERM;
! 1289: host->fix_root_path_name = 0;
! 1290:
! 1291: fcv[0].destination = host->host;
! 1292: fcv[1].destination = host->docroot;
! 1293: fcv[2].destination = fcgi_mode;
! 1294: fcv[3].destination = host->unixsocket;
! 1295: fcv[4].destination = host->bin_path;
! 1296:
! 1297: fcv[5].destination = &(host->check_local);
! 1298: fcv[6].destination = &(host->port);
! 1299: fcv[7].destination = &(host->max_procs);
! 1300: fcv[8].destination = &(host->disable_time);
! 1301:
! 1302: fcv[9].destination = host->bin_env;
! 1303: fcv[10].destination = host->bin_env_copy;
! 1304: fcv[11].destination = &(host->break_scriptfilename_for_php);
! 1305: fcv[12].destination = &(host->allow_xsendfile);
! 1306: fcv[13].destination = host->strip_request_uri;
! 1307: fcv[14].destination = &(host->kill_signal);
! 1308: fcv[15].destination = &(host->fix_root_path_name);
! 1309:
! 1310: if (0 != config_insert_values_internal(srv, da_host->value, fcv)) {
! 1311: return HANDLER_ERROR;
! 1312: }
! 1313:
! 1314: if ((!buffer_is_empty(host->host) || host->port) &&
! 1315: !buffer_is_empty(host->unixsocket)) {
! 1316: log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
! 1317: "either host/port or socket have to be set in:",
! 1318: da->key, "= (",
! 1319: da_ext->key, " => (",
! 1320: da_host->key, " ( ...");
! 1321:
! 1322: return HANDLER_ERROR;
! 1323: }
! 1324:
! 1325: if (!buffer_is_empty(host->unixsocket)) {
! 1326: /* unix domain socket */
! 1327: struct sockaddr_un un;
! 1328:
! 1329: if (host->unixsocket->used > sizeof(un.sun_path) - 2) {
! 1330: log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
! 1331: "unixsocket is too long in:",
! 1332: da->key, "= (",
! 1333: da_ext->key, " => (",
! 1334: da_host->key, " ( ...");
! 1335:
! 1336: return HANDLER_ERROR;
! 1337: }
! 1338: } else {
! 1339: /* tcp/ip */
! 1340:
! 1341: if (buffer_is_empty(host->host) &&
! 1342: buffer_is_empty(host->bin_path)) {
! 1343: log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
! 1344: "host or binpath have to be set in:",
! 1345: da->key, "= (",
! 1346: da_ext->key, " => (",
! 1347: da_host->key, " ( ...");
! 1348:
! 1349: return HANDLER_ERROR;
! 1350: } else if (host->port == 0) {
! 1351: log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
! 1352: "port has to be set in:",
! 1353: da->key, "= (",
! 1354: da_ext->key, " => (",
! 1355: da_host->key, " ( ...");
! 1356:
! 1357: return HANDLER_ERROR;
! 1358: }
! 1359: }
! 1360:
! 1361: if (!buffer_is_empty(host->bin_path)) {
! 1362: /* a local socket + self spawning */
! 1363: size_t pno;
! 1364:
! 1365: if (s->debug) {
! 1366: log_error_write(srv, __FILE__, __LINE__, "ssbsdsbsd",
! 1367: "--- fastcgi spawning local",
! 1368: "\n\tproc:", host->bin_path,
! 1369: "\n\tport:", host->port,
! 1370: "\n\tsocket", host->unixsocket,
! 1371: "\n\tmax-procs:", host->max_procs);
! 1372: }
! 1373:
! 1374: for (pno = 0; pno < host->max_procs; pno++) {
! 1375: fcgi_proc *proc;
! 1376:
! 1377: proc = fastcgi_process_init();
! 1378: proc->id = host->num_procs++;
! 1379: host->max_id++;
! 1380:
! 1381: if (buffer_is_empty(host->unixsocket)) {
! 1382: proc->port = host->port + pno;
! 1383: } else {
! 1384: buffer_copy_string_buffer(proc->unixsocket, host->unixsocket);
! 1385: buffer_append_string_len(proc->unixsocket, CONST_STR_LEN("-"));
! 1386: buffer_append_long(proc->unixsocket, pno);
! 1387: }
! 1388:
! 1389: if (s->debug) {
! 1390: log_error_write(srv, __FILE__, __LINE__, "ssdsbsdsd",
! 1391: "--- fastcgi spawning",
! 1392: "\n\tport:", host->port,
! 1393: "\n\tsocket", host->unixsocket,
! 1394: "\n\tcurrent:", pno, "/", host->max_procs);
! 1395: }
! 1396:
! 1397: if (fcgi_spawn_connection(srv, p, host, proc)) {
! 1398: log_error_write(srv, __FILE__, __LINE__, "s",
! 1399: "[ERROR]: spawning fcgi failed.");
! 1400: return HANDLER_ERROR;
! 1401: }
! 1402:
! 1403: fastcgi_status_init(srv, p->statuskey, host, proc);
! 1404:
! 1405: proc->next = host->first;
! 1406: if (host->first) host->first->prev = proc;
! 1407:
! 1408: host->first = proc;
! 1409: }
! 1410: } else {
! 1411: fcgi_proc *proc;
! 1412:
! 1413: proc = fastcgi_process_init();
! 1414: proc->id = host->num_procs++;
! 1415: host->max_id++;
! 1416: host->active_procs++;
! 1417: proc->state = PROC_STATE_RUNNING;
! 1418:
! 1419: if (buffer_is_empty(host->unixsocket)) {
! 1420: proc->port = host->port;
! 1421: } else {
! 1422: buffer_copy_string_buffer(proc->unixsocket, host->unixsocket);
! 1423: }
! 1424:
! 1425: fastcgi_status_init(srv, p->statuskey, host, proc);
! 1426:
! 1427: host->first = proc;
! 1428:
! 1429: host->max_procs = 1;
! 1430: }
! 1431:
! 1432: if (!buffer_is_empty(fcgi_mode)) {
! 1433: if (strcmp(fcgi_mode->ptr, "responder") == 0) {
! 1434: host->mode = FCGI_RESPONDER;
! 1435: } else if (strcmp(fcgi_mode->ptr, "authorizer") == 0) {
! 1436: host->mode = FCGI_AUTHORIZER;
! 1437: if (buffer_is_empty(host->docroot)) {
! 1438: log_error_write(srv, __FILE__, __LINE__, "s",
! 1439: "ERROR: docroot is required for authorizer mode.");
! 1440: return HANDLER_ERROR;
! 1441: }
! 1442: } else {
! 1443: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1444: "WARNING: unknown fastcgi mode:",
! 1445: fcgi_mode, "(ignored, mode set to responder)");
! 1446: }
! 1447: }
! 1448:
! 1449: /* if extension already exists, take it */
! 1450: fastcgi_extension_insert(s->exts, da_ext->key, host);
! 1451: }
! 1452: }
! 1453: }
! 1454: }
! 1455:
! 1456: buffer_free(fcgi_mode);
! 1457:
! 1458: return HANDLER_GO_ON;
! 1459: }
! 1460:
! 1461: static int fcgi_set_state(server *srv, handler_ctx *hctx, fcgi_connection_state_t state) {
! 1462: hctx->state = state;
! 1463: hctx->state_timestamp = srv->cur_ts;
! 1464:
! 1465: return 0;
! 1466: }
! 1467:
! 1468:
! 1469: static void fcgi_connection_close(server *srv, handler_ctx *hctx) {
! 1470: plugin_data *p;
! 1471: connection *con;
! 1472:
! 1473: if (NULL == hctx) return;
! 1474:
! 1475: p = hctx->plugin_data;
! 1476: con = hctx->remote_conn;
! 1477:
! 1478: if (hctx->fd != -1) {
! 1479: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
! 1480: fdevent_unregister(srv->ev, hctx->fd);
! 1481: close(hctx->fd);
! 1482: srv->cur_fds--;
! 1483: }
! 1484:
! 1485: if (hctx->host && hctx->proc) {
! 1486: if (hctx->got_proc) {
! 1487: /* after the connect the process gets a load */
! 1488: fcgi_proc_load_dec(srv, hctx);
! 1489:
! 1490: if (p->conf.debug) {
! 1491: log_error_write(srv, __FILE__, __LINE__, "ssdsbsd",
! 1492: "released proc:",
! 1493: "pid:", hctx->proc->pid,
! 1494: "socket:", hctx->proc->connection_name,
! 1495: "load:", hctx->proc->load);
! 1496: }
! 1497: }
! 1498: }
! 1499:
! 1500:
! 1501: handler_ctx_free(srv, hctx);
! 1502: con->plugin_ctx[p->id] = NULL;
! 1503: }
! 1504:
! 1505: static int fcgi_reconnect(server *srv, handler_ctx *hctx) {
! 1506: plugin_data *p = hctx->plugin_data;
! 1507:
! 1508: /* child died
! 1509: *
! 1510: * 1.
! 1511: *
! 1512: * connect was ok, connection was accepted
! 1513: * but the php accept loop checks after the accept if it should die or not.
! 1514: *
! 1515: * if yes we can only detect it at a write()
! 1516: *
! 1517: * next step is resetting this attemp and setup a connection again
! 1518: *
! 1519: * if we have more than 5 reconnects for the same request, die
! 1520: *
! 1521: * 2.
! 1522: *
! 1523: * we have a connection but the child died by some other reason
! 1524: *
! 1525: */
! 1526:
! 1527: if (hctx->fd != -1) {
! 1528: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
! 1529: fdevent_unregister(srv->ev, hctx->fd);
! 1530: close(hctx->fd);
! 1531: srv->cur_fds--;
! 1532: hctx->fd = -1;
! 1533: }
! 1534:
! 1535: fcgi_set_state(srv, hctx, FCGI_STATE_INIT);
! 1536:
! 1537: hctx->request_id = 0;
! 1538: hctx->reconnects++;
! 1539:
! 1540: if (p->conf.debug > 2) {
! 1541: if (hctx->proc) {
! 1542: log_error_write(srv, __FILE__, __LINE__, "sdb",
! 1543: "release proc for reconnect:",
! 1544: hctx->proc->pid, hctx->proc->connection_name);
! 1545: } else {
! 1546: log_error_write(srv, __FILE__, __LINE__, "sb",
! 1547: "release proc for reconnect:",
! 1548: hctx->host->unixsocket);
! 1549: }
! 1550: }
! 1551:
! 1552: if (hctx->proc && hctx->got_proc) {
! 1553: fcgi_proc_load_dec(srv, hctx);
! 1554: }
! 1555:
! 1556: /* perhaps another host gives us more luck */
! 1557: fcgi_host_reset(srv, hctx);
! 1558:
! 1559: return 0;
! 1560: }
! 1561:
! 1562:
! 1563: static handler_t fcgi_connection_reset(server *srv, connection *con, void *p_d) {
! 1564: plugin_data *p = p_d;
! 1565:
! 1566: fcgi_connection_close(srv, con->plugin_ctx[p->id]);
! 1567:
! 1568: return HANDLER_GO_ON;
! 1569: }
! 1570:
! 1571:
! 1572: static int fcgi_env_add(buffer *env, const char *key, size_t key_len, const char *val, size_t val_len) {
! 1573: size_t len;
! 1574:
! 1575: if (!key || !val) return -1;
! 1576:
! 1577: len = key_len + val_len;
! 1578:
! 1579: len += key_len > 127 ? 4 : 1;
! 1580: len += val_len > 127 ? 4 : 1;
! 1581:
! 1582: if (env->used + len >= FCGI_MAX_LENGTH) {
! 1583: /**
! 1584: * we can't append more headers, ignore it
! 1585: */
! 1586: return -1;
! 1587: }
! 1588:
! 1589: /**
! 1590: * field length can be 31bit max
! 1591: *
! 1592: * HINT: this can't happen as FCGI_MAX_LENGTH is only 16bit
! 1593: */
! 1594: if (key_len > 0x7fffffff) key_len = 0x7fffffff;
! 1595: if (val_len > 0x7fffffff) val_len = 0x7fffffff;
! 1596:
! 1597: buffer_prepare_append(env, len);
! 1598:
! 1599: if (key_len > 127) {
! 1600: env->ptr[env->used++] = ((key_len >> 24) & 0xff) | 0x80;
! 1601: env->ptr[env->used++] = (key_len >> 16) & 0xff;
! 1602: env->ptr[env->used++] = (key_len >> 8) & 0xff;
! 1603: env->ptr[env->used++] = (key_len >> 0) & 0xff;
! 1604: } else {
! 1605: env->ptr[env->used++] = (key_len >> 0) & 0xff;
! 1606: }
! 1607:
! 1608: if (val_len > 127) {
! 1609: env->ptr[env->used++] = ((val_len >> 24) & 0xff) | 0x80;
! 1610: env->ptr[env->used++] = (val_len >> 16) & 0xff;
! 1611: env->ptr[env->used++] = (val_len >> 8) & 0xff;
! 1612: env->ptr[env->used++] = (val_len >> 0) & 0xff;
! 1613: } else {
! 1614: env->ptr[env->used++] = (val_len >> 0) & 0xff;
! 1615: }
! 1616:
! 1617: memcpy(env->ptr + env->used, key, key_len);
! 1618: env->used += key_len;
! 1619: memcpy(env->ptr + env->used, val, val_len);
! 1620: env->used += val_len;
! 1621:
! 1622: return 0;
! 1623: }
! 1624:
! 1625: static int fcgi_header(FCGI_Header * header, unsigned char type, size_t request_id, int contentLength, unsigned char paddingLength) {
! 1626: assert(contentLength <= FCGI_MAX_LENGTH);
! 1627:
! 1628: header->version = FCGI_VERSION_1;
! 1629: header->type = type;
! 1630: header->requestIdB0 = request_id & 0xff;
! 1631: header->requestIdB1 = (request_id >> 8) & 0xff;
! 1632: header->contentLengthB0 = contentLength & 0xff;
! 1633: header->contentLengthB1 = (contentLength >> 8) & 0xff;
! 1634: header->paddingLength = paddingLength;
! 1635: header->reserved = 0;
! 1636:
! 1637: return 0;
! 1638: }
! 1639:
! 1640: typedef enum {
! 1641: CONNECTION_OK,
! 1642: CONNECTION_DELAYED, /* retry after event, take same host */
! 1643: CONNECTION_OVERLOADED, /* disable for 1 second, take another backend */
! 1644: CONNECTION_DEAD /* disable for 60 seconds, take another backend */
! 1645: } connection_result_t;
! 1646:
! 1647: static connection_result_t fcgi_establish_connection(server *srv, handler_ctx *hctx) {
! 1648: struct sockaddr *fcgi_addr;
! 1649: struct sockaddr_in fcgi_addr_in;
! 1650: #ifdef HAVE_SYS_UN_H
! 1651: struct sockaddr_un fcgi_addr_un;
! 1652: #endif
! 1653: socklen_t servlen;
! 1654:
! 1655: fcgi_extension_host *host = hctx->host;
! 1656: fcgi_proc *proc = hctx->proc;
! 1657: int fcgi_fd = hctx->fd;
! 1658:
! 1659: memset(&fcgi_addr, 0, sizeof(fcgi_addr));
! 1660:
! 1661: if (!buffer_is_empty(proc->unixsocket)) {
! 1662: #ifdef HAVE_SYS_UN_H
! 1663: /* use the unix domain socket */
! 1664: fcgi_addr_un.sun_family = AF_UNIX;
! 1665: strcpy(fcgi_addr_un.sun_path, proc->unixsocket->ptr);
! 1666: #ifdef SUN_LEN
! 1667: servlen = SUN_LEN(&fcgi_addr_un);
! 1668: #else
! 1669: /* stevens says: */
! 1670: servlen = proc->unixsocket->used + sizeof(fcgi_addr_un.sun_family);
! 1671: #endif
! 1672: fcgi_addr = (struct sockaddr *) &fcgi_addr_un;
! 1673:
! 1674: if (buffer_is_empty(proc->connection_name)) {
! 1675: /* on remote spawing we have to set the connection-name now */
! 1676: buffer_copy_string_len(proc->connection_name, CONST_STR_LEN("unix:"));
! 1677: buffer_append_string_buffer(proc->connection_name, proc->unixsocket);
! 1678: }
! 1679: #else
! 1680: return CONNECTION_DEAD;
! 1681: #endif
! 1682: } else {
! 1683: fcgi_addr_in.sin_family = AF_INET;
! 1684: if (!buffer_is_empty(host->host)) {
! 1685: if (0 == inet_aton(host->host->ptr, &(fcgi_addr_in.sin_addr))) {
! 1686: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1687: "converting IP address failed for", host->host,
! 1688: "\nBe sure to specify an IP address here");
! 1689:
! 1690: return CONNECTION_DEAD;
! 1691: }
! 1692: } else {
! 1693: fcgi_addr_in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
! 1694: }
! 1695: fcgi_addr_in.sin_port = htons(proc->port);
! 1696: servlen = sizeof(fcgi_addr_in);
! 1697:
! 1698: fcgi_addr = (struct sockaddr *) &fcgi_addr_in;
! 1699:
! 1700: if (buffer_is_empty(proc->connection_name)) {
! 1701: /* on remote spawing we have to set the connection-name now */
! 1702: buffer_copy_string_len(proc->connection_name, CONST_STR_LEN("tcp:"));
! 1703: if (!buffer_is_empty(host->host)) {
! 1704: buffer_append_string_buffer(proc->connection_name, host->host);
! 1705: } else {
! 1706: buffer_append_string_len(proc->connection_name, CONST_STR_LEN("localhost"));
! 1707: }
! 1708: buffer_append_string_len(proc->connection_name, CONST_STR_LEN(":"));
! 1709: buffer_append_long(proc->connection_name, proc->port);
! 1710: }
! 1711: }
! 1712:
! 1713: if (-1 == connect(fcgi_fd, fcgi_addr, servlen)) {
! 1714: if (errno == EINPROGRESS ||
! 1715: errno == EALREADY ||
! 1716: errno == EINTR) {
! 1717: if (hctx->conf.debug > 2) {
! 1718: log_error_write(srv, __FILE__, __LINE__, "sb",
! 1719: "connect delayed; will continue later:", proc->connection_name);
! 1720: }
! 1721:
! 1722: return CONNECTION_DELAYED;
! 1723: } else if (errno == EAGAIN) {
! 1724: if (hctx->conf.debug) {
! 1725: log_error_write(srv, __FILE__, __LINE__, "sbsd",
! 1726: "This means that you have more incoming requests than your FastCGI backend can handle in parallel."
! 1727: "It might help to spawn more FastCGI backends or PHP children; if not, decrease server.max-connections."
! 1728: "The load for this FastCGI backend", proc->connection_name, "is", proc->load);
! 1729: }
! 1730:
! 1731: return CONNECTION_OVERLOADED;
! 1732: } else {
! 1733: log_error_write(srv, __FILE__, __LINE__, "sssb",
! 1734: "connect failed:",
! 1735: strerror(errno), "on",
! 1736: proc->connection_name);
! 1737:
! 1738: return CONNECTION_DEAD;
! 1739: }
! 1740: }
! 1741:
! 1742: hctx->reconnects = 0;
! 1743: if (hctx->conf.debug > 1) {
! 1744: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1745: "connect succeeded: ", fcgi_fd);
! 1746: }
! 1747:
! 1748: return CONNECTION_OK;
! 1749: }
! 1750:
! 1751: static int fcgi_env_add_request_headers(server *srv, connection *con, plugin_data *p) {
! 1752: size_t i;
! 1753:
! 1754: for (i = 0; i < con->request.headers->used; i++) {
! 1755: data_string *ds;
! 1756:
! 1757: ds = (data_string *)con->request.headers->data[i];
! 1758:
! 1759: if (ds->value->used && ds->key->used) {
! 1760: size_t j;
! 1761: buffer_reset(srv->tmp_buf);
! 1762:
! 1763: if (0 != strcasecmp(ds->key->ptr, "CONTENT-TYPE")) {
! 1764: buffer_copy_string_len(srv->tmp_buf, CONST_STR_LEN("HTTP_"));
! 1765: srv->tmp_buf->used--;
! 1766: }
! 1767:
! 1768: buffer_prepare_append(srv->tmp_buf, ds->key->used + 2);
! 1769: for (j = 0; j < ds->key->used - 1; j++) {
! 1770: char c = '_';
! 1771: if (light_isalpha(ds->key->ptr[j])) {
! 1772: /* upper-case */
! 1773: c = ds->key->ptr[j] & ~32;
! 1774: } else if (light_isdigit(ds->key->ptr[j])) {
! 1775: /* copy */
! 1776: c = ds->key->ptr[j];
! 1777: }
! 1778: srv->tmp_buf->ptr[srv->tmp_buf->used++] = c;
! 1779: }
! 1780: srv->tmp_buf->ptr[srv->tmp_buf->used++] = '\0';
! 1781:
! 1782: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_BUF_LEN(srv->tmp_buf), CONST_BUF_LEN(ds->value)),con);
! 1783: }
! 1784: }
! 1785:
! 1786: for (i = 0; i < con->environment->used; i++) {
! 1787: data_string *ds;
! 1788:
! 1789: ds = (data_string *)con->environment->data[i];
! 1790:
! 1791: if (ds->value->used && ds->key->used) {
! 1792: size_t j;
! 1793: buffer_reset(srv->tmp_buf);
! 1794:
! 1795: buffer_prepare_append(srv->tmp_buf, ds->key->used + 2);
! 1796: for (j = 0; j < ds->key->used - 1; j++) {
! 1797: char c = '_';
! 1798: if (light_isalpha(ds->key->ptr[j])) {
! 1799: /* upper-case */
! 1800: c = ds->key->ptr[j] & ~32;
! 1801: } else if (light_isdigit(ds->key->ptr[j])) {
! 1802: /* copy */
! 1803: c = ds->key->ptr[j];
! 1804: }
! 1805: srv->tmp_buf->ptr[srv->tmp_buf->used++] = c;
! 1806: }
! 1807: srv->tmp_buf->ptr[srv->tmp_buf->used++] = '\0';
! 1808:
! 1809: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_BUF_LEN(srv->tmp_buf), CONST_BUF_LEN(ds->value)), con);
! 1810: }
! 1811: }
! 1812:
! 1813: return 0;
! 1814: }
! 1815:
! 1816:
! 1817: static int fcgi_create_env(server *srv, handler_ctx *hctx, size_t request_id) {
! 1818: FCGI_BeginRequestRecord beginRecord;
! 1819: FCGI_Header header;
! 1820: buffer *b;
! 1821:
! 1822: char buf[32];
! 1823: const char *s;
! 1824: #ifdef HAVE_IPV6
! 1825: char b2[INET6_ADDRSTRLEN + 1];
! 1826: #endif
! 1827:
! 1828: plugin_data *p = hctx->plugin_data;
! 1829: fcgi_extension_host *host= hctx->host;
! 1830:
! 1831: connection *con = hctx->remote_conn;
! 1832: server_socket *srv_sock = con->srv_socket;
! 1833:
! 1834: sock_addr our_addr;
! 1835: socklen_t our_addr_len;
! 1836:
! 1837: /* send FCGI_BEGIN_REQUEST */
! 1838:
! 1839: fcgi_header(&(beginRecord.header), FCGI_BEGIN_REQUEST, request_id, sizeof(beginRecord.body), 0);
! 1840: beginRecord.body.roleB0 = host->mode;
! 1841: beginRecord.body.roleB1 = 0;
! 1842: beginRecord.body.flags = 0;
! 1843: memset(beginRecord.body.reserved, 0, sizeof(beginRecord.body.reserved));
! 1844:
! 1845: b = chunkqueue_get_append_buffer(hctx->wb);
! 1846:
! 1847: buffer_copy_memory(b, (const char *)&beginRecord, sizeof(beginRecord));
! 1848:
! 1849: /* send FCGI_PARAMS */
! 1850: buffer_prepare_copy(p->fcgi_env, 1024);
! 1851:
! 1852:
! 1853: if (buffer_is_empty(con->conf.server_tag)) {
! 1854: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_STR_LEN(PACKAGE_DESC)),con)
! 1855: } else {
! 1856: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_BUF_LEN(con->conf.server_tag)),con)
! 1857: }
! 1858:
! 1859: if (con->server_name->used) {
! 1860: size_t len = con->server_name->used - 1;
! 1861:
! 1862: if (con->server_name->ptr[0] == '[') {
! 1863: const char *colon = strstr(con->server_name->ptr, "]:");
! 1864: if (colon) len = (colon + 1) - con->server_name->ptr;
! 1865: } else {
! 1866: const char *colon = strchr(con->server_name->ptr, ':');
! 1867: if (colon) len = colon - con->server_name->ptr;
! 1868: }
! 1869:
! 1870: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_NAME"), con->server_name->ptr, len),con)
! 1871: } else {
! 1872: #ifdef HAVE_IPV6
! 1873: s = inet_ntop(srv_sock->addr.plain.sa_family,
! 1874: srv_sock->addr.plain.sa_family == AF_INET6 ?
! 1875: (const void *) &(srv_sock->addr.ipv6.sin6_addr) :
! 1876: (const void *) &(srv_sock->addr.ipv4.sin_addr),
! 1877: b2, sizeof(b2)-1);
! 1878: #else
! 1879: s = inet_ntoa(srv_sock->addr.ipv4.sin_addr);
! 1880: #endif
! 1881: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_NAME"), s, strlen(s)),con)
! 1882: }
! 1883:
! 1884: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("GATEWAY_INTERFACE"), CONST_STR_LEN("CGI/1.1")),con)
! 1885:
! 1886: LI_ltostr(buf,
! 1887: #ifdef HAVE_IPV6
! 1888: ntohs(srv_sock->addr.plain.sa_family ? srv_sock->addr.ipv6.sin6_port : srv_sock->addr.ipv4.sin_port)
! 1889: #else
! 1890: ntohs(srv_sock->addr.ipv4.sin_port)
! 1891: #endif
! 1892: );
! 1893:
! 1894: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_PORT"), buf, strlen(buf)),con)
! 1895:
! 1896: /* get the server-side of the connection to the client */
! 1897: our_addr_len = sizeof(our_addr);
! 1898:
! 1899: if (-1 == getsockname(con->fd, &(our_addr.plain), &our_addr_len)) {
! 1900: s = inet_ntop_cache_get_ip(srv, &(srv_sock->addr));
! 1901: } else {
! 1902: s = inet_ntop_cache_get_ip(srv, &(our_addr));
! 1903: }
! 1904: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_ADDR"), s, strlen(s)),con)
! 1905:
! 1906: LI_ltostr(buf,
! 1907: #ifdef HAVE_IPV6
! 1908: ntohs(con->dst_addr.plain.sa_family ? con->dst_addr.ipv6.sin6_port : con->dst_addr.ipv4.sin_port)
! 1909: #else
! 1910: ntohs(con->dst_addr.ipv4.sin_port)
! 1911: #endif
! 1912: );
! 1913:
! 1914: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REMOTE_PORT"), buf, strlen(buf)),con)
! 1915:
! 1916: s = inet_ntop_cache_get_ip(srv, &(con->dst_addr));
! 1917: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REMOTE_ADDR"), s, strlen(s)),con)
! 1918:
! 1919: if (con->request.content_length > 0 && host->mode != FCGI_AUTHORIZER) {
! 1920: /* CGI-SPEC 6.1.2 and FastCGI spec 6.3 */
! 1921:
! 1922: /* request.content_length < SSIZE_MAX, see request.c */
! 1923: LI_ltostr(buf, con->request.content_length);
! 1924: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("CONTENT_LENGTH"), buf, strlen(buf)),con)
! 1925: }
! 1926:
! 1927: if (host->mode != FCGI_AUTHORIZER) {
! 1928: /*
! 1929: * SCRIPT_NAME, PATH_INFO and PATH_TRANSLATED according to
! 1930: * http://cgi-spec.golux.com/draft-coar-cgi-v11-03-clean.html
! 1931: * (6.1.14, 6.1.6, 6.1.7)
! 1932: * For AUTHORIZER mode these headers should be omitted.
! 1933: */
! 1934:
! 1935: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SCRIPT_NAME"), CONST_BUF_LEN(con->uri.path)),con)
! 1936:
! 1937: if (!buffer_is_empty(con->request.pathinfo)) {
! 1938: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("PATH_INFO"), CONST_BUF_LEN(con->request.pathinfo)),con)
! 1939:
! 1940: /* PATH_TRANSLATED is only defined if PATH_INFO is set */
! 1941:
! 1942: if (!buffer_is_empty(host->docroot)) {
! 1943: buffer_copy_string_buffer(p->path, host->docroot);
! 1944: } else {
! 1945: buffer_copy_string_buffer(p->path, con->physical.basedir);
! 1946: }
! 1947: buffer_append_string_buffer(p->path, con->request.pathinfo);
! 1948: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("PATH_TRANSLATED"), CONST_BUF_LEN(p->path)),con)
! 1949: } else {
! 1950: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("PATH_INFO"), CONST_STR_LEN("")),con)
! 1951: }
! 1952: }
! 1953:
! 1954: /*
! 1955: * SCRIPT_FILENAME and DOCUMENT_ROOT for php. The PHP manual
! 1956: * http://www.php.net/manual/en/reserved.variables.php
! 1957: * treatment of PATH_TRANSLATED is different from the one of CGI specs.
! 1958: * TODO: this code should be checked against cgi.fix_pathinfo php
! 1959: * parameter.
! 1960: */
! 1961:
! 1962: if (!buffer_is_empty(host->docroot)) {
! 1963: /*
! 1964: * rewrite SCRIPT_FILENAME
! 1965: *
! 1966: */
! 1967:
! 1968: buffer_copy_string_buffer(p->path, host->docroot);
! 1969: buffer_append_string_buffer(p->path, con->uri.path);
! 1970:
! 1971: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SCRIPT_FILENAME"), CONST_BUF_LEN(p->path)),con)
! 1972: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("DOCUMENT_ROOT"), CONST_BUF_LEN(host->docroot)),con)
! 1973: } else {
! 1974: buffer_copy_string_buffer(p->path, con->physical.path);
! 1975:
! 1976: /* cgi.fix_pathinfo need a broken SCRIPT_FILENAME to find out what PATH_INFO is itself
! 1977: *
! 1978: * see src/sapi/cgi_main.c, init_request_info()
! 1979: */
! 1980: if (host->break_scriptfilename_for_php) {
! 1981: buffer_append_string_buffer(p->path, con->request.pathinfo);
! 1982: }
! 1983:
! 1984: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SCRIPT_FILENAME"), CONST_BUF_LEN(p->path)),con)
! 1985: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("DOCUMENT_ROOT"), CONST_BUF_LEN(con->physical.basedir)),con)
! 1986: }
! 1987:
! 1988: if (host->strip_request_uri->used > 1) {
! 1989: /* we need at least one char to strip off */
! 1990: /**
! 1991: * /app1/index/list
! 1992: *
! 1993: * stripping /app1 or /app1/ should lead to
! 1994: *
! 1995: * /index/list
! 1996: *
! 1997: */
! 1998: if ('/' != host->strip_request_uri->ptr[host->strip_request_uri->used - 2]) {
! 1999: /* fix the user-input to have / as last char */
! 2000: buffer_append_string_len(host->strip_request_uri, CONST_STR_LEN("/"));
! 2001: }
! 2002:
! 2003: if (con->request.orig_uri->used >= host->strip_request_uri->used &&
! 2004: 0 == strncmp(con->request.orig_uri->ptr, host->strip_request_uri->ptr, host->strip_request_uri->used - 1)) {
! 2005: /* the left is the same */
! 2006:
! 2007: fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REQUEST_URI"),
! 2008: con->request.orig_uri->ptr + (host->strip_request_uri->used - 2),
! 2009: con->request.orig_uri->used - (host->strip_request_uri->used - 2) - 1);
! 2010: } else {
! 2011: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REQUEST_URI"), CONST_BUF_LEN(con->request.orig_uri)),con)
! 2012: }
! 2013: } else {
! 2014: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REQUEST_URI"), CONST_BUF_LEN(con->request.orig_uri)),con)
! 2015: }
! 2016: if (!buffer_is_equal(con->request.uri, con->request.orig_uri)) {
! 2017: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REDIRECT_URI"), CONST_BUF_LEN(con->request.uri)),con)
! 2018: }
! 2019: if (!buffer_is_empty(con->uri.query)) {
! 2020: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("QUERY_STRING"), CONST_BUF_LEN(con->uri.query)),con)
! 2021: } else {
! 2022: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("QUERY_STRING"), CONST_STR_LEN("")),con)
! 2023: }
! 2024:
! 2025: s = get_http_method_name(con->request.http_method);
! 2026: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REQUEST_METHOD"), s, strlen(s)),con)
! 2027: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("REDIRECT_STATUS"), CONST_STR_LEN("200")),con) /* if php is compiled with --force-redirect */
! 2028: s = get_http_version_name(con->request.http_version);
! 2029: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("SERVER_PROTOCOL"), s, strlen(s)),con)
! 2030:
! 2031: if (buffer_is_equal_caseless_string(con->uri.scheme, CONST_STR_LEN("https"))) {
! 2032: FCGI_ENV_ADD_CHECK(fcgi_env_add(p->fcgi_env, CONST_STR_LEN("HTTPS"), CONST_STR_LEN("on")),con)
! 2033: }
! 2034:
! 2035: FCGI_ENV_ADD_CHECK(fcgi_env_add_request_headers(srv, con, p), con);
! 2036:
! 2037: fcgi_header(&(header), FCGI_PARAMS, request_id, p->fcgi_env->used, 0);
! 2038: buffer_append_memory(b, (const char *)&header, sizeof(header));
! 2039: buffer_append_memory(b, (const char *)p->fcgi_env->ptr, p->fcgi_env->used);
! 2040:
! 2041: fcgi_header(&(header), FCGI_PARAMS, request_id, 0, 0);
! 2042: buffer_append_memory(b, (const char *)&header, sizeof(header));
! 2043:
! 2044: b->used++; /* add virtual \0 */
! 2045: hctx->wb->bytes_in += b->used - 1;
! 2046:
! 2047: if (con->request.content_length) {
! 2048: chunkqueue *req_cq = con->request_content_queue;
! 2049: chunk *req_c;
! 2050: off_t offset;
! 2051:
! 2052: /* something to send ? */
! 2053: for (offset = 0, req_c = req_cq->first; offset != req_cq->bytes_in; ) {
! 2054: off_t weWant = req_cq->bytes_in - offset > FCGI_MAX_LENGTH ? FCGI_MAX_LENGTH : req_cq->bytes_in - offset;
! 2055: off_t written = 0;
! 2056: off_t weHave = 0;
! 2057:
! 2058: /* we announce toWrite octets
! 2059: * now take all the request_content chunks that we need to fill this request
! 2060: * */
! 2061:
! 2062: b = chunkqueue_get_append_buffer(hctx->wb);
! 2063: fcgi_header(&(header), FCGI_STDIN, request_id, weWant, 0);
! 2064: buffer_copy_memory(b, (const char *)&header, sizeof(header));
! 2065: hctx->wb->bytes_in += sizeof(header);
! 2066:
! 2067: if (p->conf.debug > 10) {
! 2068: log_error_write(srv, __FILE__, __LINE__, "soso", "tosend:", offset, "/", req_cq->bytes_in);
! 2069: }
! 2070:
! 2071: for (written = 0; written != weWant; ) {
! 2072: if (p->conf.debug > 10) {
! 2073: log_error_write(srv, __FILE__, __LINE__, "soso", "chunk:", written, "/", weWant);
! 2074: }
! 2075:
! 2076: switch (req_c->type) {
! 2077: case FILE_CHUNK:
! 2078: weHave = req_c->file.length - req_c->offset;
! 2079:
! 2080: if (weHave > weWant - written) weHave = weWant - written;
! 2081:
! 2082: if (p->conf.debug > 10) {
! 2083: log_error_write(srv, __FILE__, __LINE__, "soSosOsb",
! 2084: "sending", weHave, "bytes from (",
! 2085: req_c->offset, "/", req_c->file.length, ")",
! 2086: req_c->file.name);
! 2087: }
! 2088:
! 2089: assert(weHave != 0);
! 2090:
! 2091: chunkqueue_append_file(hctx->wb, req_c->file.name, req_c->offset, weHave);
! 2092:
! 2093: req_c->offset += weHave;
! 2094: req_cq->bytes_out += weHave;
! 2095: written += weHave;
! 2096:
! 2097: hctx->wb->bytes_in += weHave;
! 2098:
! 2099: /* steal the tempfile
! 2100: *
! 2101: * This is tricky:
! 2102: * - we reference the tempfile from the request-content-queue several times
! 2103: * if the req_c is larger than FCGI_MAX_LENGTH
! 2104: * - we can't simply cleanup the request-content-queue as soon as possible
! 2105: * as it would remove the tempfiles
! 2106: * - the idea is to 'steal' the tempfiles and attach the is_temp flag to the last
! 2107: * referencing chunk of the fastcgi-write-queue
! 2108: *
! 2109: * */
! 2110:
! 2111: if (req_c->offset == req_c->file.length) {
! 2112: chunk *c;
! 2113:
! 2114: if (p->conf.debug > 10) {
! 2115: log_error_write(srv, __FILE__, __LINE__, "s", "next chunk");
! 2116: }
! 2117: c = hctx->wb->last;
! 2118:
! 2119: assert(c->type == FILE_CHUNK);
! 2120: assert(req_c->file.is_temp == 1);
! 2121:
! 2122: c->file.is_temp = 1;
! 2123: req_c->file.is_temp = 0;
! 2124:
! 2125: chunkqueue_remove_finished_chunks(req_cq);
! 2126:
! 2127: req_c = req_cq->first;
! 2128: }
! 2129:
! 2130: break;
! 2131: case MEM_CHUNK:
! 2132: /* append to the buffer */
! 2133: weHave = req_c->mem->used - 1 - req_c->offset;
! 2134:
! 2135: if (weHave > weWant - written) weHave = weWant - written;
! 2136:
! 2137: buffer_append_memory(b, req_c->mem->ptr + req_c->offset, weHave);
! 2138:
! 2139: req_c->offset += weHave;
! 2140: req_cq->bytes_out += weHave;
! 2141: written += weHave;
! 2142:
! 2143: hctx->wb->bytes_in += weHave;
! 2144:
! 2145: if (req_c->offset == (off_t) req_c->mem->used - 1) {
! 2146: chunkqueue_remove_finished_chunks(req_cq);
! 2147:
! 2148: req_c = req_cq->first;
! 2149: }
! 2150:
! 2151: break;
! 2152: default:
! 2153: break;
! 2154: }
! 2155: }
! 2156:
! 2157: b->used++; /* add virtual \0 */
! 2158: offset += weWant;
! 2159: }
! 2160: }
! 2161:
! 2162: b = chunkqueue_get_append_buffer(hctx->wb);
! 2163: /* terminate STDIN */
! 2164: fcgi_header(&(header), FCGI_STDIN, request_id, 0, 0);
! 2165: buffer_copy_memory(b, (const char *)&header, sizeof(header));
! 2166: b->used++; /* add virtual \0 */
! 2167:
! 2168: hctx->wb->bytes_in += sizeof(header);
! 2169:
! 2170: return 0;
! 2171: }
! 2172:
! 2173: static int fcgi_response_parse(server *srv, connection *con, plugin_data *p, buffer *in) {
! 2174: char *s, *ns;
! 2175:
! 2176: handler_ctx *hctx = con->plugin_ctx[p->id];
! 2177: fcgi_extension_host *host= hctx->host;
! 2178: int have_sendfile2 = 0;
! 2179: off_t sendfile2_content_length = 0;
! 2180:
! 2181: UNUSED(srv);
! 2182:
! 2183: buffer_copy_string_buffer(p->parse_response, in);
! 2184:
! 2185: /* search for \n */
! 2186: for (s = p->parse_response->ptr; NULL != (ns = strchr(s, '\n')); s = ns + 1) {
! 2187: char *key, *value;
! 2188: int key_len;
! 2189: data_string *ds = NULL;
! 2190:
! 2191: /* a good day. Someone has read the specs and is sending a \r\n to us */
! 2192:
! 2193: if (ns > p->parse_response->ptr &&
! 2194: *(ns-1) == '\r') {
! 2195: *(ns-1) = '\0';
! 2196: }
! 2197:
! 2198: ns[0] = '\0';
! 2199:
! 2200: key = s;
! 2201: if (NULL == (value = strchr(s, ':'))) {
! 2202: /* we expect: "<key>: <value>\n" */
! 2203: continue;
! 2204: }
! 2205:
! 2206: key_len = value - key;
! 2207:
! 2208: value++;
! 2209: /* strip WS */
! 2210: while (*value == ' ' || *value == '\t') value++;
! 2211:
! 2212: if (host->mode != FCGI_AUTHORIZER ||
! 2213: !(con->http_status == 0 ||
! 2214: con->http_status == 200)) {
! 2215: /* authorizers shouldn't affect the response headers sent back to the client */
! 2216:
! 2217: /* don't forward Status: */
! 2218: if (0 != strncasecmp(key, "Status", key_len)) {
! 2219: if (NULL == (ds = (data_string *)array_get_unused_element(con->response.headers, TYPE_STRING))) {
! 2220: ds = data_response_init();
! 2221: }
! 2222: buffer_copy_string_len(ds->key, key, key_len);
! 2223: buffer_copy_string(ds->value, value);
! 2224:
! 2225: array_insert_unique(con->response.headers, (data_unset *)ds);
! 2226: }
! 2227: }
! 2228:
! 2229: switch(key_len) {
! 2230: case 4:
! 2231: if (0 == strncasecmp(key, "Date", key_len)) {
! 2232: con->parsed_response |= HTTP_DATE;
! 2233: }
! 2234: break;
! 2235: case 6:
! 2236: if (0 == strncasecmp(key, "Status", key_len)) {
! 2237: con->http_status = strtol(value, NULL, 10);
! 2238: con->parsed_response |= HTTP_STATUS;
! 2239: }
! 2240: break;
! 2241: case 8:
! 2242: if (0 == strncasecmp(key, "Location", key_len)) {
! 2243: con->parsed_response |= HTTP_LOCATION;
! 2244: }
! 2245: break;
! 2246: case 10:
! 2247: if (0 == strncasecmp(key, "Connection", key_len)) {
! 2248: con->response.keep_alive = (0 == strcasecmp(value, "Keep-Alive")) ? 1 : 0;
! 2249: con->parsed_response |= HTTP_CONNECTION;
! 2250: }
! 2251: break;
! 2252: case 11:
! 2253: if (host->allow_xsendfile && 0 == strncasecmp(key, "X-Sendfile2", key_len)&& hctx->send_content_body) {
! 2254: char *pos = value;
! 2255: have_sendfile2 = 1;
! 2256:
! 2257: while (*pos) {
! 2258: char *filename, *range;
! 2259: stat_cache_entry *sce;
! 2260: off_t begin_range, end_range, range_len;
! 2261:
! 2262: while (' ' == *pos) pos++;
! 2263: if (!*pos) break;
! 2264:
! 2265: filename = pos;
! 2266: if (NULL == (range = strchr(pos, ' '))) {
! 2267: /* missing range */
! 2268: if (p->conf.debug) {
! 2269: log_error_write(srv, __FILE__, __LINE__, "ss", "Couldn't find range after filename:", filename);
! 2270: }
! 2271: return 1;
! 2272: }
! 2273: buffer_copy_string_len(srv->tmp_buf, filename, range - filename);
! 2274:
! 2275: /* find end of range */
! 2276: for (pos = ++range; *pos && *pos != ' ' && *pos != ','; pos++) ;
! 2277:
! 2278: buffer_urldecode_path(srv->tmp_buf);
! 2279: if (HANDLER_ERROR == stat_cache_get_entry(srv, con, srv->tmp_buf, &sce)) {
! 2280: if (p->conf.debug) {
! 2281: log_error_write(srv, __FILE__, __LINE__, "sb",
! 2282: "send-file error: couldn't get stat_cache entry for X-Sendfile2:",
! 2283: srv->tmp_buf);
! 2284: }
! 2285: return 1;
! 2286: } else if (!S_ISREG(sce->st.st_mode)) {
! 2287: if (p->conf.debug) {
! 2288: log_error_write(srv, __FILE__, __LINE__, "sb",
! 2289: "send-file error: wrong filetype for X-Sendfile2:",
! 2290: srv->tmp_buf);
! 2291: }
! 2292: return 1;
! 2293: }
! 2294: /* found the file */
! 2295:
! 2296: /* parse range */
! 2297: begin_range = 0; end_range = sce->st.st_size - 1;
! 2298: {
! 2299: char *rpos = NULL;
! 2300: errno = 0;
! 2301: begin_range = strtoll(range, &rpos, 10);
! 2302: if (errno != 0 || begin_range < 0 || rpos == range) goto range_failed;
! 2303: if ('-' != *rpos++) goto range_failed;
! 2304: if (rpos != pos) {
! 2305: range = rpos;
! 2306: end_range = strtoll(range, &rpos, 10);
! 2307: if (errno != 0 || end_range < 0 || rpos == range) goto range_failed;
! 2308: }
! 2309: if (rpos != pos) goto range_failed;
! 2310:
! 2311: goto range_success;
! 2312:
! 2313: range_failed:
! 2314: if (p->conf.debug) {
! 2315: log_error_write(srv, __FILE__, __LINE__, "ss", "Couldn't decode range after filename:", filename);
! 2316: }
! 2317: return 1;
! 2318:
! 2319: range_success: ;
! 2320: }
! 2321:
! 2322: /* no parameters accepted */
! 2323:
! 2324: while (*pos == ' ') pos++;
! 2325: if (*pos != '\0' && *pos != ',') return 1;
! 2326:
! 2327: range_len = end_range - begin_range + 1;
! 2328: if (range_len < 0) return 1;
! 2329: if (range_len != 0) {
! 2330: http_chunk_append_file(srv, con, srv->tmp_buf, begin_range, range_len);
! 2331: }
! 2332: sendfile2_content_length += range_len;
! 2333:
! 2334: if (*pos == ',') pos++;
! 2335: }
! 2336: }
! 2337: break;
! 2338: case 14:
! 2339: if (0 == strncasecmp(key, "Content-Length", key_len)) {
! 2340: con->response.content_length = strtol(value, NULL, 10);
! 2341: con->parsed_response |= HTTP_CONTENT_LENGTH;
! 2342:
! 2343: if (con->response.content_length < 0) con->response.content_length = 0;
! 2344: }
! 2345: break;
! 2346: default:
! 2347: break;
! 2348: }
! 2349: }
! 2350:
! 2351: if (have_sendfile2) {
! 2352: data_string *dcls;
! 2353:
! 2354: hctx->send_content_body = 0;
! 2355: joblist_append(srv, con);
! 2356:
! 2357: /* fix content-length */
! 2358: if (NULL == (dcls = (data_string *)array_get_unused_element(con->response.headers, TYPE_STRING))) {
! 2359: dcls = data_response_init();
! 2360: }
! 2361:
! 2362: buffer_copy_string_len(dcls->key, "Content-Length", sizeof("Content-Length")-1);
! 2363: buffer_copy_off_t(dcls->value, sendfile2_content_length);
! 2364: dcls = (data_string*) array_replace(con->response.headers, (data_unset *)dcls);
! 2365: if (dcls) dcls->free((data_unset*)dcls);
! 2366:
! 2367: con->parsed_response |= HTTP_CONTENT_LENGTH;
! 2368: con->response.content_length = sendfile2_content_length;
! 2369: }
! 2370:
! 2371: /* CGI/1.1 rev 03 - 7.2.1.2 */
! 2372: if ((con->parsed_response & HTTP_LOCATION) &&
! 2373: !(con->parsed_response & HTTP_STATUS)) {
! 2374: con->http_status = 302;
! 2375: }
! 2376:
! 2377: return 0;
! 2378: }
! 2379:
! 2380: typedef struct {
! 2381: buffer *b;
! 2382: size_t len;
! 2383: int type;
! 2384: int padding;
! 2385: size_t request_id;
! 2386: } fastcgi_response_packet;
! 2387:
! 2388: static int fastcgi_get_packet(server *srv, handler_ctx *hctx, fastcgi_response_packet *packet) {
! 2389: chunk * c;
! 2390: size_t offset;
! 2391: size_t toread;
! 2392: FCGI_Header *header;
! 2393:
! 2394: if (!hctx->rb->first) return -1;
! 2395:
! 2396: packet->b = buffer_init();
! 2397: packet->len = 0;
! 2398: packet->type = 0;
! 2399: packet->padding = 0;
! 2400: packet->request_id = 0;
! 2401:
! 2402: offset = 0; toread = 8;
! 2403: /* get at least the FastCGI header */
! 2404: for (c = hctx->rb->first; c; c = c->next) {
! 2405: size_t weHave = c->mem->used - c->offset - 1;
! 2406:
! 2407: if (weHave > toread) weHave = toread;
! 2408:
! 2409: if (packet->b->used == 0) {
! 2410: buffer_copy_string_len(packet->b, c->mem->ptr + c->offset, weHave);
! 2411: } else {
! 2412: buffer_append_string_len(packet->b, c->mem->ptr + c->offset, weHave);
! 2413: }
! 2414: toread -= weHave;
! 2415: offset = weHave; /* skip offset bytes in chunk for "real" data */
! 2416:
! 2417: if (0 == toread) break;
! 2418: }
! 2419:
! 2420: if ((packet->b->used == 0) ||
! 2421: (packet->b->used - 1 < sizeof(FCGI_Header))) {
! 2422: /* no header */
! 2423: buffer_free(packet->b);
! 2424:
! 2425: if (hctx->plugin_data->conf.debug) {
! 2426: log_error_write(srv, __FILE__, __LINE__, "sdsds", "FastCGI: header too small:", packet->b->used, "bytes <", sizeof(FCGI_Header), "bytes, waiting for more data");
! 2427: }
! 2428: return -1;
! 2429: }
! 2430:
! 2431: /* we have at least a header, now check how much me have to fetch */
! 2432: header = (FCGI_Header *)(packet->b->ptr);
! 2433:
! 2434: packet->len = (header->contentLengthB0 | (header->contentLengthB1 << 8)) + header->paddingLength;
! 2435: packet->request_id = (header->requestIdB0 | (header->requestIdB1 << 8));
! 2436: packet->type = header->type;
! 2437: packet->padding = header->paddingLength;
! 2438:
! 2439: /* ->b should only be the content */
! 2440: buffer_copy_string_len(packet->b, CONST_STR_LEN("")); /* used == 1 */
! 2441:
! 2442: if (packet->len) {
! 2443: /* copy the content */
! 2444: for (; c && (packet->b->used < packet->len + 1); c = c->next) {
! 2445: size_t weWant = packet->len - (packet->b->used - 1);
! 2446: size_t weHave = c->mem->used - c->offset - offset - 1;
! 2447:
! 2448: if (weHave > weWant) weHave = weWant;
! 2449:
! 2450: buffer_append_string_len(packet->b, c->mem->ptr + c->offset + offset, weHave);
! 2451:
! 2452: /* we only skipped the first bytes as they belonged to the fcgi header */
! 2453: offset = 0;
! 2454: }
! 2455:
! 2456: if (packet->b->used < packet->len + 1) {
! 2457: /* we didn't get the full packet */
! 2458:
! 2459: buffer_free(packet->b);
! 2460: return -1;
! 2461: }
! 2462:
! 2463: packet->b->used -= packet->padding;
! 2464: packet->b->ptr[packet->b->used - 1] = '\0';
! 2465: }
! 2466:
! 2467: /* tag the chunks as read */
! 2468: toread = packet->len + sizeof(FCGI_Header);
! 2469: for (c = hctx->rb->first; c && toread; c = c->next) {
! 2470: if (c->mem->used - c->offset - 1 <= toread) {
! 2471: /* we read this whole buffer, move it to unused */
! 2472: toread -= c->mem->used - c->offset - 1;
! 2473: c->offset = c->mem->used - 1; /* everthing has been written */
! 2474: } else {
! 2475: c->offset += toread;
! 2476: toread = 0;
! 2477: }
! 2478: }
! 2479:
! 2480: chunkqueue_remove_finished_chunks(hctx->rb);
! 2481:
! 2482: return 0;
! 2483: }
! 2484:
! 2485: static int fcgi_demux_response(server *srv, handler_ctx *hctx) {
! 2486: int fin = 0;
! 2487: int toread;
! 2488: ssize_t r;
! 2489:
! 2490: plugin_data *p = hctx->plugin_data;
! 2491: connection *con = hctx->remote_conn;
! 2492: int fcgi_fd = hctx->fd;
! 2493: fcgi_extension_host *host= hctx->host;
! 2494: fcgi_proc *proc = hctx->proc;
! 2495:
! 2496: /*
! 2497: * check how much we have to read
! 2498: */
! 2499: if (ioctl(hctx->fd, FIONREAD, &toread)) {
! 2500: if (errno == EAGAIN) return 0;
! 2501: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2502: "unexpected end-of-file (perhaps the fastcgi process died):",
! 2503: fcgi_fd);
! 2504: return -1;
! 2505: }
! 2506:
! 2507: /* init read-buffer */
! 2508:
! 2509: if (toread > 0) {
! 2510: buffer *b;
! 2511: chunk *cq_first = hctx->rb->first;
! 2512: chunk *cq_last = hctx->rb->last;
! 2513:
! 2514: b = chunkqueue_get_append_buffer(hctx->rb);
! 2515: buffer_prepare_copy(b, toread + 1);
! 2516:
! 2517: /* append to read-buffer */
! 2518: if (-1 == (r = read(hctx->fd, b->ptr, toread))) {
! 2519: if (errno == EAGAIN) {
! 2520: /* roll back the last chunk allocation,
! 2521: and continue on next iteration */
! 2522: buffer_free(hctx->rb->last->mem);
! 2523: free(hctx->rb->last);
! 2524: hctx->rb->first = cq_first;
! 2525: hctx->rb->last = cq_last;
! 2526: return 0;
! 2527: }
! 2528: log_error_write(srv, __FILE__, __LINE__, "sds",
! 2529: "unexpected end-of-file (perhaps the fastcgi process died):",
! 2530: fcgi_fd, strerror(errno));
! 2531: return -1;
! 2532: }
! 2533:
! 2534: /* this should be catched by the b > 0 above */
! 2535: assert(r);
! 2536:
! 2537: b->used = r + 1; /* one extra for the fake \0 */
! 2538: b->ptr[b->used - 1] = '\0';
! 2539: } else {
! 2540: log_error_write(srv, __FILE__, __LINE__, "ssdsb",
! 2541: "unexpected end-of-file (perhaps the fastcgi process died):",
! 2542: "pid:", proc->pid,
! 2543: "socket:", proc->connection_name);
! 2544:
! 2545: return -1;
! 2546: }
! 2547:
! 2548: /*
! 2549: * parse the fastcgi packets and forward the content to the write-queue
! 2550: *
! 2551: */
! 2552: while (fin == 0) {
! 2553: fastcgi_response_packet packet;
! 2554:
! 2555: /* check if we have at least one packet */
! 2556: if (0 != fastcgi_get_packet(srv, hctx, &packet)) {
! 2557: /* no full packet */
! 2558: break;
! 2559: }
! 2560:
! 2561: switch(packet.type) {
! 2562: case FCGI_STDOUT:
! 2563: if (packet.len == 0) break;
! 2564:
! 2565: /* is the header already finished */
! 2566: if (0 == con->file_started) {
! 2567: char *c;
! 2568: size_t blen;
! 2569: data_string *ds;
! 2570:
! 2571: /* search for header terminator
! 2572: *
! 2573: * if we start with \r\n check if last packet terminated with \r\n
! 2574: * if we start with \n check if last packet terminated with \n
! 2575: * search for \r\n\r\n
! 2576: * search for \n\n
! 2577: */
! 2578:
! 2579: if (hctx->response_header->used == 0) {
! 2580: buffer_copy_string_buffer(hctx->response_header, packet.b);
! 2581: } else {
! 2582: buffer_append_string_buffer(hctx->response_header, packet.b);
! 2583: }
! 2584:
! 2585: if (NULL != (c = buffer_search_string_len(hctx->response_header, CONST_STR_LEN("\r\n\r\n")))) {
! 2586: blen = hctx->response_header->used - (c - hctx->response_header->ptr) - 4;
! 2587: hctx->response_header->used = (c - hctx->response_header->ptr) + 3;
! 2588: c += 4; /* point the the start of the response */
! 2589: } else if (NULL != (c = buffer_search_string_len(hctx->response_header, CONST_STR_LEN("\n\n")))) {
! 2590: blen = hctx->response_header->used - (c - hctx->response_header->ptr) - 2;
! 2591: hctx->response_header->used = c - hctx->response_header->ptr + 2;
! 2592: c += 2; /* point the the start of the response */
! 2593: } else {
! 2594: /* no luck, no header found */
! 2595: break;
! 2596: }
! 2597:
! 2598: /* parse the response header */
! 2599: if (fcgi_response_parse(srv, con, p, hctx->response_header)) {
! 2600: con->http_status = 502;
! 2601: hctx->send_content_body = 0;
! 2602: con->file_started = 1;
! 2603: break;
! 2604: }
! 2605:
! 2606: con->file_started = 1;
! 2607:
! 2608: if (host->mode == FCGI_AUTHORIZER &&
! 2609: (con->http_status == 0 ||
! 2610: con->http_status == 200)) {
! 2611: /* a authorizer with approved the static request, ignore the content here */
! 2612: hctx->send_content_body = 0;
! 2613: }
! 2614:
! 2615: if (host->allow_xsendfile && hctx->send_content_body &&
! 2616: (NULL != (ds = (data_string *) array_get_element(con->response.headers, "X-LIGHTTPD-send-file"))
! 2617: || NULL != (ds = (data_string *) array_get_element(con->response.headers, "X-Sendfile")))) {
! 2618: stat_cache_entry *sce;
! 2619:
! 2620: if (HANDLER_ERROR != stat_cache_get_entry(srv, con, ds->value, &sce)) {
! 2621: data_string *dcls;
! 2622: if (NULL == (dcls = (data_string *)array_get_unused_element(con->response.headers, TYPE_STRING))) {
! 2623: dcls = data_response_init();
! 2624: }
! 2625: /* found */
! 2626: http_chunk_append_file(srv, con, ds->value, 0, sce->st.st_size);
! 2627: hctx->send_content_body = 0; /* ignore the content */
! 2628: joblist_append(srv, con);
! 2629:
! 2630: buffer_copy_string_len(dcls->key, "Content-Length", sizeof("Content-Length")-1);
! 2631: buffer_copy_off_t(dcls->value, sce->st.st_size);
! 2632: dcls = (data_string*) array_replace(con->response.headers, (data_unset *)dcls);
! 2633: if (dcls) dcls->free((data_unset*)dcls);
! 2634:
! 2635: con->parsed_response |= HTTP_CONTENT_LENGTH;
! 2636: con->response.content_length = sce->st.st_size;
! 2637: } else {
! 2638: log_error_write(srv, __FILE__, __LINE__, "sb",
! 2639: "send-file error: couldn't get stat_cache entry for:",
! 2640: ds->value);
! 2641: con->http_status = 502;
! 2642: hctx->send_content_body = 0;
! 2643: con->file_started = 1;
! 2644: break;
! 2645: }
! 2646: }
! 2647:
! 2648:
! 2649: if (hctx->send_content_body && blen > 1) {
! 2650: /* enable chunked-transfer-encoding */
! 2651: if (con->request.http_version == HTTP_VERSION_1_1 &&
! 2652: !(con->parsed_response & HTTP_CONTENT_LENGTH)) {
! 2653: con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
! 2654: }
! 2655:
! 2656: http_chunk_append_mem(srv, con, c, blen);
! 2657: joblist_append(srv, con);
! 2658: }
! 2659: } else if (hctx->send_content_body && packet.b->used > 1) {
! 2660: if (con->request.http_version == HTTP_VERSION_1_1 &&
! 2661: !(con->parsed_response & HTTP_CONTENT_LENGTH)) {
! 2662: /* enable chunked-transfer-encoding */
! 2663: con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
! 2664: }
! 2665:
! 2666: http_chunk_append_mem(srv, con, packet.b->ptr, packet.b->used);
! 2667: joblist_append(srv, con);
! 2668: }
! 2669: break;
! 2670: case FCGI_STDERR:
! 2671: if (packet.len == 0) break;
! 2672:
! 2673: log_error_write_multiline_buffer(srv, __FILE__, __LINE__, packet.b, "s",
! 2674: "FastCGI-stderr:");
! 2675:
! 2676: break;
! 2677: case FCGI_END_REQUEST:
! 2678: con->file_finished = 1;
! 2679:
! 2680: if (host->mode != FCGI_AUTHORIZER ||
! 2681: !(con->http_status == 0 ||
! 2682: con->http_status == 200)) {
! 2683: /* send chunk-end if necessary */
! 2684: http_chunk_append_mem(srv, con, NULL, 0);
! 2685: joblist_append(srv, con);
! 2686: }
! 2687:
! 2688: fin = 1;
! 2689: break;
! 2690: default:
! 2691: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2692: "FastCGI: header.type not handled: ", packet.type);
! 2693: break;
! 2694: }
! 2695: buffer_free(packet.b);
! 2696: }
! 2697:
! 2698: return fin;
! 2699: }
! 2700:
! 2701: static int fcgi_restart_dead_procs(server *srv, plugin_data *p, fcgi_extension_host *host) {
! 2702: fcgi_proc *proc;
! 2703:
! 2704: for (proc = host->first; proc; proc = proc->next) {
! 2705: int status;
! 2706:
! 2707: if (p->conf.debug > 2) {
! 2708: log_error_write(srv, __FILE__, __LINE__, "sbdddd",
! 2709: "proc:",
! 2710: proc->connection_name,
! 2711: proc->state,
! 2712: proc->is_local,
! 2713: proc->load,
! 2714: proc->pid);
! 2715: }
! 2716:
! 2717: /*
! 2718: * if the remote side is overloaded, we check back after <n> seconds
! 2719: *
! 2720: */
! 2721: switch (proc->state) {
! 2722: case PROC_STATE_KILLED:
! 2723: case PROC_STATE_UNSET:
! 2724: /* this should never happen as long as adaptive spawing is disabled */
! 2725: assert(0);
! 2726:
! 2727: break;
! 2728: case PROC_STATE_RUNNING:
! 2729: break;
! 2730: case PROC_STATE_OVERLOADED:
! 2731: if (srv->cur_ts <= proc->disabled_until) break;
! 2732:
! 2733: proc->state = PROC_STATE_RUNNING;
! 2734: host->active_procs++;
! 2735:
! 2736: log_error_write(srv, __FILE__, __LINE__, "sbdb",
! 2737: "fcgi-server re-enabled:",
! 2738: host->host, host->port,
! 2739: host->unixsocket);
! 2740: break;
! 2741: case PROC_STATE_DIED_WAIT_FOR_PID:
! 2742: /* non-local procs don't have PIDs to wait for */
! 2743: if (!proc->is_local) {
! 2744: proc->state = PROC_STATE_DIED;
! 2745: } else {
! 2746: /* the child should not terminate at all */
! 2747:
! 2748: for ( ;; ) {
! 2749: switch(waitpid(proc->pid, &status, WNOHANG)) {
! 2750: case 0:
! 2751: /* child is still alive */
! 2752: if (srv->cur_ts <= proc->disabled_until) break;
! 2753:
! 2754: proc->state = PROC_STATE_RUNNING;
! 2755: host->active_procs++;
! 2756:
! 2757: log_error_write(srv, __FILE__, __LINE__, "sbdb",
! 2758: "fcgi-server re-enabled:",
! 2759: host->host, host->port,
! 2760: host->unixsocket);
! 2761: break;
! 2762: case -1:
! 2763: if (errno == EINTR) continue;
! 2764:
! 2765: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2766: "child died somehow, waitpid failed:",
! 2767: errno);
! 2768: proc->state = PROC_STATE_DIED;
! 2769: break;
! 2770: default:
! 2771: if (WIFEXITED(status)) {
! 2772: #if 0
! 2773: log_error_write(srv, __FILE__, __LINE__, "sdsd",
! 2774: "child exited, pid:", proc->pid,
! 2775: "status:", WEXITSTATUS(status));
! 2776: #endif
! 2777: } else if (WIFSIGNALED(status)) {
! 2778: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2779: "child signaled:",
! 2780: WTERMSIG(status));
! 2781: } else {
! 2782: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2783: "child died somehow:",
! 2784: status);
! 2785: }
! 2786:
! 2787: proc->state = PROC_STATE_DIED;
! 2788: break;
! 2789: }
! 2790: break;
! 2791: }
! 2792: }
! 2793:
! 2794: /* fall through if we have a dead proc now */
! 2795: if (proc->state != PROC_STATE_DIED) break;
! 2796:
! 2797: case PROC_STATE_DIED:
! 2798: /* local procs get restarted by us,
! 2799: * remote ones hopefully by the admin */
! 2800:
! 2801: if (!buffer_is_empty(host->bin_path)) {
! 2802: /* we still have connections bound to this proc,
! 2803: * let them terminate first */
! 2804: if (proc->load != 0) break;
! 2805:
! 2806: /* restart the child */
! 2807:
! 2808: if (p->conf.debug) {
! 2809: log_error_write(srv, __FILE__, __LINE__, "ssbsdsd",
! 2810: "--- fastcgi spawning",
! 2811: "\n\tsocket", proc->connection_name,
! 2812: "\n\tcurrent:", 1, "/", host->max_procs);
! 2813: }
! 2814:
! 2815: if (fcgi_spawn_connection(srv, p, host, proc)) {
! 2816: log_error_write(srv, __FILE__, __LINE__, "s",
! 2817: "ERROR: spawning fcgi failed.");
! 2818: return HANDLER_ERROR;
! 2819: }
! 2820: } else {
! 2821: if (srv->cur_ts <= proc->disabled_until) break;
! 2822:
! 2823: proc->state = PROC_STATE_RUNNING;
! 2824: host->active_procs++;
! 2825:
! 2826: log_error_write(srv, __FILE__, __LINE__, "sb",
! 2827: "fcgi-server re-enabled:",
! 2828: proc->connection_name);
! 2829: }
! 2830: break;
! 2831: }
! 2832: }
! 2833:
! 2834: return 0;
! 2835: }
! 2836:
! 2837: static handler_t fcgi_write_request(server *srv, handler_ctx *hctx) {
! 2838: plugin_data *p = hctx->plugin_data;
! 2839: fcgi_extension_host *host= hctx->host;
! 2840: connection *con = hctx->remote_conn;
! 2841: fcgi_proc *proc;
! 2842:
! 2843: int ret;
! 2844:
! 2845: /* sanity check:
! 2846: * - host != NULL
! 2847: * - either:
! 2848: * - tcp socket (do not check host->host->uses, as it may be not set which means INADDR_LOOPBACK)
! 2849: * - unix socket
! 2850: */
! 2851: if (!host) {
! 2852: log_error_write(srv, __FILE__, __LINE__, "s", "fatal error: host = NULL");
! 2853: return HANDLER_ERROR;
! 2854: }
! 2855: if ((!host->port && !host->unixsocket->used)) {
! 2856: log_error_write(srv, __FILE__, __LINE__, "s", "fatal error: neither host->port nor host->unixsocket is set");
! 2857: return HANDLER_ERROR;
! 2858: }
! 2859:
! 2860: /* we can't handle this in the switch as we have to fall through in it */
! 2861: if (hctx->state == FCGI_STATE_CONNECT_DELAYED) {
! 2862: int socket_error;
! 2863: socklen_t socket_error_len = sizeof(socket_error);
! 2864:
! 2865: /* try to finish the connect() */
! 2866: if (0 != getsockopt(hctx->fd, SOL_SOCKET, SO_ERROR, &socket_error, &socket_error_len)) {
! 2867: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2868: "getsockopt failed:", strerror(errno));
! 2869:
! 2870: fcgi_host_disable(srv, hctx);
! 2871:
! 2872: return HANDLER_ERROR;
! 2873: }
! 2874: if (socket_error != 0) {
! 2875: if (!hctx->proc->is_local || p->conf.debug) {
! 2876: /* local procs get restarted */
! 2877:
! 2878: log_error_write(srv, __FILE__, __LINE__, "sssb",
! 2879: "establishing connection failed:", strerror(socket_error),
! 2880: "socket:", hctx->proc->connection_name);
! 2881: }
! 2882:
! 2883: fcgi_host_disable(srv, hctx);
! 2884: log_error_write(srv, __FILE__, __LINE__, "sdssdsd",
! 2885: "backend is overloaded; we'll disable it for", hctx->host->disable_time, "seconds and send the request to another backend instead:",
! 2886: "reconnects:", hctx->reconnects,
! 2887: "load:", host->load);
! 2888:
! 2889: fastcgi_status_copy_procname(p->statuskey, hctx->host, hctx->proc);
! 2890: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".died"));
! 2891:
! 2892: status_counter_inc(srv, CONST_BUF_LEN(p->statuskey));
! 2893:
! 2894: return HANDLER_ERROR;
! 2895: }
! 2896: /* go on with preparing the request */
! 2897: hctx->state = FCGI_STATE_PREPARE_WRITE;
! 2898: }
! 2899:
! 2900:
! 2901: switch(hctx->state) {
! 2902: case FCGI_STATE_CONNECT_DELAYED:
! 2903: /* should never happen */
! 2904: break;
! 2905: case FCGI_STATE_INIT:
! 2906: /* do we have a running process for this host (max-procs) ? */
! 2907: hctx->proc = NULL;
! 2908:
! 2909: for (proc = hctx->host->first;
! 2910: proc && proc->state != PROC_STATE_RUNNING;
! 2911: proc = proc->next);
! 2912:
! 2913: /* all children are dead */
! 2914: if (proc == NULL) {
! 2915: hctx->fde_ndx = -1;
! 2916:
! 2917: return HANDLER_ERROR;
! 2918: }
! 2919:
! 2920: hctx->proc = proc;
! 2921:
! 2922: /* check the other procs if they have a lower load */
! 2923: for (proc = proc->next; proc; proc = proc->next) {
! 2924: if (proc->state != PROC_STATE_RUNNING) continue;
! 2925: if (proc->load < hctx->proc->load) hctx->proc = proc;
! 2926: }
! 2927:
! 2928: ret = host->unixsocket->used ? AF_UNIX : AF_INET;
! 2929:
! 2930: if (-1 == (hctx->fd = socket(ret, SOCK_STREAM, 0))) {
! 2931: if (errno == EMFILE ||
! 2932: errno == EINTR) {
! 2933: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2934: "wait for fd at connection:", con->fd);
! 2935:
! 2936: return HANDLER_WAIT_FOR_FD;
! 2937: }
! 2938:
! 2939: log_error_write(srv, __FILE__, __LINE__, "ssdd",
! 2940: "socket failed:", strerror(errno), srv->cur_fds, srv->max_fds);
! 2941: return HANDLER_ERROR;
! 2942: }
! 2943: hctx->fde_ndx = -1;
! 2944:
! 2945: srv->cur_fds++;
! 2946:
! 2947: fdevent_register(srv->ev, hctx->fd, fcgi_handle_fdevent, hctx);
! 2948:
! 2949: if (-1 == fdevent_fcntl_set(srv->ev, hctx->fd)) {
! 2950: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2951: "fcntl failed:", strerror(errno));
! 2952:
! 2953: return HANDLER_ERROR;
! 2954: }
! 2955:
! 2956: if (hctx->proc->is_local) {
! 2957: hctx->pid = hctx->proc->pid;
! 2958: }
! 2959:
! 2960: switch (fcgi_establish_connection(srv, hctx)) {
! 2961: case CONNECTION_DELAYED:
! 2962: /* connection is in progress, wait for an event and call getsockopt() below */
! 2963:
! 2964: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
! 2965:
! 2966: fcgi_set_state(srv, hctx, FCGI_STATE_CONNECT_DELAYED);
! 2967: return HANDLER_WAIT_FOR_EVENT;
! 2968: case CONNECTION_OVERLOADED:
! 2969: /* cool down the backend, it is overloaded
! 2970: * -> EAGAIN */
! 2971:
! 2972: if (hctx->host->disable_time) {
! 2973: log_error_write(srv, __FILE__, __LINE__, "sdssdsd",
! 2974: "backend is overloaded; we'll disable it for", hctx->host->disable_time, "seconds and send the request to another backend instead:",
! 2975: "reconnects:", hctx->reconnects,
! 2976: "load:", host->load);
! 2977:
! 2978: hctx->proc->disabled_until = srv->cur_ts + hctx->host->disable_time;
! 2979: if (hctx->proc->state == PROC_STATE_RUNNING) hctx->host->active_procs--;
! 2980: hctx->proc->state = PROC_STATE_OVERLOADED;
! 2981: }
! 2982:
! 2983: fastcgi_status_copy_procname(p->statuskey, hctx->host, hctx->proc);
! 2984: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".overloaded"));
! 2985:
! 2986: status_counter_inc(srv, CONST_BUF_LEN(p->statuskey));
! 2987:
! 2988: return HANDLER_ERROR;
! 2989: case CONNECTION_DEAD:
! 2990: /* we got a hard error from the backend like
! 2991: * - ECONNREFUSED for tcp-ip sockets
! 2992: * - ENOENT for unix-domain-sockets
! 2993: *
! 2994: * for check if the host is back in hctx->host->disable_time seconds
! 2995: * */
! 2996:
! 2997: fcgi_host_disable(srv, hctx);
! 2998:
! 2999: log_error_write(srv, __FILE__, __LINE__, "sdssdsd",
! 3000: "backend died; we'll disable it for", hctx->host->disable_time, "seconds and send the request to another backend instead:",
! 3001: "reconnects:", hctx->reconnects,
! 3002: "load:", host->load);
! 3003:
! 3004: fastcgi_status_copy_procname(p->statuskey, hctx->host, hctx->proc);
! 3005: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".died"));
! 3006:
! 3007: status_counter_inc(srv, CONST_BUF_LEN(p->statuskey));
! 3008:
! 3009: return HANDLER_ERROR;
! 3010: case CONNECTION_OK:
! 3011: /* everything is ok, go on */
! 3012:
! 3013: fcgi_set_state(srv, hctx, FCGI_STATE_PREPARE_WRITE);
! 3014:
! 3015: break;
! 3016: }
! 3017:
! 3018: case FCGI_STATE_PREPARE_WRITE:
! 3019: /* ok, we have the connection */
! 3020:
! 3021: fcgi_proc_load_inc(srv, hctx);
! 3022: hctx->got_proc = 1;
! 3023:
! 3024: status_counter_inc(srv, CONST_STR_LEN("fastcgi.requests"));
! 3025:
! 3026: fastcgi_status_copy_procname(p->statuskey, hctx->host, hctx->proc);
! 3027: buffer_append_string_len(p->statuskey, CONST_STR_LEN(".connected"));
! 3028:
! 3029: status_counter_inc(srv, CONST_BUF_LEN(p->statuskey));
! 3030:
! 3031: if (p->conf.debug) {
! 3032: log_error_write(srv, __FILE__, __LINE__, "ssdsbsd",
! 3033: "got proc:",
! 3034: "pid:", hctx->proc->pid,
! 3035: "socket:", hctx->proc->connection_name,
! 3036: "load:", hctx->proc->load);
! 3037: }
! 3038:
! 3039: /* move the proc-list entry down the list */
! 3040: if (hctx->request_id == 0) {
! 3041: hctx->request_id = 1; /* always use id 1 as we don't use multiplexing */
! 3042: } else {
! 3043: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3044: "fcgi-request is already in use:", hctx->request_id);
! 3045: }
! 3046:
! 3047: /* fall through */
! 3048: if (-1 == fcgi_create_env(srv, hctx, hctx->request_id)) return HANDLER_ERROR;
! 3049: fcgi_set_state(srv, hctx, FCGI_STATE_WRITE);
! 3050: /* fall through */
! 3051: case FCGI_STATE_WRITE:
! 3052: ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb, MAX_WRITE_LIMIT);
! 3053:
! 3054: chunkqueue_remove_finished_chunks(hctx->wb);
! 3055:
! 3056: if (ret < 0) {
! 3057: switch(errno) {
! 3058: case EPIPE:
! 3059: case ENOTCONN:
! 3060: case ECONNRESET:
! 3061: /* the connection got dropped after accept()
! 3062: * we don't care about that - if you accept() it, you have to handle it.
! 3063: */
! 3064:
! 3065: log_error_write(srv, __FILE__, __LINE__, "ssosb",
! 3066: "connection was dropped after accept() (perhaps the fastcgi process died),",
! 3067: "write-offset:", hctx->wb->bytes_out,
! 3068: "socket:", hctx->proc->connection_name);
! 3069:
! 3070: return HANDLER_ERROR;
! 3071: default:
! 3072: log_error_write(srv, __FILE__, __LINE__, "ssd",
! 3073: "write failed:", strerror(errno), errno);
! 3074:
! 3075: return HANDLER_ERROR;
! 3076: }
! 3077: }
! 3078:
! 3079: if (hctx->wb->bytes_out == hctx->wb->bytes_in) {
! 3080: /* we don't need the out event anymore */
! 3081: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
! 3082: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
! 3083: fcgi_set_state(srv, hctx, FCGI_STATE_READ);
! 3084: } else {
! 3085: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
! 3086:
! 3087: return HANDLER_WAIT_FOR_EVENT;
! 3088: }
! 3089:
! 3090: break;
! 3091: case FCGI_STATE_READ:
! 3092: /* waiting for a response */
! 3093: break;
! 3094: default:
! 3095: log_error_write(srv, __FILE__, __LINE__, "s", "(debug) unknown state");
! 3096: return HANDLER_ERROR;
! 3097: }
! 3098:
! 3099: return HANDLER_WAIT_FOR_EVENT;
! 3100: }
! 3101:
! 3102:
! 3103: /* might be called on fdevent after a connect() is delay too
! 3104: * */
! 3105: SUBREQUEST_FUNC(mod_fastcgi_handle_subrequest) {
! 3106: plugin_data *p = p_d;
! 3107:
! 3108: handler_ctx *hctx = con->plugin_ctx[p->id];
! 3109: fcgi_extension_host *host;
! 3110:
! 3111: if (NULL == hctx) return HANDLER_GO_ON;
! 3112:
! 3113: /* not my job */
! 3114: if (con->mode != p->id) return HANDLER_GO_ON;
! 3115:
! 3116: /* we don't have a host yet, choose one
! 3117: * -> this happens in the first round
! 3118: * and when the host died and we have to select a new one */
! 3119: if (hctx->host == NULL) {
! 3120: size_t k;
! 3121: int ndx, used = -1;
! 3122:
! 3123: /* check if the next server has no load. */
! 3124: ndx = hctx->ext->last_used_ndx + 1;
! 3125: if(ndx >= (int) hctx->ext->used || ndx < 0) ndx = 0;
! 3126: host = hctx->ext->hosts[ndx];
! 3127: if (host->load > 0) {
! 3128: /* get backend with the least load. */
! 3129: for (k = 0, ndx = -1; k < hctx->ext->used; k++) {
! 3130: host = hctx->ext->hosts[k];
! 3131:
! 3132: /* we should have at least one proc that can do something */
! 3133: if (host->active_procs == 0) continue;
! 3134:
! 3135: if (used == -1 || host->load < used) {
! 3136: used = host->load;
! 3137:
! 3138: ndx = k;
! 3139: }
! 3140: }
! 3141: }
! 3142:
! 3143: /* found a server */
! 3144: if (ndx == -1) {
! 3145: /* all hosts are down */
! 3146:
! 3147: fcgi_connection_close(srv, hctx);
! 3148:
! 3149: con->http_status = 500;
! 3150: con->mode = DIRECT;
! 3151:
! 3152: return HANDLER_FINISHED;
! 3153: }
! 3154:
! 3155: hctx->ext->last_used_ndx = ndx;
! 3156: host = hctx->ext->hosts[ndx];
! 3157:
! 3158: /*
! 3159: * if check-local is disabled, use the uri.path handler
! 3160: *
! 3161: */
! 3162:
! 3163: /* init handler-context */
! 3164:
! 3165: /* we put a connection on this host, move the other new connections to other hosts
! 3166: *
! 3167: * as soon as hctx->host is unassigned, decrease the load again */
! 3168: fcgi_host_assign(srv, hctx, host);
! 3169: hctx->proc = NULL;
! 3170: } else {
! 3171: host = hctx->host;
! 3172: }
! 3173:
! 3174: /* ok, create the request */
! 3175: switch(fcgi_write_request(srv, hctx)) {
! 3176: case HANDLER_ERROR:
! 3177: host = hctx->host;
! 3178:
! 3179: if (hctx->state == FCGI_STATE_INIT ||
! 3180: hctx->state == FCGI_STATE_CONNECT_DELAYED) {
! 3181: fcgi_restart_dead_procs(srv, p, host);
! 3182:
! 3183: /* cleanup this request and let the request handler start this request again */
! 3184: if (hctx->reconnects < 5) {
! 3185: fcgi_reconnect(srv, hctx);
! 3186: joblist_append(srv, con); /* in case we come from the event-handler */
! 3187:
! 3188: return HANDLER_WAIT_FOR_FD;
! 3189: } else {
! 3190: fcgi_connection_close(srv, hctx);
! 3191:
! 3192: buffer_reset(con->physical.path);
! 3193: con->mode = DIRECT;
! 3194: con->http_status = 503;
! 3195: joblist_append(srv, con); /* in case we come from the event-handler */
! 3196:
! 3197: return HANDLER_FINISHED;
! 3198: }
! 3199: } else {
! 3200: fcgi_connection_close(srv, hctx);
! 3201:
! 3202: buffer_reset(con->physical.path);
! 3203: con->mode = DIRECT;
! 3204: if (con->http_status != 400) con->http_status = 503;
! 3205: joblist_append(srv, con); /* really ? */
! 3206:
! 3207: return HANDLER_FINISHED;
! 3208: }
! 3209: case HANDLER_WAIT_FOR_EVENT:
! 3210: if (con->file_started == 1) {
! 3211: return HANDLER_FINISHED;
! 3212: } else {
! 3213: return HANDLER_WAIT_FOR_EVENT;
! 3214: }
! 3215: case HANDLER_WAIT_FOR_FD:
! 3216: return HANDLER_WAIT_FOR_FD;
! 3217: default:
! 3218: log_error_write(srv, __FILE__, __LINE__, "s", "subrequest write-req default");
! 3219: return HANDLER_ERROR;
! 3220: }
! 3221: }
! 3222:
! 3223: static handler_t fcgi_handle_fdevent(server *srv, void *ctx, int revents) {
! 3224: handler_ctx *hctx = ctx;
! 3225: connection *con = hctx->remote_conn;
! 3226: plugin_data *p = hctx->plugin_data;
! 3227:
! 3228: fcgi_proc *proc = hctx->proc;
! 3229: fcgi_extension_host *host= hctx->host;
! 3230:
! 3231: if ((revents & FDEVENT_IN) &&
! 3232: hctx->state == FCGI_STATE_READ) {
! 3233: switch (fcgi_demux_response(srv, hctx)) {
! 3234: case 0:
! 3235: break;
! 3236: case 1:
! 3237:
! 3238: if (host->mode == FCGI_AUTHORIZER &&
! 3239: (con->http_status == 200 ||
! 3240: con->http_status == 0)) {
! 3241: /*
! 3242: * If we are here in AUTHORIZER mode then a request for authorizer
! 3243: * was processed already, and status 200 has been returned. We need
! 3244: * now to handle authorized request.
! 3245: */
! 3246:
! 3247: buffer_copy_string_buffer(con->physical.doc_root, host->docroot);
! 3248: buffer_copy_string_buffer(con->physical.basedir, host->docroot);
! 3249:
! 3250: buffer_copy_string_buffer(con->physical.path, host->docroot);
! 3251: buffer_append_string_buffer(con->physical.path, con->uri.path);
! 3252: fcgi_connection_close(srv, hctx);
! 3253:
! 3254: con->mode = DIRECT;
! 3255: con->http_status = 0;
! 3256: con->file_started = 1; /* fcgi_extension won't touch the request afterwards */
! 3257: } else {
! 3258: /* we are done */
! 3259: fcgi_connection_close(srv, hctx);
! 3260: }
! 3261:
! 3262: joblist_append(srv, con);
! 3263: return HANDLER_FINISHED;
! 3264: case -1:
! 3265: if (proc->pid && proc->state != PROC_STATE_DIED) {
! 3266: int status;
! 3267:
! 3268: /* only fetch the zombie if it is not already done */
! 3269:
! 3270: switch(waitpid(proc->pid, &status, WNOHANG)) {
! 3271: case 0:
! 3272: /* child is still alive */
! 3273: break;
! 3274: case -1:
! 3275: break;
! 3276: default:
! 3277: /* the child should not terminate at all */
! 3278: if (WIFEXITED(status)) {
! 3279: log_error_write(srv, __FILE__, __LINE__, "sdsd",
! 3280: "child exited, pid:", proc->pid,
! 3281: "status:", WEXITSTATUS(status));
! 3282: } else if (WIFSIGNALED(status)) {
! 3283: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3284: "child signaled:",
! 3285: WTERMSIG(status));
! 3286: } else {
! 3287: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3288: "child died somehow:",
! 3289: status);
! 3290: }
! 3291:
! 3292: if (p->conf.debug) {
! 3293: log_error_write(srv, __FILE__, __LINE__, "ssbsdsd",
! 3294: "--- fastcgi spawning",
! 3295: "\n\tsocket", proc->connection_name,
! 3296: "\n\tcurrent:", 1, "/", host->max_procs);
! 3297: }
! 3298:
! 3299: if (fcgi_spawn_connection(srv, p, host, proc)) {
! 3300: /* respawning failed, retry later */
! 3301: proc->state = PROC_STATE_DIED;
! 3302:
! 3303: log_error_write(srv, __FILE__, __LINE__, "s",
! 3304: "respawning failed, will retry later");
! 3305: }
! 3306:
! 3307: break;
! 3308: }
! 3309: }
! 3310:
! 3311: if (con->file_started == 0) {
! 3312: /* nothing has been sent out yet, try to use another child */
! 3313:
! 3314: if (hctx->wb->bytes_out == 0 &&
! 3315: hctx->reconnects < 5) {
! 3316: fcgi_reconnect(srv, hctx);
! 3317:
! 3318: log_error_write(srv, __FILE__, __LINE__, "ssbsBSBs",
! 3319: "response not received, request not sent",
! 3320: "on socket:", proc->connection_name,
! 3321: "for", con->uri.path, "?", con->uri.query, ", reconnecting");
! 3322:
! 3323: return HANDLER_WAIT_FOR_FD;
! 3324: }
! 3325:
! 3326: log_error_write(srv, __FILE__, __LINE__, "sosbsBSBs",
! 3327: "response not received, request sent:", hctx->wb->bytes_out,
! 3328: "on socket:", proc->connection_name,
! 3329: "for", con->uri.path, "?", con->uri.query, ", closing connection");
! 3330:
! 3331: fcgi_connection_close(srv, hctx);
! 3332:
! 3333: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 3334: buffer_reset(con->physical.path);
! 3335: con->http_status = 500;
! 3336: con->mode = DIRECT;
! 3337: } else {
! 3338: /* response might have been already started, kill the connection */
! 3339: fcgi_connection_close(srv, hctx);
! 3340:
! 3341: log_error_write(srv, __FILE__, __LINE__, "ssbsBSBs",
! 3342: "response already sent out, but backend returned error",
! 3343: "on socket:", proc->connection_name,
! 3344: "for", con->uri.path, "?", con->uri.query, ", terminating connection");
! 3345:
! 3346: connection_set_state(srv, con, CON_STATE_ERROR);
! 3347: }
! 3348:
! 3349: /* */
! 3350:
! 3351:
! 3352: joblist_append(srv, con);
! 3353: return HANDLER_FINISHED;
! 3354: }
! 3355: }
! 3356:
! 3357: if (revents & FDEVENT_OUT) {
! 3358: if (hctx->state == FCGI_STATE_CONNECT_DELAYED ||
! 3359: hctx->state == FCGI_STATE_WRITE) {
! 3360: /* we are allowed to send something out
! 3361: *
! 3362: * 1. in an unfinished connect() call
! 3363: * 2. in an unfinished write() call (long POST request)
! 3364: */
! 3365: return mod_fastcgi_handle_subrequest(srv, con, p);
! 3366: } else {
! 3367: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3368: "got a FDEVENT_OUT and didn't know why:",
! 3369: hctx->state);
! 3370: }
! 3371: }
! 3372:
! 3373: /* perhaps this issue is already handled */
! 3374: if (revents & FDEVENT_HUP) {
! 3375: if (hctx->state == FCGI_STATE_CONNECT_DELAYED) {
! 3376: /* getoptsock will catch this one (right ?)
! 3377: *
! 3378: * if we are in connect we might get an EINPROGRESS
! 3379: * in the first call and an FDEVENT_HUP in the
! 3380: * second round
! 3381: *
! 3382: * FIXME: as it is a bit ugly.
! 3383: *
! 3384: */
! 3385: return mod_fastcgi_handle_subrequest(srv, con, p);
! 3386: } else if (hctx->state == FCGI_STATE_READ &&
! 3387: hctx->proc->port == 0) {
! 3388: /* FIXME:
! 3389: *
! 3390: * ioctl says 8192 bytes to read from PHP and we receive directly a HUP for the socket
! 3391: * even if the FCGI_FIN packet is not received yet
! 3392: */
! 3393: } else {
! 3394: log_error_write(srv, __FILE__, __LINE__, "sBSbsbsd",
! 3395: "error: unexpected close of fastcgi connection for",
! 3396: con->uri.path, "?", con->uri.query,
! 3397: "(no fastcgi process on socket:", proc->connection_name, "?)",
! 3398: hctx->state);
! 3399:
! 3400: connection_set_state(srv, con, CON_STATE_ERROR);
! 3401: fcgi_connection_close(srv, hctx);
! 3402: joblist_append(srv, con);
! 3403: }
! 3404: } else if (revents & FDEVENT_ERR) {
! 3405: log_error_write(srv, __FILE__, __LINE__, "s",
! 3406: "fcgi: got a FDEVENT_ERR. Don't know why.");
! 3407: /* kill all connections to the fastcgi process */
! 3408:
! 3409:
! 3410: connection_set_state(srv, con, CON_STATE_ERROR);
! 3411: fcgi_connection_close(srv, hctx);
! 3412: joblist_append(srv, con);
! 3413: }
! 3414:
! 3415: return HANDLER_FINISHED;
! 3416: }
! 3417: #define PATCH(x) \
! 3418: p->conf.x = s->x;
! 3419: static int fcgi_patch_connection(server *srv, connection *con, plugin_data *p) {
! 3420: size_t i, j;
! 3421: plugin_config *s = p->config_storage[0];
! 3422:
! 3423: PATCH(exts);
! 3424: PATCH(debug);
! 3425: PATCH(ext_mapping);
! 3426:
! 3427: /* skip the first, the global context */
! 3428: for (i = 1; i < srv->config_context->used; i++) {
! 3429: data_config *dc = (data_config *)srv->config_context->data[i];
! 3430: s = p->config_storage[i];
! 3431:
! 3432: /* condition didn't match */
! 3433: if (!config_check_cond(srv, con, dc)) continue;
! 3434:
! 3435: /* merge config */
! 3436: for (j = 0; j < dc->value->used; j++) {
! 3437: data_unset *du = dc->value->data[j];
! 3438:
! 3439: if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.server"))) {
! 3440: PATCH(exts);
! 3441: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.debug"))) {
! 3442: PATCH(debug);
! 3443: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.map-extensions"))) {
! 3444: PATCH(ext_mapping);
! 3445: }
! 3446: }
! 3447: }
! 3448:
! 3449: return 0;
! 3450: }
! 3451: #undef PATCH
! 3452:
! 3453:
! 3454: static handler_t fcgi_check_extension(server *srv, connection *con, void *p_d, int uri_path_handler) {
! 3455: plugin_data *p = p_d;
! 3456: size_t s_len;
! 3457: size_t k;
! 3458: buffer *fn;
! 3459: fcgi_extension *extension = NULL;
! 3460: fcgi_extension_host *host = NULL;
! 3461:
! 3462: if (con->mode != DIRECT) return HANDLER_GO_ON;
! 3463:
! 3464: /* Possibly, we processed already this request */
! 3465: if (con->file_started == 1) return HANDLER_GO_ON;
! 3466:
! 3467: fn = uri_path_handler ? con->uri.path : con->physical.path;
! 3468:
! 3469: if (buffer_is_empty(fn)) return HANDLER_GO_ON;
! 3470:
! 3471: s_len = fn->used - 1;
! 3472:
! 3473: fcgi_patch_connection(srv, con, p);
! 3474:
! 3475: /* fastcgi.map-extensions maps extensions to existing fastcgi.server entries
! 3476: *
! 3477: * fastcgi.map-extensions = ( ".php3" => ".php" )
! 3478: *
! 3479: * fastcgi.server = ( ".php" => ... )
! 3480: *
! 3481: * */
! 3482:
! 3483: /* check if extension-mapping matches */
! 3484: for (k = 0; k < p->conf.ext_mapping->used; k++) {
! 3485: data_string *ds = (data_string *)p->conf.ext_mapping->data[k];
! 3486: size_t ct_len; /* length of the config entry */
! 3487:
! 3488: if (ds->key->used == 0) continue;
! 3489:
! 3490: ct_len = ds->key->used - 1;
! 3491:
! 3492: if (s_len < ct_len) continue;
! 3493:
! 3494: /* found a mapping */
! 3495: if (0 == strncmp(fn->ptr + s_len - ct_len, ds->key->ptr, ct_len)) {
! 3496: /* check if we know the extension */
! 3497:
! 3498: /* we can reuse k here */
! 3499: for (k = 0; k < p->conf.exts->used; k++) {
! 3500: extension = p->conf.exts->exts[k];
! 3501:
! 3502: if (buffer_is_equal(ds->value, extension->key)) {
! 3503: break;
! 3504: }
! 3505: }
! 3506:
! 3507: if (k == p->conf.exts->used) {
! 3508: /* found nothign */
! 3509: extension = NULL;
! 3510: }
! 3511: break;
! 3512: }
! 3513: }
! 3514:
! 3515: if (extension == NULL) {
! 3516: /* check if extension matches */
! 3517: for (k = 0; k < p->conf.exts->used; k++) {
! 3518: size_t ct_len; /* length of the config entry */
! 3519: fcgi_extension *ext = p->conf.exts->exts[k];
! 3520:
! 3521: if (ext->key->used == 0) continue;
! 3522:
! 3523: ct_len = ext->key->used - 1;
! 3524:
! 3525: /* check _url_ in the form "/fcgi_pattern" */
! 3526: if (ext->key->ptr[0] == '/') {
! 3527: if ((ct_len <= con->uri.path->used -1) &&
! 3528: (strncmp(con->uri.path->ptr, ext->key->ptr, ct_len) == 0)) {
! 3529: extension = ext;
! 3530: break;
! 3531: }
! 3532: } else if ((ct_len <= s_len) && (0 == strncmp(fn->ptr + s_len - ct_len, ext->key->ptr, ct_len))) {
! 3533: /* check extension in the form ".fcg" */
! 3534: extension = ext;
! 3535: break;
! 3536: }
! 3537: }
! 3538: /* extension doesn't match */
! 3539: if (NULL == extension) {
! 3540: return HANDLER_GO_ON;
! 3541: }
! 3542: }
! 3543:
! 3544: /* check if we have at least one server for this extension up and running */
! 3545: for (k = 0; k < extension->used; k++) {
! 3546: fcgi_extension_host *h = extension->hosts[k];
! 3547:
! 3548: /* we should have at least one proc that can do something */
! 3549: if (h->active_procs == 0) {
! 3550: continue;
! 3551: }
! 3552:
! 3553: /* we found one host that is alive */
! 3554: host = h;
! 3555: break;
! 3556: }
! 3557:
! 3558: if (!host) {
! 3559: /* sorry, we don't have a server alive for this ext */
! 3560: buffer_reset(con->physical.path);
! 3561: con->http_status = 500;
! 3562:
! 3563: /* only send the 'no handler' once */
! 3564: if (!extension->note_is_sent) {
! 3565: extension->note_is_sent = 1;
! 3566:
! 3567: log_error_write(srv, __FILE__, __LINE__, "sBSbsbs",
! 3568: "all handlers for", con->uri.path, "?", con->uri.query,
! 3569: "on", extension->key,
! 3570: "are down.");
! 3571: }
! 3572:
! 3573: return HANDLER_FINISHED;
! 3574: }
! 3575:
! 3576: /* a note about no handler is not sent yet */
! 3577: extension->note_is_sent = 0;
! 3578:
! 3579: /*
! 3580: * if check-local is disabled, use the uri.path handler
! 3581: *
! 3582: */
! 3583:
! 3584: /* init handler-context */
! 3585: if (uri_path_handler) {
! 3586: if (host->check_local == 0) {
! 3587: handler_ctx *hctx;
! 3588: char *pathinfo;
! 3589:
! 3590: hctx = handler_ctx_init();
! 3591:
! 3592: hctx->remote_conn = con;
! 3593: hctx->plugin_data = p;
! 3594: hctx->proc = NULL;
! 3595: hctx->ext = extension;
! 3596:
! 3597:
! 3598: hctx->conf.exts = p->conf.exts;
! 3599: hctx->conf.debug = p->conf.debug;
! 3600:
! 3601: con->plugin_ctx[p->id] = hctx;
! 3602:
! 3603: con->mode = p->id;
! 3604:
! 3605: if (con->conf.log_request_handling) {
! 3606: log_error_write(srv, __FILE__, __LINE__, "s",
! 3607: "handling it in mod_fastcgi");
! 3608: }
! 3609:
! 3610: /* do not split path info for authorizer */
! 3611: if (host->mode != FCGI_AUTHORIZER) {
! 3612: /* the prefix is the SCRIPT_NAME,
! 3613: * everything from start to the next slash
! 3614: * this is important for check-local = "disable"
! 3615: *
! 3616: * if prefix = /admin.fcgi
! 3617: *
! 3618: * /admin.fcgi/foo/bar
! 3619: *
! 3620: * SCRIPT_NAME = /admin.fcgi
! 3621: * PATH_INFO = /foo/bar
! 3622: *
! 3623: * if prefix = /fcgi-bin/
! 3624: *
! 3625: * /fcgi-bin/foo/bar
! 3626: *
! 3627: * SCRIPT_NAME = /fcgi-bin/foo
! 3628: * PATH_INFO = /bar
! 3629: *
! 3630: * if prefix = /, and fix-root-path-name is enable
! 3631: *
! 3632: * /fcgi-bin/foo/bar
! 3633: *
! 3634: * SCRIPT_NAME = /fcgi-bin/foo
! 3635: * PATH_INFO = /bar
! 3636: *
! 3637: */
! 3638:
! 3639: /* the rewrite is only done for /prefix/? matches */
! 3640: if (host->fix_root_path_name && extension->key->ptr[0] == '/' && extension->key->ptr[1] == '\0') {
! 3641: buffer_copy_string(con->request.pathinfo, con->uri.path->ptr);
! 3642: con->uri.path->used = 1;
! 3643: con->uri.path->ptr[con->uri.path->used - 1] = '\0';
! 3644: } else if (extension->key->ptr[0] == '/' &&
! 3645: con->uri.path->used > extension->key->used &&
! 3646: NULL != (pathinfo = strchr(con->uri.path->ptr + extension->key->used - 1, '/'))) {
! 3647: /* rewrite uri.path and pathinfo */
! 3648:
! 3649: buffer_copy_string(con->request.pathinfo, pathinfo);
! 3650:
! 3651: con->uri.path->used -= con->request.pathinfo->used - 1;
! 3652: con->uri.path->ptr[con->uri.path->used - 1] = '\0';
! 3653: }
! 3654: }
! 3655: }
! 3656: } else {
! 3657: handler_ctx *hctx;
! 3658: hctx = handler_ctx_init();
! 3659:
! 3660: hctx->remote_conn = con;
! 3661: hctx->plugin_data = p;
! 3662: hctx->proc = NULL;
! 3663: hctx->ext = extension;
! 3664:
! 3665: hctx->conf.exts = p->conf.exts;
! 3666: hctx->conf.debug = p->conf.debug;
! 3667:
! 3668: con->plugin_ctx[p->id] = hctx;
! 3669:
! 3670: con->mode = p->id;
! 3671:
! 3672: if (con->conf.log_request_handling) {
! 3673: log_error_write(srv, __FILE__, __LINE__, "s", "handling it in mod_fastcgi");
! 3674: }
! 3675: }
! 3676:
! 3677: return HANDLER_GO_ON;
! 3678: }
! 3679:
! 3680: /* uri-path handler */
! 3681: static handler_t fcgi_check_extension_1(server *srv, connection *con, void *p_d) {
! 3682: return fcgi_check_extension(srv, con, p_d, 1);
! 3683: }
! 3684:
! 3685: /* start request handler */
! 3686: static handler_t fcgi_check_extension_2(server *srv, connection *con, void *p_d) {
! 3687: return fcgi_check_extension(srv, con, p_d, 0);
! 3688: }
! 3689:
! 3690: JOBLIST_FUNC(mod_fastcgi_handle_joblist) {
! 3691: plugin_data *p = p_d;
! 3692: handler_ctx *hctx = con->plugin_ctx[p->id];
! 3693:
! 3694: if (hctx == NULL) return HANDLER_GO_ON;
! 3695:
! 3696: if (hctx->fd != -1) {
! 3697: switch (hctx->state) {
! 3698: case FCGI_STATE_READ:
! 3699: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
! 3700:
! 3701: break;
! 3702: case FCGI_STATE_CONNECT_DELAYED:
! 3703: case FCGI_STATE_WRITE:
! 3704: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
! 3705:
! 3706: break;
! 3707: case FCGI_STATE_INIT:
! 3708: /* at reconnect */
! 3709: break;
! 3710: default:
! 3711: log_error_write(srv, __FILE__, __LINE__, "sd", "unhandled fcgi.state", hctx->state);
! 3712: break;
! 3713: }
! 3714: }
! 3715:
! 3716: return HANDLER_GO_ON;
! 3717: }
! 3718:
! 3719:
! 3720: static handler_t fcgi_connection_close_callback(server *srv, connection *con, void *p_d) {
! 3721: plugin_data *p = p_d;
! 3722:
! 3723: fcgi_connection_close(srv, con->plugin_ctx[p->id]);
! 3724:
! 3725: return HANDLER_GO_ON;
! 3726: }
! 3727:
! 3728: TRIGGER_FUNC(mod_fastcgi_handle_trigger) {
! 3729: plugin_data *p = p_d;
! 3730: size_t i, j, n;
! 3731:
! 3732:
! 3733: /* perhaps we should kill a connect attempt after 10-15 seconds
! 3734: *
! 3735: * currently we wait for the TCP timeout which is 180 seconds on Linux
! 3736: *
! 3737: *
! 3738: *
! 3739: */
! 3740:
! 3741: /* check all children if they are still up */
! 3742:
! 3743: for (i = 0; i < srv->config_context->used; i++) {
! 3744: plugin_config *conf;
! 3745: fcgi_exts *exts;
! 3746:
! 3747: conf = p->config_storage[i];
! 3748:
! 3749: exts = conf->exts;
! 3750:
! 3751: for (j = 0; j < exts->used; j++) {
! 3752: fcgi_extension *ex;
! 3753:
! 3754: ex = exts->exts[j];
! 3755:
! 3756: for (n = 0; n < ex->used; n++) {
! 3757:
! 3758: fcgi_proc *proc;
! 3759: fcgi_extension_host *host;
! 3760:
! 3761: host = ex->hosts[n];
! 3762:
! 3763: fcgi_restart_dead_procs(srv, p, host);
! 3764:
! 3765: for (proc = host->unused_procs; proc; proc = proc->next) {
! 3766: int status;
! 3767:
! 3768: if (proc->pid == 0) continue;
! 3769:
! 3770: switch (waitpid(proc->pid, &status, WNOHANG)) {
! 3771: case 0:
! 3772: /* child still running after timeout, good */
! 3773: break;
! 3774: case -1:
! 3775: if (errno != EINTR) {
! 3776: /* no PID found ? should never happen */
! 3777: log_error_write(srv, __FILE__, __LINE__, "sddss",
! 3778: "pid ", proc->pid, proc->state,
! 3779: "not found:", strerror(errno));
! 3780:
! 3781: #if 0
! 3782: if (errno == ECHILD) {
! 3783: /* someone else has cleaned up for us */
! 3784: proc->pid = 0;
! 3785: proc->state = PROC_STATE_UNSET;
! 3786: }
! 3787: #endif
! 3788: }
! 3789: break;
! 3790: default:
! 3791: /* the child should not terminate at all */
! 3792: if (WIFEXITED(status)) {
! 3793: if (proc->state != PROC_STATE_KILLED) {
! 3794: log_error_write(srv, __FILE__, __LINE__, "sdb",
! 3795: "child exited:",
! 3796: WEXITSTATUS(status), proc->connection_name);
! 3797: }
! 3798: } else if (WIFSIGNALED(status)) {
! 3799: if (WTERMSIG(status) != SIGTERM) {
! 3800: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3801: "child signaled:",
! 3802: WTERMSIG(status));
! 3803: }
! 3804: } else {
! 3805: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3806: "child died somehow:",
! 3807: status);
! 3808: }
! 3809: proc->pid = 0;
! 3810: if (proc->state == PROC_STATE_RUNNING) host->active_procs--;
! 3811: proc->state = PROC_STATE_UNSET;
! 3812: host->max_id--;
! 3813: }
! 3814: }
! 3815: }
! 3816: }
! 3817: }
! 3818:
! 3819: return HANDLER_GO_ON;
! 3820: }
! 3821:
! 3822:
! 3823: int mod_fastcgi_plugin_init(plugin *p);
! 3824: int mod_fastcgi_plugin_init(plugin *p) {
! 3825: p->version = LIGHTTPD_VERSION_ID;
! 3826: p->name = buffer_init_string("fastcgi");
! 3827:
! 3828: p->init = mod_fastcgi_init;
! 3829: p->cleanup = mod_fastcgi_free;
! 3830: p->set_defaults = mod_fastcgi_set_defaults;
! 3831: p->connection_reset = fcgi_connection_reset;
! 3832: p->handle_connection_close = fcgi_connection_close_callback;
! 3833: p->handle_uri_clean = fcgi_check_extension_1;
! 3834: p->handle_subrequest_start = fcgi_check_extension_2;
! 3835: p->handle_subrequest = mod_fastcgi_handle_subrequest;
! 3836: p->handle_joblist = mod_fastcgi_handle_joblist;
! 3837: p->handle_trigger = mod_fastcgi_handle_trigger;
! 3838:
! 3839: p->data = NULL;
! 3840:
! 3841: return 0;
! 3842: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mod_fastcgi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src