Annotation of embedaddon/lighttpd/src/mod_scgi.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:
! 16: #include <sys/types.h>
! 17: #include <unistd.h>
! 18: #include <errno.h>
! 19: #include <fcntl.h>
! 20: #include <string.h>
! 21: #include <stdlib.h>
! 22: #include <ctype.h>
! 23: #include <assert.h>
! 24: #include <signal.h>
! 25:
! 26: #include <stdio.h>
! 27:
! 28: #ifdef HAVE_SYS_FILIO_H
! 29: # include <sys/filio.h>
! 30: #endif
! 31:
! 32: #include "sys-socket.h"
! 33:
! 34: #ifdef HAVE_SYS_UIO_H
! 35: # include <sys/uio.h>
! 36: #endif
! 37:
! 38: #ifdef HAVE_SYS_WAIT_H
! 39: # include <sys/wait.h>
! 40: #endif
! 41:
! 42: #include "version.h"
! 43:
! 44: enum {EOL_UNSET, EOL_N, EOL_RN};
! 45:
! 46: /*
! 47: *
! 48: * TODO:
! 49: *
! 50: * - add timeout for a connect to a non-scgi process
! 51: * (use state_timestamp + state)
! 52: *
! 53: */
! 54:
! 55: typedef struct scgi_proc {
! 56: size_t id; /* id will be between 1 and max_procs */
! 57: buffer *socket; /* config.socket + "-" + id */
! 58: unsigned port; /* config.port + pno */
! 59:
! 60: pid_t pid; /* PID of the spawned process (0 if not spawned locally) */
! 61:
! 62:
! 63: size_t load; /* number of requests waiting on this process */
! 64:
! 65: time_t last_used; /* see idle_timeout */
! 66: size_t requests; /* see max_requests */
! 67: struct scgi_proc *prev, *next; /* see first */
! 68:
! 69: time_t disable_ts; /* replace by host->something */
! 70:
! 71: int is_local;
! 72:
! 73: enum { PROC_STATE_UNSET, /* init-phase */
! 74: PROC_STATE_RUNNING, /* alive */
! 75: PROC_STATE_DIED_WAIT_FOR_PID,
! 76: PROC_STATE_KILLED, /* was killed as we don't have the load anymore */
! 77: PROC_STATE_DIED, /* marked as dead, should be restarted */
! 78: PROC_STATE_DISABLED /* proc disabled as it resulted in an error */
! 79: } state;
! 80: } scgi_proc;
! 81:
! 82: typedef struct {
! 83: /* list of processes handling this extension
! 84: * sorted by lowest load
! 85: *
! 86: * whenever a job is done move it up in the list
! 87: * until it is sorted, move it down as soon as the
! 88: * job is started
! 89: */
! 90: scgi_proc *first;
! 91: scgi_proc *unused_procs;
! 92:
! 93: /*
! 94: * spawn at least min_procs, at max_procs.
! 95: *
! 96: * as soon as the load of the first entry
! 97: * is max_load_per_proc we spawn a new one
! 98: * and add it to the first entry and give it
! 99: * the load
! 100: *
! 101: */
! 102:
! 103: unsigned short min_procs;
! 104: unsigned short max_procs;
! 105: size_t num_procs; /* how many procs are started */
! 106: size_t active_procs; /* how many of them are really running */
! 107:
! 108: unsigned short max_load_per_proc;
! 109:
! 110: /*
! 111: * kick the process from the list if it was not
! 112: * used for idle_timeout until min_procs is
! 113: * reached. this helps to get the processlist
! 114: * small again we had a small peak load.
! 115: *
! 116: */
! 117:
! 118: unsigned short idle_timeout;
! 119:
! 120: /*
! 121: * time after a disabled remote connection is tried to be re-enabled
! 122: *
! 123: *
! 124: */
! 125:
! 126: unsigned short disable_time;
! 127:
! 128: /*
! 129: * same scgi processes get a little bit larger
! 130: * than wanted. max_requests_per_proc kills a
! 131: * process after a number of handled requests.
! 132: *
! 133: */
! 134: size_t max_requests_per_proc;
! 135:
! 136:
! 137: /* config */
! 138:
! 139: /*
! 140: * host:port
! 141: *
! 142: * if host is one of the local IP adresses the
! 143: * whole connection is local
! 144: *
! 145: * if tcp/ip should be used host AND port have
! 146: * to be specified
! 147: *
! 148: */
! 149: buffer *host;
! 150: unsigned short port;
! 151:
! 152: /*
! 153: * Unix Domain Socket
! 154: *
! 155: * instead of TCP/IP we can use Unix Domain Sockets
! 156: * - more secure (you have fileperms to play with)
! 157: * - more control (on locally)
! 158: * - more speed (no extra overhead)
! 159: */
! 160: buffer *unixsocket;
! 161:
! 162: /* if socket is local we can start the scgi
! 163: * process ourself
! 164: *
! 165: * bin-path is the path to the binary
! 166: *
! 167: * check min_procs and max_procs for the number
! 168: * of process to start-up
! 169: */
! 170: buffer *bin_path;
! 171:
! 172: /* bin-path is set bin-environment is taken to
! 173: * create the environement before starting the
! 174: * FastCGI process
! 175: *
! 176: */
! 177: array *bin_env;
! 178:
! 179: array *bin_env_copy;
! 180:
! 181: /*
! 182: * docroot-translation between URL->phys and the
! 183: * remote host
! 184: *
! 185: * reasons:
! 186: * - different dir-layout if remote
! 187: * - chroot if local
! 188: *
! 189: */
! 190: buffer *docroot;
! 191:
! 192: /*
! 193: * check_local tell you if the phys file is stat()ed
! 194: * or not. FastCGI doesn't care if the service is
! 195: * remote. If the web-server side doesn't contain
! 196: * the scgi-files we should not stat() for them
! 197: * and say '404 not found'.
! 198: */
! 199: unsigned short check_local;
! 200:
! 201: /*
! 202: * append PATH_INFO to SCRIPT_FILENAME
! 203: *
! 204: * php needs this if cgi.fix_pathinfo is provied
! 205: *
! 206: */
! 207:
! 208: /*
! 209: * workaround for program when prefix="/"
! 210: *
! 211: * rule to build PATH_INFO is hardcoded for when check_local is disabled
! 212: * enable this option to use the workaround
! 213: *
! 214: */
! 215:
! 216: unsigned short fix_root_path_name;
! 217: ssize_t load; /* replace by host->load */
! 218:
! 219: size_t max_id; /* corresponds most of the time to
! 220: num_procs.
! 221:
! 222: only if a process is killed max_id waits for the process itself
! 223: to die and decrements its afterwards */
! 224: } scgi_extension_host;
! 225:
! 226: /*
! 227: * one extension can have multiple hosts assigned
! 228: * one host can spawn additional processes on the same
! 229: * socket (if we control it)
! 230: *
! 231: * ext -> host -> procs
! 232: * 1:n 1:n
! 233: *
! 234: * if the scgi process is remote that whole goes down
! 235: * to
! 236: *
! 237: * ext -> host -> procs
! 238: * 1:n 1:1
! 239: *
! 240: * in case of PHP and FCGI_CHILDREN we have again a procs
! 241: * but we don't control it directly.
! 242: *
! 243: */
! 244:
! 245: typedef struct {
! 246: buffer *key; /* like .php */
! 247:
! 248: int note_is_sent;
! 249: scgi_extension_host **hosts;
! 250:
! 251: size_t used;
! 252: size_t size;
! 253: } scgi_extension;
! 254:
! 255: typedef struct {
! 256: scgi_extension **exts;
! 257:
! 258: size_t used;
! 259: size_t size;
! 260: } scgi_exts;
! 261:
! 262:
! 263: typedef struct {
! 264: scgi_exts *exts;
! 265:
! 266: int debug;
! 267: } plugin_config;
! 268:
! 269: typedef struct {
! 270: char **ptr;
! 271:
! 272: size_t size;
! 273: size_t used;
! 274: } char_array;
! 275:
! 276: /* generic plugin data, shared between all connections */
! 277: typedef struct {
! 278: PLUGIN_DATA;
! 279:
! 280: buffer *scgi_env;
! 281:
! 282: buffer *path;
! 283: buffer *parse_response;
! 284:
! 285: plugin_config **config_storage;
! 286:
! 287: plugin_config conf; /* this is only used as long as no handler_ctx is setup */
! 288: } plugin_data;
! 289:
! 290: /* connection specific data */
! 291: typedef enum { FCGI_STATE_INIT, FCGI_STATE_CONNECT, FCGI_STATE_PREPARE_WRITE,
! 292: FCGI_STATE_WRITE, FCGI_STATE_READ
! 293: } scgi_connection_state_t;
! 294:
! 295: typedef struct {
! 296: buffer *response;
! 297: size_t response_len;
! 298: int response_type;
! 299: int response_padding;
! 300:
! 301: scgi_proc *proc;
! 302: scgi_extension_host *host;
! 303:
! 304: scgi_connection_state_t state;
! 305: time_t state_timestamp;
! 306:
! 307: int reconnects; /* number of reconnect attempts */
! 308:
! 309: read_buffer *rb;
! 310: chunkqueue *wb;
! 311:
! 312: buffer *response_header;
! 313:
! 314: int delayed; /* flag to mark that the connect() is delayed */
! 315:
! 316: size_t request_id;
! 317: int fd; /* fd to the scgi process */
! 318: int fde_ndx; /* index into the fd-event buffer */
! 319:
! 320: pid_t pid;
! 321: int got_proc;
! 322:
! 323: plugin_config conf;
! 324:
! 325: connection *remote_conn; /* dumb pointer */
! 326: plugin_data *plugin_data; /* dumb pointer */
! 327: } handler_ctx;
! 328:
! 329:
! 330: /* ok, we need a prototype */
! 331: static handler_t scgi_handle_fdevent(server *srv, void *ctx, int revents);
! 332:
! 333: int scgi_proclist_sort_down(server *srv, scgi_extension_host *host, scgi_proc *proc);
! 334:
! 335: static void reset_signals(void) {
! 336: #ifdef SIGTTOU
! 337: signal(SIGTTOU, SIG_DFL);
! 338: #endif
! 339: #ifdef SIGTTIN
! 340: signal(SIGTTIN, SIG_DFL);
! 341: #endif
! 342: #ifdef SIGTSTP
! 343: signal(SIGTSTP, SIG_DFL);
! 344: #endif
! 345: signal(SIGHUP, SIG_DFL);
! 346: signal(SIGPIPE, SIG_DFL);
! 347: signal(SIGUSR1, SIG_DFL);
! 348: }
! 349:
! 350: static handler_ctx * handler_ctx_init(void) {
! 351: handler_ctx * hctx;
! 352:
! 353: hctx = calloc(1, sizeof(*hctx));
! 354: assert(hctx);
! 355:
! 356: hctx->fde_ndx = -1;
! 357:
! 358: hctx->response = buffer_init();
! 359: hctx->response_header = buffer_init();
! 360:
! 361: hctx->request_id = 0;
! 362: hctx->state = FCGI_STATE_INIT;
! 363: hctx->proc = NULL;
! 364:
! 365: hctx->response_len = 0;
! 366: hctx->response_type = 0;
! 367: hctx->response_padding = 0;
! 368: hctx->fd = -1;
! 369:
! 370: hctx->reconnects = 0;
! 371:
! 372: hctx->wb = chunkqueue_init();
! 373:
! 374: return hctx;
! 375: }
! 376:
! 377: static void handler_ctx_free(handler_ctx *hctx) {
! 378: buffer_free(hctx->response);
! 379: buffer_free(hctx->response_header);
! 380:
! 381: chunkqueue_free(hctx->wb);
! 382:
! 383: if (hctx->rb) {
! 384: if (hctx->rb->ptr) free(hctx->rb->ptr);
! 385: free(hctx->rb);
! 386: }
! 387:
! 388: free(hctx);
! 389: }
! 390:
! 391: static scgi_proc *scgi_process_init(void) {
! 392: scgi_proc *f;
! 393:
! 394: f = calloc(1, sizeof(*f));
! 395: f->socket = buffer_init();
! 396:
! 397: f->prev = NULL;
! 398: f->next = NULL;
! 399:
! 400: return f;
! 401: }
! 402:
! 403: static void scgi_process_free(scgi_proc *f) {
! 404: if (!f) return;
! 405:
! 406: scgi_process_free(f->next);
! 407:
! 408: buffer_free(f->socket);
! 409:
! 410: free(f);
! 411: }
! 412:
! 413: static scgi_extension_host *scgi_host_init(void) {
! 414: scgi_extension_host *f;
! 415:
! 416: f = calloc(1, sizeof(*f));
! 417:
! 418: f->host = buffer_init();
! 419: f->unixsocket = buffer_init();
! 420: f->docroot = buffer_init();
! 421: f->bin_path = buffer_init();
! 422: f->bin_env = array_init();
! 423: f->bin_env_copy = array_init();
! 424:
! 425: return f;
! 426: }
! 427:
! 428: static void scgi_host_free(scgi_extension_host *h) {
! 429: if (!h) return;
! 430:
! 431: buffer_free(h->host);
! 432: buffer_free(h->unixsocket);
! 433: buffer_free(h->docroot);
! 434: buffer_free(h->bin_path);
! 435: array_free(h->bin_env);
! 436: array_free(h->bin_env_copy);
! 437:
! 438: scgi_process_free(h->first);
! 439: scgi_process_free(h->unused_procs);
! 440:
! 441: free(h);
! 442:
! 443: }
! 444:
! 445: static scgi_exts *scgi_extensions_init(void) {
! 446: scgi_exts *f;
! 447:
! 448: f = calloc(1, sizeof(*f));
! 449:
! 450: return f;
! 451: }
! 452:
! 453: static void scgi_extensions_free(scgi_exts *f) {
! 454: size_t i;
! 455:
! 456: if (!f) return;
! 457:
! 458: for (i = 0; i < f->used; i++) {
! 459: scgi_extension *fe;
! 460: size_t j;
! 461:
! 462: fe = f->exts[i];
! 463:
! 464: for (j = 0; j < fe->used; j++) {
! 465: scgi_extension_host *h;
! 466:
! 467: h = fe->hosts[j];
! 468:
! 469: scgi_host_free(h);
! 470: }
! 471:
! 472: buffer_free(fe->key);
! 473: free(fe->hosts);
! 474:
! 475: free(fe);
! 476: }
! 477:
! 478: free(f->exts);
! 479:
! 480: free(f);
! 481: }
! 482:
! 483: static int scgi_extension_insert(scgi_exts *ext, buffer *key, scgi_extension_host *fh) {
! 484: scgi_extension *fe;
! 485: size_t i;
! 486:
! 487: /* there is something */
! 488:
! 489: for (i = 0; i < ext->used; i++) {
! 490: if (buffer_is_equal(key, ext->exts[i]->key)) {
! 491: break;
! 492: }
! 493: }
! 494:
! 495: if (i == ext->used) {
! 496: /* filextension is new */
! 497: fe = calloc(1, sizeof(*fe));
! 498: assert(fe);
! 499: fe->key = buffer_init();
! 500: buffer_copy_string_buffer(fe->key, key);
! 501:
! 502: /* */
! 503:
! 504: if (ext->size == 0) {
! 505: ext->size = 8;
! 506: ext->exts = malloc(ext->size * sizeof(*(ext->exts)));
! 507: assert(ext->exts);
! 508: } else if (ext->used == ext->size) {
! 509: ext->size += 8;
! 510: ext->exts = realloc(ext->exts, ext->size * sizeof(*(ext->exts)));
! 511: assert(ext->exts);
! 512: }
! 513: ext->exts[ext->used++] = fe;
! 514: } else {
! 515: fe = ext->exts[i];
! 516: }
! 517:
! 518: if (fe->size == 0) {
! 519: fe->size = 4;
! 520: fe->hosts = malloc(fe->size * sizeof(*(fe->hosts)));
! 521: assert(fe->hosts);
! 522: } else if (fe->size == fe->used) {
! 523: fe->size += 4;
! 524: fe->hosts = realloc(fe->hosts, fe->size * sizeof(*(fe->hosts)));
! 525: assert(fe->hosts);
! 526: }
! 527:
! 528: fe->hosts[fe->used++] = fh;
! 529:
! 530: return 0;
! 531:
! 532: }
! 533:
! 534: INIT_FUNC(mod_scgi_init) {
! 535: plugin_data *p;
! 536:
! 537: p = calloc(1, sizeof(*p));
! 538:
! 539: p->scgi_env = buffer_init();
! 540:
! 541: p->path = buffer_init();
! 542: p->parse_response = buffer_init();
! 543:
! 544: return p;
! 545: }
! 546:
! 547:
! 548: FREE_FUNC(mod_scgi_free) {
! 549: plugin_data *p = p_d;
! 550:
! 551: UNUSED(srv);
! 552:
! 553: buffer_free(p->scgi_env);
! 554: buffer_free(p->path);
! 555: buffer_free(p->parse_response);
! 556:
! 557: if (p->config_storage) {
! 558: size_t i, j, n;
! 559: for (i = 0; i < srv->config_context->used; i++) {
! 560: plugin_config *s = p->config_storage[i];
! 561: scgi_exts *exts;
! 562:
! 563: if (!s) continue;
! 564:
! 565: exts = s->exts;
! 566:
! 567: for (j = 0; j < exts->used; j++) {
! 568: scgi_extension *ex;
! 569:
! 570: ex = exts->exts[j];
! 571:
! 572: for (n = 0; n < ex->used; n++) {
! 573: scgi_proc *proc;
! 574: scgi_extension_host *host;
! 575:
! 576: host = ex->hosts[n];
! 577:
! 578: for (proc = host->first; proc; proc = proc->next) {
! 579: if (proc->pid != 0) kill(proc->pid, SIGTERM);
! 580:
! 581: if (proc->is_local &&
! 582: !buffer_is_empty(proc->socket)) {
! 583: unlink(proc->socket->ptr);
! 584: }
! 585: }
! 586:
! 587: for (proc = host->unused_procs; proc; proc = proc->next) {
! 588: if (proc->pid != 0) kill(proc->pid, SIGTERM);
! 589:
! 590: if (proc->is_local &&
! 591: !buffer_is_empty(proc->socket)) {
! 592: unlink(proc->socket->ptr);
! 593: }
! 594: }
! 595: }
! 596: }
! 597:
! 598: scgi_extensions_free(s->exts);
! 599:
! 600: free(s);
! 601: }
! 602: free(p->config_storage);
! 603: }
! 604:
! 605: free(p);
! 606:
! 607: return HANDLER_GO_ON;
! 608: }
! 609:
! 610: static int env_add(char_array *env, const char *key, size_t key_len, const char *val, size_t val_len) {
! 611: char *dst;
! 612: size_t i;
! 613:
! 614: if (!key || !val) return -1;
! 615:
! 616: dst = malloc(key_len + val_len + 3);
! 617: memcpy(dst, key, key_len);
! 618: dst[key_len] = '=';
! 619: /* add the \0 from the value */
! 620: memcpy(dst + key_len + 1, val, val_len + 1);
! 621:
! 622: for (i = 0; i < env->used; i++) {
! 623: if (0 == strncmp(dst, env->ptr[i], key_len + 1)) {
! 624: /* don't care about free as we are in a forked child which is going to exec(...) */
! 625: /* free(env->ptr[i]); */
! 626: env->ptr[i] = dst;
! 627: return 0;
! 628: }
! 629: }
! 630:
! 631: if (env->size == 0) {
! 632: env->size = 16;
! 633: env->ptr = malloc(env->size * sizeof(*env->ptr));
! 634: } else if (env->size == env->used) {
! 635: env->size += 16;
! 636: env->ptr = realloc(env->ptr, env->size * sizeof(*env->ptr));
! 637: }
! 638:
! 639: env->ptr[env->used++] = dst;
! 640:
! 641: return 0;
! 642: }
! 643:
! 644: static int scgi_spawn_connection(server *srv,
! 645: plugin_data *p,
! 646: scgi_extension_host *host,
! 647: scgi_proc *proc) {
! 648: int scgi_fd;
! 649: int socket_type, status;
! 650: struct timeval tv = { 0, 100 * 1000 };
! 651: #ifdef HAVE_SYS_UN_H
! 652: struct sockaddr_un scgi_addr_un;
! 653: #endif
! 654: struct sockaddr_in scgi_addr_in;
! 655: struct sockaddr *scgi_addr;
! 656:
! 657: socklen_t servlen;
! 658:
! 659: #ifndef HAVE_FORK
! 660: return -1;
! 661: #endif
! 662:
! 663: if (p->conf.debug) {
! 664: log_error_write(srv, __FILE__, __LINE__, "sdb",
! 665: "new proc, socket:", proc->port, proc->socket);
! 666: }
! 667:
! 668: if (!buffer_is_empty(proc->socket)) {
! 669: memset(&scgi_addr, 0, sizeof(scgi_addr));
! 670:
! 671: #ifdef HAVE_SYS_UN_H
! 672: scgi_addr_un.sun_family = AF_UNIX;
! 673: strcpy(scgi_addr_un.sun_path, proc->socket->ptr);
! 674:
! 675: #ifdef SUN_LEN
! 676: servlen = SUN_LEN(&scgi_addr_un);
! 677: #else
! 678: /* stevens says: */
! 679: servlen = proc->socket->used + sizeof(scgi_addr_un.sun_family);
! 680: #endif
! 681: socket_type = AF_UNIX;
! 682: scgi_addr = (struct sockaddr *) &scgi_addr_un;
! 683: #else
! 684: log_error_write(srv, __FILE__, __LINE__, "s",
! 685: "ERROR: Unix Domain sockets are not supported.");
! 686: return -1;
! 687: #endif
! 688: } else {
! 689: scgi_addr_in.sin_family = AF_INET;
! 690:
! 691: if (buffer_is_empty(host->host)) {
! 692: scgi_addr_in.sin_addr.s_addr = htonl(INADDR_ANY);
! 693: } else {
! 694: struct hostent *he;
! 695:
! 696: /* set a usefull default */
! 697: scgi_addr_in.sin_addr.s_addr = htonl(INADDR_ANY);
! 698:
! 699:
! 700: if (NULL == (he = gethostbyname(host->host->ptr))) {
! 701: log_error_write(srv, __FILE__, __LINE__,
! 702: "sdb", "gethostbyname failed: ",
! 703: h_errno, host->host);
! 704: return -1;
! 705: }
! 706:
! 707: if (he->h_addrtype != AF_INET) {
! 708: log_error_write(srv, __FILE__, __LINE__, "sd", "addr-type != AF_INET: ", he->h_addrtype);
! 709: return -1;
! 710: }
! 711:
! 712: if (he->h_length != sizeof(struct in_addr)) {
! 713: log_error_write(srv, __FILE__, __LINE__, "sd", "addr-length != sizeof(in_addr): ", he->h_length);
! 714: return -1;
! 715: }
! 716:
! 717: memcpy(&(scgi_addr_in.sin_addr.s_addr), he->h_addr_list[0], he->h_length);
! 718:
! 719: }
! 720: scgi_addr_in.sin_port = htons(proc->port);
! 721: servlen = sizeof(scgi_addr_in);
! 722:
! 723: socket_type = AF_INET;
! 724: scgi_addr = (struct sockaddr *) &scgi_addr_in;
! 725: }
! 726:
! 727: if (-1 == (scgi_fd = socket(socket_type, SOCK_STREAM, 0))) {
! 728: log_error_write(srv, __FILE__, __LINE__, "ss",
! 729: "failed:", strerror(errno));
! 730: return -1;
! 731: }
! 732:
! 733: if (-1 == connect(scgi_fd, scgi_addr, servlen)) {
! 734: /* server is not up, spawn in */
! 735: pid_t child;
! 736: int val;
! 737:
! 738: if (!buffer_is_empty(proc->socket)) {
! 739: unlink(proc->socket->ptr);
! 740: }
! 741:
! 742: close(scgi_fd);
! 743:
! 744: /* reopen socket */
! 745: if (-1 == (scgi_fd = socket(socket_type, SOCK_STREAM, 0))) {
! 746: log_error_write(srv, __FILE__, __LINE__, "ss",
! 747: "socket failed:", strerror(errno));
! 748: return -1;
! 749: }
! 750:
! 751: val = 1;
! 752: if (setsockopt(scgi_fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
! 753: log_error_write(srv, __FILE__, __LINE__, "ss",
! 754: "socketsockopt failed:", strerror(errno));
! 755: return -1;
! 756: }
! 757:
! 758: /* create socket */
! 759: if (-1 == bind(scgi_fd, scgi_addr, servlen)) {
! 760: log_error_write(srv, __FILE__, __LINE__, "sbds",
! 761: "bind failed for:",
! 762: proc->socket,
! 763: proc->port,
! 764: strerror(errno));
! 765: return -1;
! 766: }
! 767:
! 768: if (-1 == listen(scgi_fd, 1024)) {
! 769: log_error_write(srv, __FILE__, __LINE__, "ss",
! 770: "listen failed:", strerror(errno));
! 771: return -1;
! 772: }
! 773:
! 774: #ifdef HAVE_FORK
! 775: switch ((child = fork())) {
! 776: case 0: {
! 777: buffer *b;
! 778: size_t i = 0;
! 779: int fd = 0;
! 780: char_array env;
! 781:
! 782:
! 783: /* create environment */
! 784: env.ptr = NULL;
! 785: env.size = 0;
! 786: env.used = 0;
! 787:
! 788: if (scgi_fd != 0) {
! 789: dup2(scgi_fd, 0);
! 790: close(scgi_fd);
! 791: }
! 792:
! 793: /* we don't need the client socket */
! 794: for (fd = 3; fd < 256; fd++) {
! 795: close(fd);
! 796: }
! 797:
! 798: /* build clean environment */
! 799: if (host->bin_env_copy->used) {
! 800: for (i = 0; i < host->bin_env_copy->used; i++) {
! 801: data_string *ds = (data_string *)host->bin_env_copy->data[i];
! 802: char *ge;
! 803:
! 804: if (NULL != (ge = getenv(ds->value->ptr))) {
! 805: env_add(&env, CONST_BUF_LEN(ds->value), ge, strlen(ge));
! 806: }
! 807: }
! 808: } else {
! 809: for (i = 0; environ[i]; i++) {
! 810: char *eq;
! 811:
! 812: if (NULL != (eq = strchr(environ[i], '='))) {
! 813: env_add(&env, environ[i], eq - environ[i], eq+1, strlen(eq+1));
! 814: }
! 815: }
! 816: }
! 817:
! 818: /* create environment */
! 819: for (i = 0; i < host->bin_env->used; i++) {
! 820: data_string *ds = (data_string *)host->bin_env->data[i];
! 821:
! 822: env_add(&env, CONST_BUF_LEN(ds->key), CONST_BUF_LEN(ds->value));
! 823: }
! 824:
! 825: for (i = 0; i < env.used; i++) {
! 826: /* search for PHP_FCGI_CHILDREN */
! 827: if (0 == strncmp(env.ptr[i], "PHP_FCGI_CHILDREN=", sizeof("PHP_FCGI_CHILDREN=") - 1)) break;
! 828: }
! 829:
! 830: /* not found, add a default */
! 831: if (i == env.used) {
! 832: env_add(&env, CONST_STR_LEN("PHP_FCGI_CHILDREN"), CONST_STR_LEN("1"));
! 833: }
! 834:
! 835: env.ptr[env.used] = NULL;
! 836:
! 837: b = buffer_init();
! 838: buffer_copy_string_len(b, CONST_STR_LEN("exec "));
! 839: buffer_append_string_buffer(b, host->bin_path);
! 840:
! 841: reset_signals();
! 842:
! 843: /* exec the cgi */
! 844: execle("/bin/sh", "sh", "-c", b->ptr, (char *)NULL, env.ptr);
! 845:
! 846: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 847: "execl failed for:", host->bin_path, strerror(errno));
! 848:
! 849: exit(errno);
! 850:
! 851: break;
! 852: }
! 853: case -1:
! 854: /* error */
! 855: break;
! 856: default:
! 857: /* father */
! 858:
! 859: /* wait */
! 860: select(0, NULL, NULL, NULL, &tv);
! 861:
! 862: switch (waitpid(child, &status, WNOHANG)) {
! 863: case 0:
! 864: /* child still running after timeout, good */
! 865: break;
! 866: case -1:
! 867: /* no PID found ? should never happen */
! 868: log_error_write(srv, __FILE__, __LINE__, "ss",
! 869: "pid not found:", strerror(errno));
! 870: return -1;
! 871: default:
! 872: /* the child should not terminate at all */
! 873: if (WIFEXITED(status)) {
! 874: log_error_write(srv, __FILE__, __LINE__, "sd",
! 875: "child exited (is this a SCGI binary ?):",
! 876: WEXITSTATUS(status));
! 877: } else if (WIFSIGNALED(status)) {
! 878: log_error_write(srv, __FILE__, __LINE__, "sd",
! 879: "child signaled:",
! 880: WTERMSIG(status));
! 881: } else {
! 882: log_error_write(srv, __FILE__, __LINE__, "sd",
! 883: "child died somehow:",
! 884: status);
! 885: }
! 886: return -1;
! 887: }
! 888:
! 889: /* register process */
! 890: proc->pid = child;
! 891: proc->last_used = srv->cur_ts;
! 892: proc->is_local = 1;
! 893:
! 894: break;
! 895: }
! 896: #endif
! 897: } else {
! 898: proc->is_local = 0;
! 899: proc->pid = 0;
! 900:
! 901: if (p->conf.debug) {
! 902: log_error_write(srv, __FILE__, __LINE__, "sb",
! 903: "(debug) socket is already used, won't spawn:",
! 904: proc->socket);
! 905: }
! 906: }
! 907:
! 908: proc->state = PROC_STATE_RUNNING;
! 909: host->active_procs++;
! 910:
! 911: close(scgi_fd);
! 912:
! 913: return 0;
! 914: }
! 915:
! 916:
! 917: SETDEFAULTS_FUNC(mod_scgi_set_defaults) {
! 918: plugin_data *p = p_d;
! 919: data_unset *du;
! 920: size_t i = 0;
! 921:
! 922: config_values_t cv[] = {
! 923: { "scgi.server", NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
! 924: { "scgi.debug", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
! 925: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
! 926: };
! 927:
! 928: p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
! 929:
! 930: for (i = 0; i < srv->config_context->used; i++) {
! 931: plugin_config *s;
! 932: array *ca;
! 933:
! 934: s = malloc(sizeof(plugin_config));
! 935: s->exts = scgi_extensions_init();
! 936: s->debug = 0;
! 937:
! 938: cv[0].destination = s->exts;
! 939: cv[1].destination = &(s->debug);
! 940:
! 941: p->config_storage[i] = s;
! 942: ca = ((data_config *)srv->config_context->data[i])->value;
! 943:
! 944: if (0 != config_insert_values_global(srv, ca, cv)) {
! 945: return HANDLER_ERROR;
! 946: }
! 947:
! 948: /*
! 949: * <key> = ( ... )
! 950: */
! 951:
! 952: if (NULL != (du = array_get_element(ca, "scgi.server"))) {
! 953: size_t j;
! 954: data_array *da = (data_array *)du;
! 955:
! 956: if (du->type != TYPE_ARRAY) {
! 957: log_error_write(srv, __FILE__, __LINE__, "sss",
! 958: "unexpected type for key: ", "scgi.server", "array of strings");
! 959:
! 960: return HANDLER_ERROR;
! 961: }
! 962:
! 963:
! 964: /*
! 965: * scgi.server = ( "<ext>" => ( ... ),
! 966: * "<ext>" => ( ... ) )
! 967: */
! 968:
! 969: for (j = 0; j < da->value->used; j++) {
! 970: size_t n;
! 971: data_array *da_ext = (data_array *)da->value->data[j];
! 972:
! 973: if (da->value->data[j]->type != TYPE_ARRAY) {
! 974: log_error_write(srv, __FILE__, __LINE__, "sssbs",
! 975: "unexpected type for key: ", "scgi.server",
! 976: "[", da->value->data[j]->key, "](string)");
! 977:
! 978: return HANDLER_ERROR;
! 979: }
! 980:
! 981: /*
! 982: * da_ext->key == name of the extension
! 983: */
! 984:
! 985: /*
! 986: * scgi.server = ( "<ext>" =>
! 987: * ( "<host>" => ( ... ),
! 988: * "<host>" => ( ... )
! 989: * ),
! 990: * "<ext>" => ... )
! 991: */
! 992:
! 993: for (n = 0; n < da_ext->value->used; n++) {
! 994: data_array *da_host = (data_array *)da_ext->value->data[n];
! 995:
! 996: scgi_extension_host *df;
! 997:
! 998: config_values_t fcv[] = {
! 999: { "host", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 0 */
! 1000: { "docroot", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 1 */
! 1001: { "socket", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
! 1002: { "bin-path", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 3 */
! 1003:
! 1004: { "check-local", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 4 */
! 1005: { "port", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 5 */
! 1006: { "min-procs-not-working", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 7 this is broken for now */
! 1007: { "max-procs", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 7 */
! 1008: { "max-load-per-proc", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 8 */
! 1009: { "idle-timeout", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 9 */
! 1010: { "disable-time", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 10 */
! 1011:
! 1012: { "bin-environment", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 11 */
! 1013: { "bin-copy-environment", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 12 */
! 1014: { "fix-root-scriptname", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 13 */
! 1015:
! 1016:
! 1017: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
! 1018: };
! 1019:
! 1020: if (da_host->type != TYPE_ARRAY) {
! 1021: log_error_write(srv, __FILE__, __LINE__, "ssSBS",
! 1022: "unexpected type for key:",
! 1023: "scgi.server",
! 1024: "[", da_host->key, "](string)");
! 1025:
! 1026: return HANDLER_ERROR;
! 1027: }
! 1028:
! 1029: df = scgi_host_init();
! 1030:
! 1031: df->check_local = 1;
! 1032: df->min_procs = 4;
! 1033: df->max_procs = 4;
! 1034: df->max_load_per_proc = 1;
! 1035: df->idle_timeout = 60;
! 1036: df->disable_time = 60;
! 1037: df->fix_root_path_name = 0;
! 1038:
! 1039: fcv[0].destination = df->host;
! 1040: fcv[1].destination = df->docroot;
! 1041: fcv[2].destination = df->unixsocket;
! 1042: fcv[3].destination = df->bin_path;
! 1043:
! 1044: fcv[4].destination = &(df->check_local);
! 1045: fcv[5].destination = &(df->port);
! 1046: fcv[6].destination = &(df->min_procs);
! 1047: fcv[7].destination = &(df->max_procs);
! 1048: fcv[8].destination = &(df->max_load_per_proc);
! 1049: fcv[9].destination = &(df->idle_timeout);
! 1050: fcv[10].destination = &(df->disable_time);
! 1051:
! 1052: fcv[11].destination = df->bin_env;
! 1053: fcv[12].destination = df->bin_env_copy;
! 1054: fcv[13].destination = &(df->fix_root_path_name);
! 1055:
! 1056:
! 1057: if (0 != config_insert_values_internal(srv, da_host->value, fcv)) {
! 1058: return HANDLER_ERROR;
! 1059: }
! 1060:
! 1061: if ((!buffer_is_empty(df->host) || df->port) &&
! 1062: !buffer_is_empty(df->unixsocket)) {
! 1063: log_error_write(srv, __FILE__, __LINE__, "s",
! 1064: "either host+port or socket");
! 1065:
! 1066: return HANDLER_ERROR;
! 1067: }
! 1068:
! 1069: if (!buffer_is_empty(df->unixsocket)) {
! 1070: /* unix domain socket */
! 1071: struct sockaddr_un un;
! 1072:
! 1073: if (df->unixsocket->used > sizeof(un.sun_path) - 2) {
! 1074: log_error_write(srv, __FILE__, __LINE__, "s",
! 1075: "path of the unixdomain socket is too large");
! 1076: return HANDLER_ERROR;
! 1077: }
! 1078: } else {
! 1079: /* tcp/ip */
! 1080:
! 1081: if (buffer_is_empty(df->host) &&
! 1082: buffer_is_empty(df->bin_path)) {
! 1083: log_error_write(srv, __FILE__, __LINE__, "sbbbs",
! 1084: "missing key (string):",
! 1085: da->key,
! 1086: da_ext->key,
! 1087: da_host->key,
! 1088: "host");
! 1089:
! 1090: return HANDLER_ERROR;
! 1091: } else if (df->port == 0) {
! 1092: log_error_write(srv, __FILE__, __LINE__, "sbbbs",
! 1093: "missing key (short):",
! 1094: da->key,
! 1095: da_ext->key,
! 1096: da_host->key,
! 1097: "port");
! 1098: return HANDLER_ERROR;
! 1099: }
! 1100: }
! 1101:
! 1102: if (!buffer_is_empty(df->bin_path)) {
! 1103: /* a local socket + self spawning */
! 1104: size_t pno;
! 1105:
! 1106: /* HACK: just to make sure the adaptive spawing is disabled */
! 1107: df->min_procs = df->max_procs;
! 1108:
! 1109: if (df->min_procs > df->max_procs) df->max_procs = df->min_procs;
! 1110: if (df->max_load_per_proc < 1) df->max_load_per_proc = 0;
! 1111:
! 1112: if (s->debug) {
! 1113: log_error_write(srv, __FILE__, __LINE__, "ssbsdsbsdsd",
! 1114: "--- scgi spawning local",
! 1115: "\n\tproc:", df->bin_path,
! 1116: "\n\tport:", df->port,
! 1117: "\n\tsocket", df->unixsocket,
! 1118: "\n\tmin-procs:", df->min_procs,
! 1119: "\n\tmax-procs:", df->max_procs);
! 1120: }
! 1121:
! 1122: for (pno = 0; pno < df->min_procs; pno++) {
! 1123: scgi_proc *proc;
! 1124:
! 1125: proc = scgi_process_init();
! 1126: proc->id = df->num_procs++;
! 1127: df->max_id++;
! 1128:
! 1129: if (buffer_is_empty(df->unixsocket)) {
! 1130: proc->port = df->port + pno;
! 1131: } else {
! 1132: buffer_copy_string_buffer(proc->socket, df->unixsocket);
! 1133: buffer_append_string_len(proc->socket, CONST_STR_LEN("-"));
! 1134: buffer_append_long(proc->socket, pno);
! 1135: }
! 1136:
! 1137: if (s->debug) {
! 1138: log_error_write(srv, __FILE__, __LINE__, "ssdsbsdsd",
! 1139: "--- scgi spawning",
! 1140: "\n\tport:", df->port,
! 1141: "\n\tsocket", df->unixsocket,
! 1142: "\n\tcurrent:", pno, "/", df->min_procs);
! 1143: }
! 1144:
! 1145: if (scgi_spawn_connection(srv, p, df, proc)) {
! 1146: log_error_write(srv, __FILE__, __LINE__, "s",
! 1147: "[ERROR]: spawning fcgi failed.");
! 1148: return HANDLER_ERROR;
! 1149: }
! 1150:
! 1151: proc->next = df->first;
! 1152: if (df->first) df->first->prev = proc;
! 1153:
! 1154: df->first = proc;
! 1155: }
! 1156: } else {
! 1157: scgi_proc *fp;
! 1158:
! 1159: fp = scgi_process_init();
! 1160: fp->id = df->num_procs++;
! 1161: df->max_id++;
! 1162: df->active_procs++;
! 1163: fp->state = PROC_STATE_RUNNING;
! 1164:
! 1165: if (buffer_is_empty(df->unixsocket)) {
! 1166: fp->port = df->port;
! 1167: } else {
! 1168: buffer_copy_string_buffer(fp->socket, df->unixsocket);
! 1169: }
! 1170:
! 1171: df->first = fp;
! 1172:
! 1173: df->min_procs = 1;
! 1174: df->max_procs = 1;
! 1175: }
! 1176:
! 1177: /* if extension already exists, take it */
! 1178: scgi_extension_insert(s->exts, da_ext->key, df);
! 1179: }
! 1180: }
! 1181: }
! 1182: }
! 1183:
! 1184: return HANDLER_GO_ON;
! 1185: }
! 1186:
! 1187: static int scgi_set_state(server *srv, handler_ctx *hctx, scgi_connection_state_t state) {
! 1188: hctx->state = state;
! 1189: hctx->state_timestamp = srv->cur_ts;
! 1190:
! 1191: return 0;
! 1192: }
! 1193:
! 1194:
! 1195: static void scgi_connection_cleanup(server *srv, handler_ctx *hctx) {
! 1196: plugin_data *p;
! 1197: connection *con;
! 1198:
! 1199: if (NULL == hctx) return;
! 1200:
! 1201: p = hctx->plugin_data;
! 1202: con = hctx->remote_conn;
! 1203:
! 1204: if (hctx->fd != -1) {
! 1205: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
! 1206: fdevent_unregister(srv->ev, hctx->fd);
! 1207: close(hctx->fd);
! 1208: srv->cur_fds--;
! 1209: }
! 1210:
! 1211: if (hctx->host && hctx->proc) {
! 1212: hctx->host->load--;
! 1213:
! 1214: if (hctx->got_proc) {
! 1215: /* after the connect the process gets a load */
! 1216: hctx->proc->load--;
! 1217:
! 1218: if (p->conf.debug) {
! 1219: log_error_write(srv, __FILE__, __LINE__, "sddb",
! 1220: "release proc:",
! 1221: hctx->fd,
! 1222: hctx->proc->pid, hctx->proc->socket);
! 1223: }
! 1224: }
! 1225:
! 1226: scgi_proclist_sort_down(srv, hctx->host, hctx->proc);
! 1227: }
! 1228:
! 1229:
! 1230: handler_ctx_free(hctx);
! 1231: con->plugin_ctx[p->id] = NULL;
! 1232: }
! 1233:
! 1234: static int scgi_reconnect(server *srv, handler_ctx *hctx) {
! 1235: plugin_data *p = hctx->plugin_data;
! 1236:
! 1237: /* child died
! 1238: *
! 1239: * 1.
! 1240: *
! 1241: * connect was ok, connection was accepted
! 1242: * but the php accept loop checks after the accept if it should die or not.
! 1243: *
! 1244: * if yes we can only detect it at a write()
! 1245: *
! 1246: * next step is resetting this attemp and setup a connection again
! 1247: *
! 1248: * if we have more then 5 reconnects for the same request, die
! 1249: *
! 1250: * 2.
! 1251: *
! 1252: * we have a connection but the child died by some other reason
! 1253: *
! 1254: */
! 1255:
! 1256: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
! 1257: fdevent_unregister(srv->ev, hctx->fd);
! 1258: close(hctx->fd);
! 1259: srv->cur_fds--;
! 1260:
! 1261: scgi_set_state(srv, hctx, FCGI_STATE_INIT);
! 1262:
! 1263: hctx->request_id = 0;
! 1264: hctx->reconnects++;
! 1265:
! 1266: if (p->conf.debug) {
! 1267: log_error_write(srv, __FILE__, __LINE__, "sddb",
! 1268: "release proc:",
! 1269: hctx->fd,
! 1270: hctx->proc->pid, hctx->proc->socket);
! 1271: }
! 1272:
! 1273: hctx->proc->load--;
! 1274: scgi_proclist_sort_down(srv, hctx->host, hctx->proc);
! 1275:
! 1276: return 0;
! 1277: }
! 1278:
! 1279:
! 1280: static handler_t scgi_connection_reset(server *srv, connection *con, void *p_d) {
! 1281: plugin_data *p = p_d;
! 1282:
! 1283: scgi_connection_cleanup(srv, con->plugin_ctx[p->id]);
! 1284:
! 1285: return HANDLER_GO_ON;
! 1286: }
! 1287:
! 1288:
! 1289: static int scgi_env_add(buffer *env, const char *key, size_t key_len, const char *val, size_t val_len) {
! 1290: size_t len;
! 1291:
! 1292: if (!key || !val) return -1;
! 1293:
! 1294: len = key_len + val_len + 2;
! 1295:
! 1296: buffer_prepare_append(env, len);
! 1297:
! 1298: memcpy(env->ptr + env->used, key, key_len);
! 1299: env->ptr[env->used + key_len] = '\0';
! 1300: env->used += key_len + 1;
! 1301: memcpy(env->ptr + env->used, val, val_len);
! 1302: env->ptr[env->used + val_len] = '\0';
! 1303: env->used += val_len + 1;
! 1304:
! 1305: return 0;
! 1306: }
! 1307:
! 1308:
! 1309: /**
! 1310: *
! 1311: * returns
! 1312: * -1 error
! 1313: * 0 connected
! 1314: * 1 not connected yet
! 1315: */
! 1316:
! 1317: static int scgi_establish_connection(server *srv, handler_ctx *hctx) {
! 1318: struct sockaddr *scgi_addr;
! 1319: struct sockaddr_in scgi_addr_in;
! 1320: #ifdef HAVE_SYS_UN_H
! 1321: struct sockaddr_un scgi_addr_un;
! 1322: #endif
! 1323: socklen_t servlen;
! 1324:
! 1325: scgi_extension_host *host = hctx->host;
! 1326: scgi_proc *proc = hctx->proc;
! 1327: int scgi_fd = hctx->fd;
! 1328:
! 1329: memset(&scgi_addr, 0, sizeof(scgi_addr));
! 1330:
! 1331: if (!buffer_is_empty(proc->socket)) {
! 1332: #ifdef HAVE_SYS_UN_H
! 1333: /* use the unix domain socket */
! 1334: scgi_addr_un.sun_family = AF_UNIX;
! 1335: strcpy(scgi_addr_un.sun_path, proc->socket->ptr);
! 1336: #ifdef SUN_LEN
! 1337: servlen = SUN_LEN(&scgi_addr_un);
! 1338: #else
! 1339: /* stevens says: */
! 1340: servlen = proc->socket->used + sizeof(scgi_addr_un.sun_family);
! 1341: #endif
! 1342: scgi_addr = (struct sockaddr *) &scgi_addr_un;
! 1343: #else
! 1344: return -1;
! 1345: #endif
! 1346: } else {
! 1347: scgi_addr_in.sin_family = AF_INET;
! 1348: if (0 == inet_aton(host->host->ptr, &(scgi_addr_in.sin_addr))) {
! 1349: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1350: "converting IP-adress failed for", host->host,
! 1351: "\nBe sure to specify an IP address here");
! 1352:
! 1353: return -1;
! 1354: }
! 1355: scgi_addr_in.sin_port = htons(proc->port);
! 1356: servlen = sizeof(scgi_addr_in);
! 1357:
! 1358: scgi_addr = (struct sockaddr *) &scgi_addr_in;
! 1359: }
! 1360:
! 1361: if (-1 == connect(scgi_fd, scgi_addr, servlen)) {
! 1362: if (errno == EINPROGRESS ||
! 1363: errno == EALREADY ||
! 1364: errno == EINTR) {
! 1365: if (hctx->conf.debug) {
! 1366: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1367: "connect delayed, will continue later:", scgi_fd);
! 1368: }
! 1369:
! 1370: return 1;
! 1371: } else {
! 1372: log_error_write(srv, __FILE__, __LINE__, "sdsddb",
! 1373: "connect failed:", scgi_fd,
! 1374: strerror(errno), errno,
! 1375: proc->port, proc->socket);
! 1376:
! 1377: if (errno == EAGAIN) {
! 1378: /* this is Linux only */
! 1379:
! 1380: log_error_write(srv, __FILE__, __LINE__, "s",
! 1381: "If this happend on Linux: You have been run out of local ports. "
! 1382: "Check the manual, section Performance how to handle this.");
! 1383: }
! 1384:
! 1385: return -1;
! 1386: }
! 1387: }
! 1388: if (hctx->conf.debug > 1) {
! 1389: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1390: "connect succeeded: ", scgi_fd);
! 1391: }
! 1392:
! 1393:
! 1394:
! 1395: return 0;
! 1396: }
! 1397:
! 1398: static int scgi_env_add_request_headers(server *srv, connection *con, plugin_data *p) {
! 1399: size_t i;
! 1400:
! 1401: for (i = 0; i < con->request.headers->used; i++) {
! 1402: data_string *ds;
! 1403:
! 1404: ds = (data_string *)con->request.headers->data[i];
! 1405:
! 1406: if (ds->value->used && ds->key->used) {
! 1407: size_t j;
! 1408: buffer_reset(srv->tmp_buf);
! 1409:
! 1410: if (0 != strcasecmp(ds->key->ptr, "CONTENT-TYPE")) {
! 1411: buffer_copy_string_len(srv->tmp_buf, CONST_STR_LEN("HTTP_"));
! 1412: srv->tmp_buf->used--;
! 1413: }
! 1414:
! 1415: buffer_prepare_append(srv->tmp_buf, ds->key->used + 2);
! 1416: for (j = 0; j < ds->key->used - 1; j++) {
! 1417: srv->tmp_buf->ptr[srv->tmp_buf->used++] =
! 1418: light_isalpha(ds->key->ptr[j]) ?
! 1419: ds->key->ptr[j] & ~32 : '_';
! 1420: }
! 1421: srv->tmp_buf->ptr[srv->tmp_buf->used++] = '\0';
! 1422:
! 1423: scgi_env_add(p->scgi_env, CONST_BUF_LEN(srv->tmp_buf), CONST_BUF_LEN(ds->value));
! 1424: }
! 1425: }
! 1426:
! 1427: for (i = 0; i < con->environment->used; i++) {
! 1428: data_string *ds;
! 1429:
! 1430: ds = (data_string *)con->environment->data[i];
! 1431:
! 1432: if (ds->value->used && ds->key->used) {
! 1433: size_t j;
! 1434: buffer_reset(srv->tmp_buf);
! 1435:
! 1436: buffer_prepare_append(srv->tmp_buf, ds->key->used + 2);
! 1437: for (j = 0; j < ds->key->used - 1; j++) {
! 1438: srv->tmp_buf->ptr[srv->tmp_buf->used++] =
! 1439: light_isalnum((unsigned char)ds->key->ptr[j]) ?
! 1440: toupper((unsigned char)ds->key->ptr[j]) : '_';
! 1441: }
! 1442: srv->tmp_buf->ptr[srv->tmp_buf->used++] = '\0';
! 1443:
! 1444: scgi_env_add(p->scgi_env, CONST_BUF_LEN(srv->tmp_buf), CONST_BUF_LEN(ds->value));
! 1445: }
! 1446: }
! 1447:
! 1448: return 0;
! 1449: }
! 1450:
! 1451:
! 1452: static int scgi_create_env(server *srv, handler_ctx *hctx) {
! 1453: char buf[32];
! 1454: const char *s;
! 1455: #ifdef HAVE_IPV6
! 1456: char b2[INET6_ADDRSTRLEN + 1];
! 1457: #endif
! 1458: buffer *b;
! 1459:
! 1460: plugin_data *p = hctx->plugin_data;
! 1461: scgi_extension_host *host= hctx->host;
! 1462:
! 1463: connection *con = hctx->remote_conn;
! 1464: server_socket *srv_sock = con->srv_socket;
! 1465:
! 1466: sock_addr our_addr;
! 1467: socklen_t our_addr_len;
! 1468:
! 1469: buffer_prepare_copy(p->scgi_env, 1024);
! 1470:
! 1471: /* CGI-SPEC 6.1.2, FastCGI spec 6.3 and SCGI spec */
! 1472:
! 1473: /* request.content_length < SSIZE_MAX, see request.c */
! 1474: LI_ltostr(buf, con->request.content_length);
! 1475: scgi_env_add(p->scgi_env, CONST_STR_LEN("CONTENT_LENGTH"), buf, strlen(buf));
! 1476: scgi_env_add(p->scgi_env, CONST_STR_LEN("SCGI"), CONST_STR_LEN("1"));
! 1477:
! 1478:
! 1479: if (buffer_is_empty(con->conf.server_tag)) {
! 1480: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_STR_LEN(PACKAGE_DESC));
! 1481: } else {
! 1482: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_BUF_LEN(con->conf.server_tag));
! 1483: }
! 1484:
! 1485: if (con->server_name->used) {
! 1486: size_t len = con->server_name->used - 1;
! 1487:
! 1488: if (con->server_name->ptr[0] == '[') {
! 1489: const char *colon = strstr(con->server_name->ptr, "]:");
! 1490: if (colon) len = (colon + 1) - con->server_name->ptr;
! 1491: } else {
! 1492: const char *colon = strchr(con->server_name->ptr, ':');
! 1493: if (colon) len = colon - con->server_name->ptr;
! 1494: }
! 1495:
! 1496: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_NAME"), con->server_name->ptr, len);
! 1497: } else {
! 1498: #ifdef HAVE_IPV6
! 1499: s = inet_ntop(srv_sock->addr.plain.sa_family,
! 1500: srv_sock->addr.plain.sa_family == AF_INET6 ?
! 1501: (const void *) &(srv_sock->addr.ipv6.sin6_addr) :
! 1502: (const void *) &(srv_sock->addr.ipv4.sin_addr),
! 1503: b2, sizeof(b2)-1);
! 1504: #else
! 1505: s = inet_ntoa(srv_sock->addr.ipv4.sin_addr);
! 1506: #endif
! 1507: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_NAME"), s, strlen(s));
! 1508: }
! 1509:
! 1510: scgi_env_add(p->scgi_env, CONST_STR_LEN("GATEWAY_INTERFACE"), CONST_STR_LEN("CGI/1.1"));
! 1511:
! 1512: LI_ltostr(buf,
! 1513: #ifdef HAVE_IPV6
! 1514: ntohs(srv_sock->addr.plain.sa_family ? srv_sock->addr.ipv6.sin6_port : srv_sock->addr.ipv4.sin_port)
! 1515: #else
! 1516: ntohs(srv_sock->addr.ipv4.sin_port)
! 1517: #endif
! 1518: );
! 1519:
! 1520: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_PORT"), buf, strlen(buf));
! 1521:
! 1522: /* get the server-side of the connection to the client */
! 1523: our_addr_len = sizeof(our_addr);
! 1524:
! 1525: if (-1 == getsockname(con->fd, &(our_addr.plain), &our_addr_len)) {
! 1526: s = inet_ntop_cache_get_ip(srv, &(srv_sock->addr));
! 1527: } else {
! 1528: s = inet_ntop_cache_get_ip(srv, &(our_addr));
! 1529: }
! 1530: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_ADDR"), s, strlen(s));
! 1531:
! 1532: LI_ltostr(buf,
! 1533: #ifdef HAVE_IPV6
! 1534: ntohs(con->dst_addr.plain.sa_family ? con->dst_addr.ipv6.sin6_port : con->dst_addr.ipv4.sin_port)
! 1535: #else
! 1536: ntohs(con->dst_addr.ipv4.sin_port)
! 1537: #endif
! 1538: );
! 1539:
! 1540: scgi_env_add(p->scgi_env, CONST_STR_LEN("REMOTE_PORT"), buf, strlen(buf));
! 1541:
! 1542: s = inet_ntop_cache_get_ip(srv, &(con->dst_addr));
! 1543: scgi_env_add(p->scgi_env, CONST_STR_LEN("REMOTE_ADDR"), s, strlen(s));
! 1544:
! 1545: /*
! 1546: * SCRIPT_NAME, PATH_INFO and PATH_TRANSLATED according to
! 1547: * http://cgi-spec.golux.com/draft-coar-cgi-v11-03-clean.html
! 1548: * (6.1.14, 6.1.6, 6.1.7)
! 1549: */
! 1550:
! 1551: scgi_env_add(p->scgi_env, CONST_STR_LEN("SCRIPT_NAME"), CONST_BUF_LEN(con->uri.path));
! 1552:
! 1553: if (!buffer_is_empty(con->request.pathinfo)) {
! 1554: scgi_env_add(p->scgi_env, CONST_STR_LEN("PATH_INFO"), CONST_BUF_LEN(con->request.pathinfo));
! 1555:
! 1556: /* PATH_TRANSLATED is only defined if PATH_INFO is set */
! 1557:
! 1558: if (!buffer_is_empty(host->docroot)) {
! 1559: buffer_copy_string_buffer(p->path, host->docroot);
! 1560: } else {
! 1561: buffer_copy_string_buffer(p->path, con->physical.basedir);
! 1562: }
! 1563: buffer_append_string_buffer(p->path, con->request.pathinfo);
! 1564: scgi_env_add(p->scgi_env, CONST_STR_LEN("PATH_TRANSLATED"), CONST_BUF_LEN(p->path));
! 1565: } else {
! 1566: scgi_env_add(p->scgi_env, CONST_STR_LEN("PATH_INFO"), CONST_STR_LEN(""));
! 1567: }
! 1568:
! 1569: /*
! 1570: * SCRIPT_FILENAME and DOCUMENT_ROOT for php. The PHP manual
! 1571: * http://www.php.net/manual/en/reserved.variables.php
! 1572: * treatment of PATH_TRANSLATED is different from the one of CGI specs.
! 1573: * TODO: this code should be checked against cgi.fix_pathinfo php
! 1574: * parameter.
! 1575: */
! 1576:
! 1577: if (!buffer_is_empty(host->docroot)) {
! 1578: /*
! 1579: * rewrite SCRIPT_FILENAME
! 1580: *
! 1581: */
! 1582:
! 1583: buffer_copy_string_buffer(p->path, host->docroot);
! 1584: buffer_append_string_buffer(p->path, con->uri.path);
! 1585:
! 1586: scgi_env_add(p->scgi_env, CONST_STR_LEN("SCRIPT_FILENAME"), CONST_BUF_LEN(p->path));
! 1587: scgi_env_add(p->scgi_env, CONST_STR_LEN("DOCUMENT_ROOT"), CONST_BUF_LEN(host->docroot));
! 1588: } else {
! 1589: buffer_copy_string_buffer(p->path, con->physical.path);
! 1590:
! 1591: scgi_env_add(p->scgi_env, CONST_STR_LEN("SCRIPT_FILENAME"), CONST_BUF_LEN(p->path));
! 1592: scgi_env_add(p->scgi_env, CONST_STR_LEN("DOCUMENT_ROOT"), CONST_BUF_LEN(con->physical.basedir));
! 1593: }
! 1594: scgi_env_add(p->scgi_env, CONST_STR_LEN("REQUEST_URI"), CONST_BUF_LEN(con->request.orig_uri));
! 1595: if (!buffer_is_equal(con->request.uri, con->request.orig_uri)) {
! 1596: scgi_env_add(p->scgi_env, CONST_STR_LEN("REDIRECT_URI"), CONST_BUF_LEN(con->request.uri));
! 1597: }
! 1598: if (!buffer_is_empty(con->uri.query)) {
! 1599: scgi_env_add(p->scgi_env, CONST_STR_LEN("QUERY_STRING"), CONST_BUF_LEN(con->uri.query));
! 1600: } else {
! 1601: scgi_env_add(p->scgi_env, CONST_STR_LEN("QUERY_STRING"), CONST_STR_LEN(""));
! 1602: }
! 1603:
! 1604: s = get_http_method_name(con->request.http_method);
! 1605: scgi_env_add(p->scgi_env, CONST_STR_LEN("REQUEST_METHOD"), s, strlen(s));
! 1606: scgi_env_add(p->scgi_env, CONST_STR_LEN("REDIRECT_STATUS"), CONST_STR_LEN("200")); /* if php is compiled with --force-redirect */
! 1607: s = get_http_version_name(con->request.http_version);
! 1608: scgi_env_add(p->scgi_env, CONST_STR_LEN("SERVER_PROTOCOL"), s, strlen(s));
! 1609:
! 1610: #ifdef USE_OPENSSL
! 1611: if (buffer_is_equal_caseless_string(con->uri.scheme, CONST_STR_LEN("https"))) {
! 1612: scgi_env_add(p->scgi_env, CONST_STR_LEN("HTTPS"), CONST_STR_LEN("on"));
! 1613: }
! 1614: #endif
! 1615:
! 1616: scgi_env_add_request_headers(srv, con, p);
! 1617:
! 1618: b = chunkqueue_get_append_buffer(hctx->wb);
! 1619:
! 1620: buffer_append_long(b, p->scgi_env->used);
! 1621: buffer_append_string_len(b, CONST_STR_LEN(":"));
! 1622: buffer_append_string_len(b, (const char *)p->scgi_env->ptr, p->scgi_env->used);
! 1623: buffer_append_string_len(b, CONST_STR_LEN(","));
! 1624:
! 1625: hctx->wb->bytes_in += b->used - 1;
! 1626:
! 1627: if (con->request.content_length) {
! 1628: chunkqueue *req_cq = con->request_content_queue;
! 1629: chunk *req_c;
! 1630: off_t offset;
! 1631:
! 1632: /* something to send ? */
! 1633: for (offset = 0, req_c = req_cq->first; offset != req_cq->bytes_in; req_c = req_c->next) {
! 1634: off_t weWant = req_cq->bytes_in - offset;
! 1635: off_t weHave = 0;
! 1636:
! 1637: /* we announce toWrite octects
! 1638: * now take all the request_content chunk that we need to fill this request
! 1639: * */
! 1640:
! 1641: switch (req_c->type) {
! 1642: case FILE_CHUNK:
! 1643: weHave = req_c->file.length - req_c->offset;
! 1644:
! 1645: if (weHave > weWant) weHave = weWant;
! 1646:
! 1647: chunkqueue_append_file(hctx->wb, req_c->file.name, req_c->offset, weHave);
! 1648:
! 1649: req_c->offset += weHave;
! 1650: req_cq->bytes_out += weHave;
! 1651:
! 1652: hctx->wb->bytes_in += weHave;
! 1653:
! 1654: break;
! 1655: case MEM_CHUNK:
! 1656: /* append to the buffer */
! 1657: weHave = req_c->mem->used - 1 - req_c->offset;
! 1658:
! 1659: if (weHave > weWant) weHave = weWant;
! 1660:
! 1661: b = chunkqueue_get_append_buffer(hctx->wb);
! 1662: buffer_append_memory(b, req_c->mem->ptr + req_c->offset, weHave);
! 1663: b->used++; /* add virtual \0 */
! 1664:
! 1665: req_c->offset += weHave;
! 1666: req_cq->bytes_out += weHave;
! 1667:
! 1668: hctx->wb->bytes_in += weHave;
! 1669:
! 1670: break;
! 1671: default:
! 1672: break;
! 1673: }
! 1674:
! 1675: offset += weHave;
! 1676: }
! 1677: }
! 1678:
! 1679: return 0;
! 1680: }
! 1681:
! 1682: static int scgi_response_parse(server *srv, connection *con, plugin_data *p, buffer *in, int eol) {
! 1683: char *ns;
! 1684: const char *s;
! 1685: int line = 0;
! 1686:
! 1687: UNUSED(srv);
! 1688:
! 1689: buffer_copy_string_buffer(p->parse_response, in);
! 1690:
! 1691: for (s = p->parse_response->ptr;
! 1692: NULL != (ns = (eol == EOL_RN ? strstr(s, "\r\n") : strchr(s, '\n')));
! 1693: s = ns + (eol == EOL_RN ? 2 : 1), line++) {
! 1694: const char *key, *value;
! 1695: int key_len;
! 1696: data_string *ds;
! 1697:
! 1698: ns[0] = '\0';
! 1699:
! 1700: if (line == 0 &&
! 1701: 0 == strncmp(s, "HTTP/1.", 7)) {
! 1702: /* non-parsed header ... we parse them anyway */
! 1703:
! 1704: if ((s[7] == '1' ||
! 1705: s[7] == '0') &&
! 1706: s[8] == ' ') {
! 1707: int status;
! 1708: /* after the space should be a status code for us */
! 1709:
! 1710: status = strtol(s+9, NULL, 10);
! 1711:
! 1712: if (status >= 100 && status < 1000) {
! 1713: /* we expected 3 digits got them */
! 1714: con->parsed_response |= HTTP_STATUS;
! 1715: con->http_status = status;
! 1716: }
! 1717: }
! 1718: } else {
! 1719:
! 1720: key = s;
! 1721: if (NULL == (value = strchr(s, ':'))) {
! 1722: /* we expect: "<key>: <value>\r\n" */
! 1723: continue;
! 1724: }
! 1725:
! 1726: key_len = value - key;
! 1727: value += 1;
! 1728:
! 1729: /* skip LWS */
! 1730: while (*value == ' ' || *value == '\t') value++;
! 1731:
! 1732: if (NULL == (ds = (data_string *)array_get_unused_element(con->response.headers, TYPE_STRING))) {
! 1733: ds = data_response_init();
! 1734: }
! 1735: buffer_copy_string_len(ds->key, key, key_len);
! 1736: buffer_copy_string(ds->value, value);
! 1737:
! 1738: array_insert_unique(con->response.headers, (data_unset *)ds);
! 1739:
! 1740: switch(key_len) {
! 1741: case 4:
! 1742: if (0 == strncasecmp(key, "Date", key_len)) {
! 1743: con->parsed_response |= HTTP_DATE;
! 1744: }
! 1745: break;
! 1746: case 6:
! 1747: if (0 == strncasecmp(key, "Status", key_len)) {
! 1748: con->http_status = strtol(value, NULL, 10);
! 1749: con->parsed_response |= HTTP_STATUS;
! 1750: }
! 1751: break;
! 1752: case 8:
! 1753: if (0 == strncasecmp(key, "Location", key_len)) {
! 1754: con->parsed_response |= HTTP_LOCATION;
! 1755: }
! 1756: break;
! 1757: case 10:
! 1758: if (0 == strncasecmp(key, "Connection", key_len)) {
! 1759: con->response.keep_alive = (0 == strcasecmp(value, "Keep-Alive")) ? 1 : 0;
! 1760: con->parsed_response |= HTTP_CONNECTION;
! 1761: }
! 1762: break;
! 1763: case 14:
! 1764: if (0 == strncasecmp(key, "Content-Length", key_len)) {
! 1765: con->response.content_length = strtol(value, NULL, 10);
! 1766: con->parsed_response |= HTTP_CONTENT_LENGTH;
! 1767: }
! 1768: break;
! 1769: default:
! 1770: break;
! 1771: }
! 1772: }
! 1773: }
! 1774:
! 1775: /* CGI/1.1 rev 03 - 7.2.1.2 */
! 1776: if ((con->parsed_response & HTTP_LOCATION) &&
! 1777: !(con->parsed_response & HTTP_STATUS)) {
! 1778: con->http_status = 302;
! 1779: }
! 1780:
! 1781: return 0;
! 1782: }
! 1783:
! 1784:
! 1785: static int scgi_demux_response(server *srv, handler_ctx *hctx) {
! 1786: plugin_data *p = hctx->plugin_data;
! 1787: connection *con = hctx->remote_conn;
! 1788:
! 1789: while(1) {
! 1790: int n;
! 1791:
! 1792: buffer_prepare_copy(hctx->response, 1024);
! 1793: if (-1 == (n = read(hctx->fd, hctx->response->ptr, hctx->response->size - 1))) {
! 1794: if (errno == EAGAIN || errno == EINTR) {
! 1795: /* would block, wait for signal */
! 1796: return 0;
! 1797: }
! 1798: /* error */
! 1799: log_error_write(srv, __FILE__, __LINE__, "sdd", strerror(errno), con->fd, hctx->fd);
! 1800: return -1;
! 1801: }
! 1802:
! 1803: if (n == 0) {
! 1804: /* read finished */
! 1805:
! 1806: con->file_finished = 1;
! 1807:
! 1808: /* send final chunk */
! 1809: http_chunk_append_mem(srv, con, NULL, 0);
! 1810: joblist_append(srv, con);
! 1811:
! 1812: return 1;
! 1813: }
! 1814:
! 1815: hctx->response->ptr[n] = '\0';
! 1816: hctx->response->used = n+1;
! 1817:
! 1818: /* split header from body */
! 1819:
! 1820: if (con->file_started == 0) {
! 1821: char *c;
! 1822: int in_header = 0;
! 1823: int header_end = 0;
! 1824: int cp, eol = EOL_UNSET;
! 1825: size_t used = 0;
! 1826: size_t hlen = 0;
! 1827:
! 1828: buffer_append_string_buffer(hctx->response_header, hctx->response);
! 1829:
! 1830: /* nph (non-parsed headers) */
! 1831: if (0 == strncmp(hctx->response_header->ptr, "HTTP/1.", 7)) in_header = 1;
! 1832:
! 1833: /* search for the \r\n\r\n or \n\n in the string */
! 1834: for (c = hctx->response_header->ptr, cp = 0, used = hctx->response_header->used - 1; used; c++, cp++, used--) {
! 1835: if (*c == ':') in_header = 1;
! 1836: else if (*c == '\n') {
! 1837: if (in_header == 0) {
! 1838: /* got a response without a response header */
! 1839:
! 1840: c = NULL;
! 1841: header_end = 1;
! 1842: break;
! 1843: }
! 1844:
! 1845: if (eol == EOL_UNSET) eol = EOL_N;
! 1846:
! 1847: if (*(c+1) == '\n') {
! 1848: header_end = 1;
! 1849: hlen = cp + 2;
! 1850: break;
! 1851: }
! 1852:
! 1853: } else if (used > 1 && *c == '\r' && *(c+1) == '\n') {
! 1854: if (in_header == 0) {
! 1855: /* got a response without a response header */
! 1856:
! 1857: c = NULL;
! 1858: header_end = 1;
! 1859: break;
! 1860: }
! 1861:
! 1862: if (eol == EOL_UNSET) eol = EOL_RN;
! 1863:
! 1864: if (used > 3 &&
! 1865: *(c+2) == '\r' &&
! 1866: *(c+3) == '\n') {
! 1867: header_end = 1;
! 1868: hlen = cp + 4;
! 1869: break;
! 1870: }
! 1871:
! 1872: /* skip the \n */
! 1873: c++;
! 1874: cp++;
! 1875: used--;
! 1876: }
! 1877: }
! 1878:
! 1879: if (header_end) {
! 1880: if (c == NULL) {
! 1881: /* no header, but a body */
! 1882:
! 1883: if (con->request.http_version == HTTP_VERSION_1_1) {
! 1884: con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
! 1885: }
! 1886:
! 1887: http_chunk_append_mem(srv, con, hctx->response_header->ptr, hctx->response_header->used);
! 1888: joblist_append(srv, con);
! 1889: } else {
! 1890: size_t blen = hctx->response_header->used - hlen - 1;
! 1891:
! 1892: /* a small hack: terminate after at the second \r */
! 1893: hctx->response_header->used = hlen;
! 1894: hctx->response_header->ptr[hlen - 1] = '\0';
! 1895:
! 1896: /* parse the response header */
! 1897: scgi_response_parse(srv, con, p, hctx->response_header, eol);
! 1898:
! 1899: /* enable chunked-transfer-encoding */
! 1900: if (con->request.http_version == HTTP_VERSION_1_1 &&
! 1901: !(con->parsed_response & HTTP_CONTENT_LENGTH)) {
! 1902: con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
! 1903: }
! 1904:
! 1905: if ((hctx->response->used != hlen) && blen > 0) {
! 1906: http_chunk_append_mem(srv, con, hctx->response_header->ptr + hlen, blen + 1);
! 1907: joblist_append(srv, con);
! 1908: }
! 1909: }
! 1910:
! 1911: con->file_started = 1;
! 1912: }
! 1913: } else {
! 1914: http_chunk_append_mem(srv, con, hctx->response->ptr, hctx->response->used);
! 1915: joblist_append(srv, con);
! 1916: }
! 1917:
! 1918: #if 0
! 1919: log_error_write(srv, __FILE__, __LINE__, "ddss", con->fd, hctx->fd, connection_get_state(con->state), b->ptr);
! 1920: #endif
! 1921: }
! 1922:
! 1923: return 0;
! 1924: }
! 1925:
! 1926:
! 1927: static int scgi_proclist_sort_up(server *srv, scgi_extension_host *host, scgi_proc *proc) {
! 1928: scgi_proc *p;
! 1929:
! 1930: UNUSED(srv);
! 1931:
! 1932: /* we have been the smallest of the current list
! 1933: * and we want to insert the node sorted as soon
! 1934: * possible
! 1935: *
! 1936: * 1 0 0 0 1 1 1
! 1937: * | ^
! 1938: * | |
! 1939: * +------+
! 1940: *
! 1941: */
! 1942:
! 1943: /* nothing to sort, only one element */
! 1944: if (host->first == proc && proc->next == NULL) return 0;
! 1945:
! 1946: for (p = proc; p->next && p->next->load < proc->load; p = p->next);
! 1947:
! 1948: /* no need to move something
! 1949: *
! 1950: * 1 2 2 2 3 3 3
! 1951: * ^
! 1952: * |
! 1953: * +
! 1954: *
! 1955: */
! 1956: if (p == proc) return 0;
! 1957:
! 1958: if (host->first == proc) {
! 1959: /* we have been the first elememt */
! 1960:
! 1961: host->first = proc->next;
! 1962: host->first->prev = NULL;
! 1963: }
! 1964:
! 1965: /* disconnect proc */
! 1966:
! 1967: if (proc->prev) proc->prev->next = proc->next;
! 1968: if (proc->next) proc->next->prev = proc->prev;
! 1969:
! 1970: /* proc should be right of p */
! 1971:
! 1972: proc->next = p->next;
! 1973: proc->prev = p;
! 1974: if (p->next) p->next->prev = proc;
! 1975: p->next = proc;
! 1976: #if 0
! 1977: for(p = host->first; p; p = p->next) {
! 1978: log_error_write(srv, __FILE__, __LINE__, "dd",
! 1979: p->pid, p->load);
! 1980: }
! 1981: #else
! 1982: UNUSED(srv);
! 1983: #endif
! 1984:
! 1985: return 0;
! 1986: }
! 1987:
! 1988: int scgi_proclist_sort_down(server *srv, scgi_extension_host *host, scgi_proc *proc) {
! 1989: scgi_proc *p;
! 1990:
! 1991: UNUSED(srv);
! 1992:
! 1993: /* we have been the smallest of the current list
! 1994: * and we want to insert the node sorted as soon
! 1995: * possible
! 1996: *
! 1997: * 0 0 0 0 1 0 1
! 1998: * ^ |
! 1999: * | |
! 2000: * +----------+
! 2001: *
! 2002: *
! 2003: * the basic is idea is:
! 2004: * - the last active scgi process should be still
! 2005: * in ram and is not swapped out yet
! 2006: * - processes that are not reused will be killed
! 2007: * after some time by the trigger-handler
! 2008: * - remember it as:
! 2009: * everything > 0 is hot
! 2010: * all unused procs are colder the more right they are
! 2011: * ice-cold processes are propably unused since more
! 2012: * than 'unused-timeout', are swaped out and won't be
! 2013: * reused in the next seconds anyway.
! 2014: *
! 2015: */
! 2016:
! 2017: /* nothing to sort, only one element */
! 2018: if (host->first == proc && proc->next == NULL) return 0;
! 2019:
! 2020: for (p = host->first; p != proc && p->load < proc->load; p = p->next);
! 2021:
! 2022:
! 2023: /* no need to move something
! 2024: *
! 2025: * 1 2 2 2 3 3 3
! 2026: * ^
! 2027: * |
! 2028: * +
! 2029: *
! 2030: */
! 2031: if (p == proc) return 0;
! 2032:
! 2033: /* we have to move left. If we are already the first element
! 2034: * we are done */
! 2035: if (host->first == proc) return 0;
! 2036:
! 2037: /* release proc */
! 2038: if (proc->prev) proc->prev->next = proc->next;
! 2039: if (proc->next) proc->next->prev = proc->prev;
! 2040:
! 2041: /* proc should be left of p */
! 2042: proc->next = p;
! 2043: proc->prev = p->prev;
! 2044: if (p->prev) p->prev->next = proc;
! 2045: p->prev = proc;
! 2046:
! 2047: if (proc->prev == NULL) host->first = proc;
! 2048: #if 0
! 2049: for(p = host->first; p; p = p->next) {
! 2050: log_error_write(srv, __FILE__, __LINE__, "dd",
! 2051: p->pid, p->load);
! 2052: }
! 2053: #else
! 2054: UNUSED(srv);
! 2055: #endif
! 2056:
! 2057: return 0;
! 2058: }
! 2059:
! 2060: static int scgi_restart_dead_procs(server *srv, plugin_data *p, scgi_extension_host *host) {
! 2061: scgi_proc *proc;
! 2062:
! 2063: for (proc = host->first; proc; proc = proc->next) {
! 2064: if (p->conf.debug) {
! 2065: log_error_write(srv, __FILE__, __LINE__, "sbdbdddd",
! 2066: "proc:",
! 2067: host->host, proc->port,
! 2068: proc->socket,
! 2069: proc->state,
! 2070: proc->is_local,
! 2071: proc->load,
! 2072: proc->pid);
! 2073: }
! 2074:
! 2075: if (0 == proc->is_local) {
! 2076: /*
! 2077: * external servers might get disabled
! 2078: *
! 2079: * enable the server again, perhaps it is back again
! 2080: */
! 2081:
! 2082: if ((proc->state == PROC_STATE_DISABLED) &&
! 2083: (srv->cur_ts - proc->disable_ts > host->disable_time)) {
! 2084: proc->state = PROC_STATE_RUNNING;
! 2085: host->active_procs++;
! 2086:
! 2087: log_error_write(srv, __FILE__, __LINE__, "sbdb",
! 2088: "fcgi-server re-enabled:",
! 2089: host->host, host->port,
! 2090: host->unixsocket);
! 2091: }
! 2092: } else {
! 2093: /* the child should not terminate at all */
! 2094: int status;
! 2095:
! 2096: if (proc->state == PROC_STATE_DIED_WAIT_FOR_PID) {
! 2097: switch(waitpid(proc->pid, &status, WNOHANG)) {
! 2098: case 0:
! 2099: /* child is still alive */
! 2100: break;
! 2101: case -1:
! 2102: break;
! 2103: default:
! 2104: if (WIFEXITED(status)) {
! 2105: #if 0
! 2106: log_error_write(srv, __FILE__, __LINE__, "sdsd",
! 2107: "child exited, pid:", proc->pid,
! 2108: "status:", WEXITSTATUS(status));
! 2109: #endif
! 2110: } else if (WIFSIGNALED(status)) {
! 2111: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2112: "child signaled:",
! 2113: WTERMSIG(status));
! 2114: } else {
! 2115: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2116: "child died somehow:",
! 2117: status);
! 2118: }
! 2119:
! 2120: proc->state = PROC_STATE_DIED;
! 2121: break;
! 2122: }
! 2123: }
! 2124:
! 2125: /*
! 2126: * local servers might died, but we restart them
! 2127: *
! 2128: */
! 2129: if (proc->state == PROC_STATE_DIED &&
! 2130: proc->load == 0) {
! 2131: /* restart the child */
! 2132:
! 2133: if (p->conf.debug) {
! 2134: log_error_write(srv, __FILE__, __LINE__, "ssdsbsdsd",
! 2135: "--- scgi spawning",
! 2136: "\n\tport:", host->port,
! 2137: "\n\tsocket", host->unixsocket,
! 2138: "\n\tcurrent:", 1, "/", host->min_procs);
! 2139: }
! 2140:
! 2141: if (scgi_spawn_connection(srv, p, host, proc)) {
! 2142: log_error_write(srv, __FILE__, __LINE__, "s",
! 2143: "ERROR: spawning fcgi failed.");
! 2144: return HANDLER_ERROR;
! 2145: }
! 2146:
! 2147: scgi_proclist_sort_down(srv, host, proc);
! 2148: }
! 2149: }
! 2150: }
! 2151:
! 2152: return 0;
! 2153: }
! 2154:
! 2155:
! 2156: static handler_t scgi_write_request(server *srv, handler_ctx *hctx) {
! 2157: plugin_data *p = hctx->plugin_data;
! 2158: scgi_extension_host *host= hctx->host;
! 2159: connection *con = hctx->remote_conn;
! 2160:
! 2161: int ret;
! 2162:
! 2163: /* sanity check */
! 2164: if (!host) {
! 2165: log_error_write(srv, __FILE__, __LINE__, "s", "fatal error: host = NULL");
! 2166: return HANDLER_ERROR;
! 2167: }
! 2168: if (((!host->host->used || !host->port) && !host->unixsocket->used)) {
! 2169: log_error_write(srv, __FILE__, __LINE__, "sxddd",
! 2170: "write-req: error",
! 2171: host,
! 2172: host->host->used,
! 2173: host->port,
! 2174: host->unixsocket->used);
! 2175: return HANDLER_ERROR;
! 2176: }
! 2177:
! 2178:
! 2179: switch(hctx->state) {
! 2180: case FCGI_STATE_INIT:
! 2181: ret = host->unixsocket->used ? AF_UNIX : AF_INET;
! 2182:
! 2183: if (-1 == (hctx->fd = socket(ret, SOCK_STREAM, 0))) {
! 2184: if (errno == EMFILE ||
! 2185: errno == EINTR) {
! 2186: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2187: "wait for fd at connection:", con->fd);
! 2188:
! 2189: return HANDLER_WAIT_FOR_FD;
! 2190: }
! 2191:
! 2192: log_error_write(srv, __FILE__, __LINE__, "ssdd",
! 2193: "socket failed:", strerror(errno), srv->cur_fds, srv->max_fds);
! 2194: return HANDLER_ERROR;
! 2195: }
! 2196: hctx->fde_ndx = -1;
! 2197:
! 2198: srv->cur_fds++;
! 2199:
! 2200: fdevent_register(srv->ev, hctx->fd, scgi_handle_fdevent, hctx);
! 2201:
! 2202: if (-1 == fdevent_fcntl_set(srv->ev, hctx->fd)) {
! 2203: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2204: "fcntl failed: ", strerror(errno));
! 2205:
! 2206: return HANDLER_ERROR;
! 2207: }
! 2208:
! 2209: /* fall through */
! 2210: case FCGI_STATE_CONNECT:
! 2211: if (hctx->state == FCGI_STATE_INIT) {
! 2212: for (hctx->proc = hctx->host->first;
! 2213: hctx->proc && hctx->proc->state != PROC_STATE_RUNNING;
! 2214: hctx->proc = hctx->proc->next);
! 2215:
! 2216: /* all childs are dead */
! 2217: if (hctx->proc == NULL) {
! 2218: hctx->fde_ndx = -1;
! 2219:
! 2220: return HANDLER_ERROR;
! 2221: }
! 2222:
! 2223: if (hctx->proc->is_local) {
! 2224: hctx->pid = hctx->proc->pid;
! 2225: }
! 2226:
! 2227: switch (scgi_establish_connection(srv, hctx)) {
! 2228: case 1:
! 2229: scgi_set_state(srv, hctx, FCGI_STATE_CONNECT);
! 2230:
! 2231: /* connection is in progress, wait for an event and call getsockopt() below */
! 2232:
! 2233: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
! 2234:
! 2235: return HANDLER_WAIT_FOR_EVENT;
! 2236: case -1:
! 2237: /* if ECONNREFUSED choose another connection -> FIXME */
! 2238: hctx->fde_ndx = -1;
! 2239:
! 2240: return HANDLER_ERROR;
! 2241: default:
! 2242: /* everything is ok, go on */
! 2243: break;
! 2244: }
! 2245:
! 2246:
! 2247: } else {
! 2248: int socket_error;
! 2249: socklen_t socket_error_len = sizeof(socket_error);
! 2250:
! 2251: /* try to finish the connect() */
! 2252: if (0 != getsockopt(hctx->fd, SOL_SOCKET, SO_ERROR, &socket_error, &socket_error_len)) {
! 2253: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2254: "getsockopt failed:", strerror(errno));
! 2255:
! 2256: return HANDLER_ERROR;
! 2257: }
! 2258: if (socket_error != 0) {
! 2259: if (!hctx->proc->is_local || p->conf.debug) {
! 2260: /* local procs get restarted */
! 2261:
! 2262: log_error_write(srv, __FILE__, __LINE__, "ss",
! 2263: "establishing connection failed:", strerror(socket_error),
! 2264: "port:", hctx->proc->port);
! 2265: }
! 2266:
! 2267: return HANDLER_ERROR;
! 2268: }
! 2269: }
! 2270:
! 2271: /* ok, we have the connection */
! 2272:
! 2273: hctx->proc->load++;
! 2274: hctx->proc->last_used = srv->cur_ts;
! 2275: hctx->got_proc = 1;
! 2276:
! 2277: if (p->conf.debug) {
! 2278: log_error_write(srv, __FILE__, __LINE__, "sddbdd",
! 2279: "got proc:",
! 2280: hctx->fd,
! 2281: hctx->proc->pid,
! 2282: hctx->proc->socket,
! 2283: hctx->proc->port,
! 2284: hctx->proc->load);
! 2285: }
! 2286:
! 2287: /* move the proc-list entry down the list */
! 2288: scgi_proclist_sort_up(srv, hctx->host, hctx->proc);
! 2289:
! 2290: scgi_set_state(srv, hctx, FCGI_STATE_PREPARE_WRITE);
! 2291: /* fall through */
! 2292: case FCGI_STATE_PREPARE_WRITE:
! 2293: scgi_create_env(srv, hctx);
! 2294:
! 2295: scgi_set_state(srv, hctx, FCGI_STATE_WRITE);
! 2296:
! 2297: /* fall through */
! 2298: case FCGI_STATE_WRITE:
! 2299: ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb, MAX_WRITE_LIMIT);
! 2300:
! 2301: chunkqueue_remove_finished_chunks(hctx->wb);
! 2302:
! 2303: if (ret < 0) {
! 2304: if (errno == ENOTCONN || ret == -2) {
! 2305: /* the connection got dropped after accept()
! 2306: *
! 2307: * this is most of the time a PHP which dies
! 2308: * after PHP_FCGI_MAX_REQUESTS
! 2309: *
! 2310: */
! 2311: if (hctx->wb->bytes_out == 0 &&
! 2312: hctx->reconnects < 5) {
! 2313: usleep(10000); /* take away the load of the webserver
! 2314: * to let the php a chance to restart
! 2315: */
! 2316:
! 2317: scgi_reconnect(srv, hctx);
! 2318:
! 2319: return HANDLER_WAIT_FOR_FD;
! 2320: }
! 2321:
! 2322: /* not reconnected ... why
! 2323: *
! 2324: * far@#lighttpd report this for FreeBSD
! 2325: *
! 2326: */
! 2327:
! 2328: log_error_write(srv, __FILE__, __LINE__, "ssosd",
! 2329: "connection was dropped after accept(). reconnect() denied:",
! 2330: "write-offset:", hctx->wb->bytes_out,
! 2331: "reconnect attempts:", hctx->reconnects);
! 2332:
! 2333: return HANDLER_ERROR;
! 2334: } else {
! 2335: /* -1 == ret => error on our side */
! 2336: log_error_write(srv, __FILE__, __LINE__, "ssd",
! 2337: "write failed:", strerror(errno), errno);
! 2338:
! 2339: return HANDLER_ERROR;
! 2340: }
! 2341: }
! 2342:
! 2343: if (hctx->wb->bytes_out == hctx->wb->bytes_in) {
! 2344: /* we don't need the out event anymore */
! 2345: fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
! 2346: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
! 2347: scgi_set_state(srv, hctx, FCGI_STATE_READ);
! 2348: } else {
! 2349: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
! 2350:
! 2351: return HANDLER_WAIT_FOR_EVENT;
! 2352: }
! 2353:
! 2354: break;
! 2355: case FCGI_STATE_READ:
! 2356: /* waiting for a response */
! 2357: break;
! 2358: default:
! 2359: log_error_write(srv, __FILE__, __LINE__, "s", "(debug) unknown state");
! 2360: return HANDLER_ERROR;
! 2361: }
! 2362:
! 2363: return HANDLER_WAIT_FOR_EVENT;
! 2364: }
! 2365:
! 2366: SUBREQUEST_FUNC(mod_scgi_handle_subrequest) {
! 2367: plugin_data *p = p_d;
! 2368:
! 2369: handler_ctx *hctx = con->plugin_ctx[p->id];
! 2370: scgi_proc *proc;
! 2371: scgi_extension_host *host;
! 2372:
! 2373: if (NULL == hctx) return HANDLER_GO_ON;
! 2374:
! 2375: /* not my job */
! 2376: if (con->mode != p->id) return HANDLER_GO_ON;
! 2377:
! 2378: /* ok, create the request */
! 2379: switch(scgi_write_request(srv, hctx)) {
! 2380: case HANDLER_ERROR:
! 2381: proc = hctx->proc;
! 2382: host = hctx->host;
! 2383:
! 2384: if (proc &&
! 2385: 0 == proc->is_local &&
! 2386: proc->state != PROC_STATE_DISABLED) {
! 2387: /* only disable remote servers as we don't manage them*/
! 2388:
! 2389: log_error_write(srv, __FILE__, __LINE__, "sbdb", "fcgi-server disabled:",
! 2390: host->host,
! 2391: proc->port,
! 2392: proc->socket);
! 2393:
! 2394: /* disable this server */
! 2395: proc->disable_ts = srv->cur_ts;
! 2396: proc->state = PROC_STATE_DISABLED;
! 2397: host->active_procs--;
! 2398: }
! 2399:
! 2400: if (hctx->state == FCGI_STATE_INIT ||
! 2401: hctx->state == FCGI_STATE_CONNECT) {
! 2402: /* connect() or getsockopt() failed,
! 2403: * restart the request-handling
! 2404: */
! 2405: if (proc && proc->is_local) {
! 2406:
! 2407: if (p->conf.debug) {
! 2408: log_error_write(srv, __FILE__, __LINE__, "sbdb", "connect() to scgi failed, restarting the request-handling:",
! 2409: host->host,
! 2410: proc->port,
! 2411: proc->socket);
! 2412: }
! 2413:
! 2414: /*
! 2415: * several hctx might reference the same proc
! 2416: *
! 2417: * Only one of them should mark the proc as dead all the other
! 2418: * ones should just take a new one.
! 2419: *
! 2420: * If a new proc was started with the old struct this might lead
! 2421: * the mark a perfect proc as dead otherwise
! 2422: *
! 2423: */
! 2424: if (proc->state == PROC_STATE_RUNNING &&
! 2425: hctx->pid == proc->pid) {
! 2426: proc->state = PROC_STATE_DIED_WAIT_FOR_PID;
! 2427: }
! 2428: }
! 2429: scgi_restart_dead_procs(srv, p, host);
! 2430:
! 2431: scgi_connection_cleanup(srv, hctx);
! 2432:
! 2433: buffer_reset(con->physical.path);
! 2434: con->mode = DIRECT;
! 2435: joblist_append(srv, con);
! 2436:
! 2437: /* mis-using HANDLER_WAIT_FOR_FD to break out of the loop
! 2438: * and hope that the childs will be restarted
! 2439: *
! 2440: */
! 2441: return HANDLER_WAIT_FOR_FD;
! 2442: } else {
! 2443: scgi_connection_cleanup(srv, hctx);
! 2444:
! 2445: buffer_reset(con->physical.path);
! 2446: con->mode = DIRECT;
! 2447: con->http_status = 503;
! 2448:
! 2449: return HANDLER_FINISHED;
! 2450: }
! 2451: case HANDLER_WAIT_FOR_EVENT:
! 2452: if (con->file_started == 1) {
! 2453: return HANDLER_FINISHED;
! 2454: } else {
! 2455: return HANDLER_WAIT_FOR_EVENT;
! 2456: }
! 2457: case HANDLER_WAIT_FOR_FD:
! 2458: return HANDLER_WAIT_FOR_FD;
! 2459: default:
! 2460: log_error_write(srv, __FILE__, __LINE__, "s", "subrequest write-req default");
! 2461: return HANDLER_ERROR;
! 2462: }
! 2463: }
! 2464:
! 2465: static handler_t scgi_connection_close(server *srv, handler_ctx *hctx) {
! 2466: connection *con;
! 2467:
! 2468: if (NULL == hctx) return HANDLER_GO_ON;
! 2469:
! 2470: con = hctx->remote_conn;
! 2471:
! 2472: log_error_write(srv, __FILE__, __LINE__, "ssdsd",
! 2473: "emergency exit: scgi:",
! 2474: "connection-fd:", con->fd,
! 2475: "fcgi-fd:", hctx->fd);
! 2476:
! 2477: scgi_connection_cleanup(srv, hctx);
! 2478:
! 2479: return HANDLER_FINISHED;
! 2480: }
! 2481:
! 2482:
! 2483: static handler_t scgi_handle_fdevent(server *srv, void *ctx, int revents) {
! 2484: handler_ctx *hctx = ctx;
! 2485: connection *con = hctx->remote_conn;
! 2486: plugin_data *p = hctx->plugin_data;
! 2487:
! 2488: scgi_proc *proc = hctx->proc;
! 2489: scgi_extension_host *host= hctx->host;
! 2490:
! 2491: if ((revents & FDEVENT_IN) &&
! 2492: hctx->state == FCGI_STATE_READ) {
! 2493: switch (scgi_demux_response(srv, hctx)) {
! 2494: case 0:
! 2495: break;
! 2496: case 1:
! 2497: /* we are done */
! 2498: scgi_connection_cleanup(srv, hctx);
! 2499:
! 2500: joblist_append(srv, con);
! 2501: return HANDLER_FINISHED;
! 2502: case -1:
! 2503: if (proc->pid && proc->state != PROC_STATE_DIED) {
! 2504: int status;
! 2505:
! 2506: /* only fetch the zombie if it is not already done */
! 2507:
! 2508: switch(waitpid(proc->pid, &status, WNOHANG)) {
! 2509: case 0:
! 2510: /* child is still alive */
! 2511: break;
! 2512: case -1:
! 2513: break;
! 2514: default:
! 2515: /* the child should not terminate at all */
! 2516: if (WIFEXITED(status)) {
! 2517: log_error_write(srv, __FILE__, __LINE__, "sdsd",
! 2518: "child exited, pid:", proc->pid,
! 2519: "status:", WEXITSTATUS(status));
! 2520: } else if (WIFSIGNALED(status)) {
! 2521: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2522: "child signaled:",
! 2523: WTERMSIG(status));
! 2524: } else {
! 2525: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2526: "child died somehow:",
! 2527: status);
! 2528: }
! 2529:
! 2530: if (p->conf.debug) {
! 2531: log_error_write(srv, __FILE__, __LINE__, "ssdsbsdsd",
! 2532: "--- scgi spawning",
! 2533: "\n\tport:", host->port,
! 2534: "\n\tsocket", host->unixsocket,
! 2535: "\n\tcurrent:", 1, "/", host->min_procs);
! 2536: }
! 2537:
! 2538: if (scgi_spawn_connection(srv, p, host, proc)) {
! 2539: /* child died */
! 2540: proc->state = PROC_STATE_DIED;
! 2541: } else {
! 2542: scgi_proclist_sort_down(srv, host, proc);
! 2543: }
! 2544:
! 2545: break;
! 2546: }
! 2547: }
! 2548:
! 2549: if (con->file_started == 0) {
! 2550: /* nothing has been send out yet, try to use another child */
! 2551:
! 2552: if (hctx->wb->bytes_out == 0 &&
! 2553: hctx->reconnects < 5) {
! 2554: scgi_reconnect(srv, hctx);
! 2555:
! 2556: log_error_write(srv, __FILE__, __LINE__, "ssdsd",
! 2557: "response not sent, request not sent, reconnection.",
! 2558: "connection-fd:", con->fd,
! 2559: "fcgi-fd:", hctx->fd);
! 2560:
! 2561: return HANDLER_WAIT_FOR_FD;
! 2562: }
! 2563:
! 2564: log_error_write(srv, __FILE__, __LINE__, "sosdsd",
! 2565: "response not sent, request sent:", hctx->wb->bytes_out,
! 2566: "connection-fd:", con->fd,
! 2567: "fcgi-fd:", hctx->fd);
! 2568:
! 2569: scgi_connection_cleanup(srv, hctx);
! 2570:
! 2571: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 2572: buffer_reset(con->physical.path);
! 2573: con->http_status = 500;
! 2574: con->mode = DIRECT;
! 2575: } else {
! 2576: /* response might have been already started, kill the connection */
! 2577: log_error_write(srv, __FILE__, __LINE__, "ssdsd",
! 2578: "response already sent out, termination connection",
! 2579: "connection-fd:", con->fd,
! 2580: "fcgi-fd:", hctx->fd);
! 2581:
! 2582: scgi_connection_cleanup(srv, hctx);
! 2583:
! 2584: connection_set_state(srv, con, CON_STATE_ERROR);
! 2585: }
! 2586:
! 2587: /* */
! 2588:
! 2589:
! 2590: joblist_append(srv, con);
! 2591: return HANDLER_FINISHED;
! 2592: }
! 2593: }
! 2594:
! 2595: if (revents & FDEVENT_OUT) {
! 2596: if (hctx->state == FCGI_STATE_CONNECT ||
! 2597: hctx->state == FCGI_STATE_WRITE) {
! 2598: /* we are allowed to send something out
! 2599: *
! 2600: * 1. in a unfinished connect() call
! 2601: * 2. in a unfinished write() call (long POST request)
! 2602: */
! 2603: return mod_scgi_handle_subrequest(srv, con, p);
! 2604: } else {
! 2605: log_error_write(srv, __FILE__, __LINE__, "sd",
! 2606: "got a FDEVENT_OUT and didn't know why:",
! 2607: hctx->state);
! 2608: }
! 2609: }
! 2610:
! 2611: /* perhaps this issue is already handled */
! 2612: if (revents & FDEVENT_HUP) {
! 2613: if (hctx->state == FCGI_STATE_CONNECT) {
! 2614: /* getoptsock will catch this one (right ?)
! 2615: *
! 2616: * if we are in connect we might get a EINPROGRESS
! 2617: * in the first call and a FDEVENT_HUP in the
! 2618: * second round
! 2619: *
! 2620: * FIXME: as it is a bit ugly.
! 2621: *
! 2622: */
! 2623: return mod_scgi_handle_subrequest(srv, con, p);
! 2624: } else if (hctx->state == FCGI_STATE_READ &&
! 2625: hctx->proc->port == 0) {
! 2626: /* FIXME:
! 2627: *
! 2628: * ioctl says 8192 bytes to read from PHP and we receive directly a HUP for the socket
! 2629: * even if the FCGI_FIN packet is not received yet
! 2630: */
! 2631: } else {
! 2632: log_error_write(srv, __FILE__, __LINE__, "sbSBSDSd",
! 2633: "error: unexpected close of scgi connection for",
! 2634: con->uri.path,
! 2635: "(no scgi process on host: ",
! 2636: host->host,
! 2637: ", port: ",
! 2638: host->port,
! 2639: " ?)",
! 2640: hctx->state);
! 2641:
! 2642: connection_set_state(srv, con, CON_STATE_ERROR);
! 2643: scgi_connection_close(srv, hctx);
! 2644: joblist_append(srv, con);
! 2645: }
! 2646: } else if (revents & FDEVENT_ERR) {
! 2647: log_error_write(srv, __FILE__, __LINE__, "s",
! 2648: "fcgi: got a FDEVENT_ERR. Don't know why.");
! 2649: /* kill all connections to the scgi process */
! 2650:
! 2651:
! 2652: connection_set_state(srv, con, CON_STATE_ERROR);
! 2653: scgi_connection_close(srv, hctx);
! 2654: joblist_append(srv, con);
! 2655: }
! 2656:
! 2657: return HANDLER_FINISHED;
! 2658: }
! 2659: #define PATCH(x) \
! 2660: p->conf.x = s->x;
! 2661: static int scgi_patch_connection(server *srv, connection *con, plugin_data *p) {
! 2662: size_t i, j;
! 2663: plugin_config *s = p->config_storage[0];
! 2664:
! 2665: PATCH(exts);
! 2666: PATCH(debug);
! 2667:
! 2668: /* skip the first, the global context */
! 2669: for (i = 1; i < srv->config_context->used; i++) {
! 2670: data_config *dc = (data_config *)srv->config_context->data[i];
! 2671: s = p->config_storage[i];
! 2672:
! 2673: /* condition didn't match */
! 2674: if (!config_check_cond(srv, con, dc)) continue;
! 2675:
! 2676: /* merge config */
! 2677: for (j = 0; j < dc->value->used; j++) {
! 2678: data_unset *du = dc->value->data[j];
! 2679:
! 2680: if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.server"))) {
! 2681: PATCH(exts);
! 2682: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.debug"))) {
! 2683: PATCH(debug);
! 2684: }
! 2685: }
! 2686: }
! 2687:
! 2688: return 0;
! 2689: }
! 2690: #undef PATCH
! 2691:
! 2692:
! 2693: static handler_t scgi_check_extension(server *srv, connection *con, void *p_d, int uri_path_handler) {
! 2694: plugin_data *p = p_d;
! 2695: size_t s_len;
! 2696: int used = -1;
! 2697: size_t k;
! 2698: buffer *fn;
! 2699: scgi_extension *extension = NULL;
! 2700: scgi_extension_host *host = NULL;
! 2701:
! 2702: if (con->mode != DIRECT) return HANDLER_GO_ON;
! 2703:
! 2704: /* Possibly, we processed already this request */
! 2705: if (con->file_started == 1) return HANDLER_GO_ON;
! 2706:
! 2707: fn = uri_path_handler ? con->uri.path : con->physical.path;
! 2708:
! 2709: if (buffer_is_empty(fn)) return HANDLER_GO_ON;
! 2710:
! 2711: s_len = fn->used - 1;
! 2712:
! 2713: scgi_patch_connection(srv, con, p);
! 2714:
! 2715: /* check if extension matches */
! 2716: for (k = 0; k < p->conf.exts->used; k++) {
! 2717: size_t ct_len;
! 2718: scgi_extension *ext = p->conf.exts->exts[k];
! 2719:
! 2720: if (ext->key->used == 0) continue;
! 2721:
! 2722: ct_len = ext->key->used - 1;
! 2723:
! 2724: if (s_len < ct_len) continue;
! 2725:
! 2726: /* check extension in the form "/scgi_pattern" */
! 2727: if (*(ext->key->ptr) == '/') {
! 2728: if (strncmp(fn->ptr, ext->key->ptr, ct_len) == 0) {
! 2729: extension = ext;
! 2730: break;
! 2731: }
! 2732: } else if (0 == strncmp(fn->ptr + s_len - ct_len, ext->key->ptr, ct_len)) {
! 2733: /* check extension in the form ".fcg" */
! 2734: extension = ext;
! 2735: break;
! 2736: }
! 2737: }
! 2738:
! 2739: /* extension doesn't match */
! 2740: if (NULL == extension) {
! 2741: return HANDLER_GO_ON;
! 2742: }
! 2743:
! 2744: /* get best server */
! 2745: for (k = 0; k < extension->used; k++) {
! 2746: scgi_extension_host *h = extension->hosts[k];
! 2747:
! 2748: /* we should have at least one proc that can do something */
! 2749: if (h->active_procs == 0) {
! 2750: continue;
! 2751: }
! 2752:
! 2753: if (used == -1 || h->load < used) {
! 2754: used = h->load;
! 2755:
! 2756: host = h;
! 2757: }
! 2758: }
! 2759:
! 2760: if (!host) {
! 2761: /* sorry, we don't have a server alive for this ext */
! 2762: buffer_reset(con->physical.path);
! 2763: con->http_status = 500;
! 2764:
! 2765: /* only send the 'no handler' once */
! 2766: if (!extension->note_is_sent) {
! 2767: extension->note_is_sent = 1;
! 2768:
! 2769: log_error_write(srv, __FILE__, __LINE__, "sbsbs",
! 2770: "all handlers for ", con->uri.path,
! 2771: "on", extension->key,
! 2772: "are down.");
! 2773: }
! 2774:
! 2775: return HANDLER_FINISHED;
! 2776: }
! 2777:
! 2778: /* a note about no handler is not sent yet */
! 2779: extension->note_is_sent = 0;
! 2780:
! 2781: /*
! 2782: * if check-local is disabled, use the uri.path handler
! 2783: *
! 2784: */
! 2785:
! 2786: /* init handler-context */
! 2787: if (uri_path_handler) {
! 2788: if (host->check_local == 0) {
! 2789: handler_ctx *hctx;
! 2790: char *pathinfo;
! 2791:
! 2792: hctx = handler_ctx_init();
! 2793:
! 2794: hctx->remote_conn = con;
! 2795: hctx->plugin_data = p;
! 2796: hctx->host = host;
! 2797: hctx->proc = NULL;
! 2798:
! 2799: hctx->conf.exts = p->conf.exts;
! 2800: hctx->conf.debug = p->conf.debug;
! 2801:
! 2802: con->plugin_ctx[p->id] = hctx;
! 2803:
! 2804: host->load++;
! 2805:
! 2806: con->mode = p->id;
! 2807:
! 2808: if (con->conf.log_request_handling) {
! 2809: log_error_write(srv, __FILE__, __LINE__, "s",
! 2810: "handling it in mod_scgi");
! 2811: }
! 2812:
! 2813: /* the prefix is the SCRIPT_NAME,
! 2814: * everything from start to the next slash
! 2815: * this is important for check-local = "disable"
! 2816: *
! 2817: * if prefix = /admin.fcgi
! 2818: *
! 2819: * /admin.fcgi/foo/bar
! 2820: *
! 2821: * SCRIPT_NAME = /admin.fcgi
! 2822: * PATH_INFO = /foo/bar
! 2823: *
! 2824: * if prefix = /fcgi-bin/
! 2825: *
! 2826: * /fcgi-bin/foo/bar
! 2827: *
! 2828: * SCRIPT_NAME = /fcgi-bin/foo
! 2829: * PATH_INFO = /bar
! 2830: *
! 2831: */
! 2832:
! 2833: /* the rewrite is only done for /prefix/? matches */
! 2834: if (host->fix_root_path_name && extension->key->ptr[0] == '/' && extension->key->ptr[1] == '\0') {
! 2835: buffer_copy_string(con->request.pathinfo, con->uri.path->ptr);
! 2836: con->uri.path->used = 1;
! 2837: con->uri.path->ptr[con->uri.path->used - 1] = '\0';
! 2838: } else if (extension->key->ptr[0] == '/' &&
! 2839: con->uri.path->used > extension->key->used &&
! 2840: NULL != (pathinfo = strchr(con->uri.path->ptr + extension->key->used - 1, '/'))) {
! 2841: /* rewrite uri.path and pathinfo */
! 2842:
! 2843: buffer_copy_string(con->request.pathinfo, pathinfo);
! 2844:
! 2845: con->uri.path->used -= con->request.pathinfo->used - 1;
! 2846: con->uri.path->ptr[con->uri.path->used - 1] = '\0';
! 2847: }
! 2848: }
! 2849: } else {
! 2850: handler_ctx *hctx;
! 2851: hctx = handler_ctx_init();
! 2852:
! 2853: hctx->remote_conn = con;
! 2854: hctx->plugin_data = p;
! 2855: hctx->host = host;
! 2856: hctx->proc = NULL;
! 2857:
! 2858: hctx->conf.exts = p->conf.exts;
! 2859: hctx->conf.debug = p->conf.debug;
! 2860:
! 2861: con->plugin_ctx[p->id] = hctx;
! 2862:
! 2863: host->load++;
! 2864:
! 2865: con->mode = p->id;
! 2866:
! 2867: if (con->conf.log_request_handling) {
! 2868: log_error_write(srv, __FILE__, __LINE__, "s", "handling it in mod_scgi");
! 2869: }
! 2870: }
! 2871:
! 2872: return HANDLER_GO_ON;
! 2873: }
! 2874:
! 2875: /* uri-path handler */
! 2876: static handler_t scgi_check_extension_1(server *srv, connection *con, void *p_d) {
! 2877: return scgi_check_extension(srv, con, p_d, 1);
! 2878: }
! 2879:
! 2880: /* start request handler */
! 2881: static handler_t scgi_check_extension_2(server *srv, connection *con, void *p_d) {
! 2882: return scgi_check_extension(srv, con, p_d, 0);
! 2883: }
! 2884:
! 2885: JOBLIST_FUNC(mod_scgi_handle_joblist) {
! 2886: plugin_data *p = p_d;
! 2887: handler_ctx *hctx = con->plugin_ctx[p->id];
! 2888:
! 2889: if (hctx == NULL) return HANDLER_GO_ON;
! 2890:
! 2891: if (hctx->fd != -1) {
! 2892: switch (hctx->state) {
! 2893: case FCGI_STATE_READ:
! 2894: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
! 2895:
! 2896: break;
! 2897: case FCGI_STATE_CONNECT:
! 2898: case FCGI_STATE_WRITE:
! 2899: fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
! 2900:
! 2901: break;
! 2902: case FCGI_STATE_INIT:
! 2903: /* at reconnect */
! 2904: break;
! 2905: default:
! 2906: log_error_write(srv, __FILE__, __LINE__, "sd", "unhandled fcgi.state", hctx->state);
! 2907: break;
! 2908: }
! 2909: }
! 2910:
! 2911: return HANDLER_GO_ON;
! 2912: }
! 2913:
! 2914:
! 2915: static handler_t scgi_connection_close_callback(server *srv, connection *con, void *p_d) {
! 2916: plugin_data *p = p_d;
! 2917:
! 2918: return scgi_connection_close(srv, con->plugin_ctx[p->id]);
! 2919: }
! 2920:
! 2921: TRIGGER_FUNC(mod_scgi_handle_trigger) {
! 2922: plugin_data *p = p_d;
! 2923: size_t i, j, n;
! 2924:
! 2925:
! 2926: /* perhaps we should kill a connect attempt after 10-15 seconds
! 2927: *
! 2928: * currently we wait for the TCP timeout which is on Linux 180 seconds
! 2929: *
! 2930: *
! 2931: *
! 2932: */
! 2933:
! 2934: /* check all childs if they are still up */
! 2935:
! 2936: for (i = 0; i < srv->config_context->used; i++) {
! 2937: plugin_config *conf;
! 2938: scgi_exts *exts;
! 2939:
! 2940: conf = p->config_storage[i];
! 2941:
! 2942: exts = conf->exts;
! 2943:
! 2944: for (j = 0; j < exts->used; j++) {
! 2945: scgi_extension *ex;
! 2946:
! 2947: ex = exts->exts[j];
! 2948:
! 2949: for (n = 0; n < ex->used; n++) {
! 2950:
! 2951: scgi_proc *proc;
! 2952: unsigned long sum_load = 0;
! 2953: scgi_extension_host *host;
! 2954:
! 2955: host = ex->hosts[n];
! 2956:
! 2957: scgi_restart_dead_procs(srv, p, host);
! 2958:
! 2959: for (proc = host->first; proc; proc = proc->next) {
! 2960: sum_load += proc->load;
! 2961: }
! 2962:
! 2963: if (host->num_procs &&
! 2964: host->num_procs < host->max_procs &&
! 2965: (sum_load / host->num_procs) > host->max_load_per_proc) {
! 2966: /* overload, spawn new child */
! 2967: scgi_proc *fp = NULL;
! 2968:
! 2969: if (p->conf.debug) {
! 2970: log_error_write(srv, __FILE__, __LINE__, "s",
! 2971: "overload detected, spawning a new child");
! 2972: }
! 2973:
! 2974: for (fp = host->unused_procs; fp && fp->pid != 0; fp = fp->next);
! 2975:
! 2976: if (fp) {
! 2977: if (fp == host->unused_procs) host->unused_procs = fp->next;
! 2978:
! 2979: if (fp->next) fp->next->prev = NULL;
! 2980:
! 2981: host->max_id++;
! 2982: } else {
! 2983: fp = scgi_process_init();
! 2984: fp->id = host->max_id++;
! 2985: }
! 2986:
! 2987: host->num_procs++;
! 2988:
! 2989: if (buffer_is_empty(host->unixsocket)) {
! 2990: fp->port = host->port + fp->id;
! 2991: } else {
! 2992: buffer_copy_string_buffer(fp->socket, host->unixsocket);
! 2993: buffer_append_string_len(fp->socket, CONST_STR_LEN("-"));
! 2994: buffer_append_long(fp->socket, fp->id);
! 2995: }
! 2996:
! 2997: if (scgi_spawn_connection(srv, p, host, fp)) {
! 2998: log_error_write(srv, __FILE__, __LINE__, "s",
! 2999: "ERROR: spawning fcgi failed.");
! 3000: return HANDLER_ERROR;
! 3001: }
! 3002:
! 3003: fp->prev = NULL;
! 3004: fp->next = host->first;
! 3005: if (host->first) {
! 3006: host->first->prev = fp;
! 3007: }
! 3008: host->first = fp;
! 3009: }
! 3010:
! 3011: for (proc = host->first; proc; proc = proc->next) {
! 3012: if (proc->load != 0) break;
! 3013: if (host->num_procs <= host->min_procs) break;
! 3014: if (proc->pid == 0) continue;
! 3015:
! 3016: if (srv->cur_ts - proc->last_used > host->idle_timeout) {
! 3017: /* a proc is idling for a long time now,
! 3018: * terminated it */
! 3019:
! 3020: if (p->conf.debug) {
! 3021: log_error_write(srv, __FILE__, __LINE__, "ssbsd",
! 3022: "idle-timeout reached, terminating child:",
! 3023: "socket:", proc->socket,
! 3024: "pid", proc->pid);
! 3025: }
! 3026:
! 3027:
! 3028: if (proc->next) proc->next->prev = proc->prev;
! 3029: if (proc->prev) proc->prev->next = proc->next;
! 3030:
! 3031: if (proc->prev == NULL) host->first = proc->next;
! 3032:
! 3033: proc->prev = NULL;
! 3034: proc->next = host->unused_procs;
! 3035:
! 3036: if (host->unused_procs) host->unused_procs->prev = proc;
! 3037: host->unused_procs = proc;
! 3038:
! 3039: kill(proc->pid, SIGTERM);
! 3040:
! 3041: proc->state = PROC_STATE_KILLED;
! 3042:
! 3043: log_error_write(srv, __FILE__, __LINE__, "ssbsd",
! 3044: "killed:",
! 3045: "socket:", proc->socket,
! 3046: "pid", proc->pid);
! 3047:
! 3048: host->num_procs--;
! 3049:
! 3050: /* proc is now in unused, let the next second handle the next process */
! 3051: break;
! 3052: }
! 3053: }
! 3054:
! 3055: for (proc = host->unused_procs; proc; proc = proc->next) {
! 3056: int status;
! 3057:
! 3058: if (proc->pid == 0) continue;
! 3059:
! 3060: switch (waitpid(proc->pid, &status, WNOHANG)) {
! 3061: case 0:
! 3062: /* child still running after timeout, good */
! 3063: break;
! 3064: case -1:
! 3065: if (errno != EINTR) {
! 3066: /* no PID found ? should never happen */
! 3067: log_error_write(srv, __FILE__, __LINE__, "sddss",
! 3068: "pid ", proc->pid, proc->state,
! 3069: "not found:", strerror(errno));
! 3070:
! 3071: #if 0
! 3072: if (errno == ECHILD) {
! 3073: /* someone else has cleaned up for us */
! 3074: proc->pid = 0;
! 3075: proc->state = PROC_STATE_UNSET;
! 3076: }
! 3077: #endif
! 3078: }
! 3079: break;
! 3080: default:
! 3081: /* the child should not terminate at all */
! 3082: if (WIFEXITED(status)) {
! 3083: if (proc->state != PROC_STATE_KILLED) {
! 3084: log_error_write(srv, __FILE__, __LINE__, "sdb",
! 3085: "child exited:",
! 3086: WEXITSTATUS(status), proc->socket);
! 3087: }
! 3088: } else if (WIFSIGNALED(status)) {
! 3089: if (WTERMSIG(status) != SIGTERM) {
! 3090: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3091: "child signaled:",
! 3092: WTERMSIG(status));
! 3093: }
! 3094: } else {
! 3095: log_error_write(srv, __FILE__, __LINE__, "sd",
! 3096: "child died somehow:",
! 3097: status);
! 3098: }
! 3099: proc->pid = 0;
! 3100: proc->state = PROC_STATE_UNSET;
! 3101: host->max_id--;
! 3102: }
! 3103: }
! 3104: }
! 3105: }
! 3106: }
! 3107:
! 3108: return HANDLER_GO_ON;
! 3109: }
! 3110:
! 3111:
! 3112: int mod_scgi_plugin_init(plugin *p);
! 3113: int mod_scgi_plugin_init(plugin *p) {
! 3114: p->version = LIGHTTPD_VERSION_ID;
! 3115: p->name = buffer_init_string("scgi");
! 3116:
! 3117: p->init = mod_scgi_init;
! 3118: p->cleanup = mod_scgi_free;
! 3119: p->set_defaults = mod_scgi_set_defaults;
! 3120: p->connection_reset = scgi_connection_reset;
! 3121: p->handle_connection_close = scgi_connection_close_callback;
! 3122: p->handle_uri_clean = scgi_check_extension_1;
! 3123: p->handle_subrequest_start = scgi_check_extension_2;
! 3124: p->handle_subrequest = mod_scgi_handle_subrequest;
! 3125: p->handle_joblist = mod_scgi_handle_joblist;
! 3126: p->handle_trigger = mod_scgi_handle_trigger;
! 3127:
! 3128: p->data = NULL;
! 3129:
! 3130: return 0;
! 3131: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mod_scgi.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