Annotation of embedaddon/php/sapi/cgi/cgi_main.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
! 16: | Stig Bakken <ssb@php.net> |
! 17: | Zeev Suraski <zeev@zend.com> |
! 18: | FastCGI: Ben Mansell <php@slimyhorror.com> |
! 19: | Shane Caraveo <shane@caraveo.com> |
! 20: | Dmitry Stogov <dmitry@zend.com> |
! 21: +----------------------------------------------------------------------+
! 22: */
! 23:
! 24: /* $Id: cgi_main.c 321634 2012-01-01 13:15:04Z felipe $ */
! 25:
! 26: #include "php.h"
! 27: #include "php_globals.h"
! 28: #include "php_variables.h"
! 29: #include "zend_modules.h"
! 30:
! 31: #include "SAPI.h"
! 32:
! 33: #include <stdio.h>
! 34: #include "php.h"
! 35:
! 36: #ifdef PHP_WIN32
! 37: # include "win32/time.h"
! 38: # include "win32/signal.h"
! 39: # include <process.h>
! 40: #endif
! 41:
! 42: #if HAVE_SYS_TIME_H
! 43: # include <sys/time.h>
! 44: #endif
! 45:
! 46: #if HAVE_UNISTD_H
! 47: # include <unistd.h>
! 48: #endif
! 49:
! 50: #if HAVE_SIGNAL_H
! 51: # include <signal.h>
! 52: #endif
! 53:
! 54: #if HAVE_SETLOCALE
! 55: # include <locale.h>
! 56: #endif
! 57:
! 58: #if HAVE_SYS_TYPES_H
! 59: # include <sys/types.h>
! 60: #endif
! 61:
! 62: #if HAVE_SYS_WAIT_H
! 63: # include <sys/wait.h>
! 64: #endif
! 65:
! 66: #include "zend.h"
! 67: #include "zend_extensions.h"
! 68: #include "php_ini.h"
! 69: #include "php_globals.h"
! 70: #include "php_main.h"
! 71: #include "fopen_wrappers.h"
! 72: #include "ext/standard/php_standard.h"
! 73:
! 74: #ifdef PHP_WIN32
! 75: # include <io.h>
! 76: # include <fcntl.h>
! 77: # include "win32/php_registry.h"
! 78: #endif
! 79:
! 80: #ifdef __riscos__
! 81: # include <unixlib/local.h>
! 82: int __riscosify_control = __RISCOSIFY_STRICT_UNIX_SPECS;
! 83: #endif
! 84:
! 85: #include "zend_compile.h"
! 86: #include "zend_execute.h"
! 87: #include "zend_highlight.h"
! 88: #include "zend_indent.h"
! 89:
! 90: #include "php_getopt.h"
! 91:
! 92: #include "fastcgi.h"
! 93:
! 94: #ifndef PHP_WIN32
! 95: /* XXX this will need to change later when threaded fastcgi is implemented. shane */
! 96: struct sigaction act, old_term, old_quit, old_int;
! 97: #endif
! 98:
! 99: static void (*php_php_import_environment_variables)(zval *array_ptr TSRMLS_DC);
! 100:
! 101: #ifndef PHP_WIN32
! 102: /* these globals used for forking children on unix systems */
! 103: /**
! 104: * Number of child processes that will get created to service requests
! 105: */
! 106: static int children = 0;
! 107:
! 108: /**
! 109: * Set to non-zero if we are the parent process
! 110: */
! 111: static int parent = 1;
! 112:
! 113: /* Did parent received exit signals SIG_TERM/SIG_INT/SIG_QUIT */
! 114: static int exit_signal = 0;
! 115:
! 116: /* Is Parent waiting for children to exit */
! 117: static int parent_waiting = 0;
! 118:
! 119: /**
! 120: * Process group
! 121: */
! 122: static pid_t pgroup;
! 123: #endif
! 124:
! 125: #define PHP_MODE_STANDARD 1
! 126: #define PHP_MODE_HIGHLIGHT 2
! 127: #define PHP_MODE_INDENT 3
! 128: #define PHP_MODE_LINT 4
! 129: #define PHP_MODE_STRIP 5
! 130:
! 131: static char *php_optarg = NULL;
! 132: static int php_optind = 1;
! 133: static zend_module_entry cgi_module_entry;
! 134:
! 135: static const opt_struct OPTIONS[] = {
! 136: {'a', 0, "interactive"},
! 137: {'b', 1, "bindpath"},
! 138: {'C', 0, "no-chdir"},
! 139: {'c', 1, "php-ini"},
! 140: {'d', 1, "define"},
! 141: {'e', 0, "profile-info"},
! 142: {'f', 1, "file"},
! 143: {'h', 0, "help"},
! 144: {'i', 0, "info"},
! 145: {'l', 0, "syntax-check"},
! 146: {'m', 0, "modules"},
! 147: {'n', 0, "no-php-ini"},
! 148: {'q', 0, "no-header"},
! 149: {'s', 0, "syntax-highlight"},
! 150: {'s', 0, "syntax-highlighting"},
! 151: {'w', 0, "strip"},
! 152: {'?', 0, "usage"},/* help alias (both '?' and 'usage') */
! 153: {'v', 0, "version"},
! 154: {'z', 1, "zend-extension"},
! 155: {'T', 1, "timing"},
! 156: {'-', 0, NULL} /* end of args */
! 157: };
! 158:
! 159: typedef struct _php_cgi_globals_struct {
! 160: zend_bool rfc2616_headers;
! 161: zend_bool nph;
! 162: zend_bool check_shebang_line;
! 163: zend_bool fix_pathinfo;
! 164: zend_bool force_redirect;
! 165: zend_bool discard_path;
! 166: zend_bool fcgi_logging;
! 167: char *redirect_status_env;
! 168: #ifdef PHP_WIN32
! 169: zend_bool impersonate;
! 170: #endif
! 171: HashTable user_config_cache;
! 172: } php_cgi_globals_struct;
! 173:
! 174: /* {{{ user_config_cache
! 175: *
! 176: * Key for each cache entry is dirname(PATH_TRANSLATED).
! 177: *
! 178: * NOTE: Each cache entry config_hash contains the combination from all user ini files found in
! 179: * the path starting from doc_root throught to dirname(PATH_TRANSLATED). There is no point
! 180: * storing per-file entries as it would not be possible to detect added / deleted entries
! 181: * between separate files.
! 182: */
! 183: typedef struct _user_config_cache_entry {
! 184: time_t expires;
! 185: HashTable *user_config;
! 186: } user_config_cache_entry;
! 187:
! 188: static void user_config_cache_entry_dtor(user_config_cache_entry *entry)
! 189: {
! 190: zend_hash_destroy(entry->user_config);
! 191: free(entry->user_config);
! 192: }
! 193: /* }}} */
! 194:
! 195: #ifdef ZTS
! 196: static int php_cgi_globals_id;
! 197: #define CGIG(v) TSRMG(php_cgi_globals_id, php_cgi_globals_struct *, v)
! 198: #else
! 199: static php_cgi_globals_struct php_cgi_globals;
! 200: #define CGIG(v) (php_cgi_globals.v)
! 201: #endif
! 202:
! 203: #ifdef PHP_WIN32
! 204: #define TRANSLATE_SLASHES(path) \
! 205: { \
! 206: char *tmp = path; \
! 207: while (*tmp) { \
! 208: if (*tmp == '\\') *tmp = '/'; \
! 209: tmp++; \
! 210: } \
! 211: }
! 212: #else
! 213: #define TRANSLATE_SLASHES(path)
! 214: #endif
! 215:
! 216: static int print_module_info(zend_module_entry *module, void *arg TSRMLS_DC)
! 217: {
! 218: php_printf("%s\n", module->name);
! 219: return 0;
! 220: }
! 221:
! 222: static int module_name_cmp(const void *a, const void *b TSRMLS_DC)
! 223: {
! 224: Bucket *f = *((Bucket **) a);
! 225: Bucket *s = *((Bucket **) b);
! 226:
! 227: return strcasecmp( ((zend_module_entry *)f->pData)->name,
! 228: ((zend_module_entry *)s->pData)->name);
! 229: }
! 230:
! 231: static void print_modules(TSRMLS_D)
! 232: {
! 233: HashTable sorted_registry;
! 234: zend_module_entry tmp;
! 235:
! 236: zend_hash_init(&sorted_registry, 50, NULL, NULL, 1);
! 237: zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
! 238: zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);
! 239: zend_hash_apply_with_argument(&sorted_registry, (apply_func_arg_t) print_module_info, NULL TSRMLS_CC);
! 240: zend_hash_destroy(&sorted_registry);
! 241: }
! 242:
! 243: static int print_extension_info(zend_extension *ext, void *arg TSRMLS_DC)
! 244: {
! 245: php_printf("%s\n", ext->name);
! 246: return 0;
! 247: }
! 248:
! 249: static int extension_name_cmp(const zend_llist_element **f, const zend_llist_element **s TSRMLS_DC)
! 250: {
! 251: return strcmp( ((zend_extension *)(*f)->data)->name,
! 252: ((zend_extension *)(*s)->data)->name);
! 253: }
! 254:
! 255: static void print_extensions(TSRMLS_D)
! 256: {
! 257: zend_llist sorted_exts;
! 258:
! 259: zend_llist_copy(&sorted_exts, &zend_extensions);
! 260: sorted_exts.dtor = NULL;
! 261: zend_llist_sort(&sorted_exts, extension_name_cmp TSRMLS_CC);
! 262: zend_llist_apply_with_argument(&sorted_exts, (llist_apply_with_arg_func_t) print_extension_info, NULL TSRMLS_CC);
! 263: zend_llist_destroy(&sorted_exts);
! 264: }
! 265:
! 266: #ifndef STDOUT_FILENO
! 267: #define STDOUT_FILENO 1
! 268: #endif
! 269:
! 270: static inline size_t sapi_cgibin_single_write(const char *str, uint str_length TSRMLS_DC)
! 271: {
! 272: #ifdef PHP_WRITE_STDOUT
! 273: long ret;
! 274: #else
! 275: size_t ret;
! 276: #endif
! 277:
! 278: if (fcgi_is_fastcgi()) {
! 279: fcgi_request *request = (fcgi_request*) SG(server_context);
! 280: long ret = fcgi_write(request, FCGI_STDOUT, str, str_length);
! 281: if (ret <= 0) {
! 282: return 0;
! 283: }
! 284: return ret;
! 285: }
! 286:
! 287: #ifdef PHP_WRITE_STDOUT
! 288: ret = write(STDOUT_FILENO, str, str_length);
! 289: if (ret <= 0) return 0;
! 290: return ret;
! 291: #else
! 292: ret = fwrite(str, 1, MIN(str_length, 16384), stdout);
! 293: return ret;
! 294: #endif
! 295: }
! 296:
! 297: static int sapi_cgibin_ub_write(const char *str, uint str_length TSRMLS_DC)
! 298: {
! 299: const char *ptr = str;
! 300: uint remaining = str_length;
! 301: size_t ret;
! 302:
! 303: while (remaining > 0) {
! 304: ret = sapi_cgibin_single_write(ptr, remaining TSRMLS_CC);
! 305: if (!ret) {
! 306: php_handle_aborted_connection();
! 307: return str_length - remaining;
! 308: }
! 309: ptr += ret;
! 310: remaining -= ret;
! 311: }
! 312:
! 313: return str_length;
! 314: }
! 315:
! 316:
! 317: static void sapi_cgibin_flush(void *server_context)
! 318: {
! 319: if (fcgi_is_fastcgi()) {
! 320: fcgi_request *request = (fcgi_request*) server_context;
! 321: if (
! 322: #ifndef PHP_WIN32
! 323: !parent &&
! 324: #endif
! 325: request && !fcgi_flush(request, 0)) {
! 326: php_handle_aborted_connection();
! 327: }
! 328: return;
! 329: }
! 330: if (fflush(stdout) == EOF) {
! 331: php_handle_aborted_connection();
! 332: }
! 333: }
! 334:
! 335: #define SAPI_CGI_MAX_HEADER_LENGTH 1024
! 336:
! 337: typedef struct _http_error {
! 338: int code;
! 339: const char* msg;
! 340: } http_error;
! 341:
! 342: static const http_error http_error_codes[] = {
! 343: {100, "Continue"},
! 344: {101, "Switching Protocols"},
! 345: {200, "OK"},
! 346: {201, "Created"},
! 347: {202, "Accepted"},
! 348: {203, "Non-Authoritative Information"},
! 349: {204, "No Content"},
! 350: {205, "Reset Content"},
! 351: {206, "Partial Content"},
! 352: {300, "Multiple Choices"},
! 353: {301, "Moved Permanently"},
! 354: {302, "Moved Temporarily"},
! 355: {303, "See Other"},
! 356: {304, "Not Modified"},
! 357: {305, "Use Proxy"},
! 358: {400, "Bad Request"},
! 359: {401, "Unauthorized"},
! 360: {402, "Payment Required"},
! 361: {403, "Forbidden"},
! 362: {404, "Not Found"},
! 363: {405, "Method Not Allowed"},
! 364: {406, "Not Acceptable"},
! 365: {407, "Proxy Authentication Required"},
! 366: {408, "Request Time-out"},
! 367: {409, "Conflict"},
! 368: {410, "Gone"},
! 369: {411, "Length Required"},
! 370: {412, "Precondition Failed"},
! 371: {413, "Request Entity Too Large"},
! 372: {414, "Request-URI Too Large"},
! 373: {415, "Unsupported Media Type"},
! 374: {500, "Internal Server Error"},
! 375: {501, "Not Implemented"},
! 376: {502, "Bad Gateway"},
! 377: {503, "Service Unavailable"},
! 378: {504, "Gateway Time-out"},
! 379: {505, "HTTP Version not supported"},
! 380: {0, NULL}
! 381: };
! 382:
! 383: static int sapi_cgi_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
! 384: {
! 385: char buf[SAPI_CGI_MAX_HEADER_LENGTH];
! 386: sapi_header_struct *h;
! 387: zend_llist_position pos;
! 388: zend_bool ignore_status = 0;
! 389: int response_status = SG(sapi_headers).http_response_code;
! 390:
! 391: if (SG(request_info).no_headers == 1) {
! 392: return SAPI_HEADER_SENT_SUCCESSFULLY;
! 393: }
! 394:
! 395: if (CGIG(nph) || SG(sapi_headers).http_response_code != 200)
! 396: {
! 397: int len;
! 398: zend_bool has_status = 0;
! 399:
! 400: if (CGIG(rfc2616_headers) && SG(sapi_headers).http_status_line) {
! 401: char *s;
! 402: len = slprintf(buf, SAPI_CGI_MAX_HEADER_LENGTH, "%s\r\n", SG(sapi_headers).http_status_line);
! 403: if ((s = strchr(SG(sapi_headers).http_status_line, ' '))) {
! 404: response_status = atoi((s + 1));
! 405: }
! 406:
! 407: if (len > SAPI_CGI_MAX_HEADER_LENGTH) {
! 408: len = SAPI_CGI_MAX_HEADER_LENGTH;
! 409: }
! 410:
! 411: } else {
! 412: char *s;
! 413:
! 414: if (SG(sapi_headers).http_status_line &&
! 415: (s = strchr(SG(sapi_headers).http_status_line, ' ')) != 0 &&
! 416: (s - SG(sapi_headers).http_status_line) >= 5 &&
! 417: strncasecmp(SG(sapi_headers).http_status_line, "HTTP/", 5) == 0
! 418: ) {
! 419: len = slprintf(buf, sizeof(buf), "Status:%s\r\n", s);
! 420: response_status = atoi((s + 1));
! 421: } else {
! 422: h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);
! 423: while (h) {
! 424: if (h->header_len > sizeof("Status:")-1 &&
! 425: strncasecmp(h->header, "Status:", sizeof("Status:")-1) == 0
! 426: ) {
! 427: has_status = 1;
! 428: break;
! 429: }
! 430: h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);
! 431: }
! 432: if (!has_status) {
! 433: http_error *err = (http_error*)http_error_codes;
! 434:
! 435: while (err->code != 0) {
! 436: if (err->code == SG(sapi_headers).http_response_code) {
! 437: break;
! 438: }
! 439: err++;
! 440: }
! 441: if (err->msg) {
! 442: len = slprintf(buf, sizeof(buf), "Status: %d %s\r\n", SG(sapi_headers).http_response_code, err->msg);
! 443: } else {
! 444: len = slprintf(buf, sizeof(buf), "Status: %d\r\n", SG(sapi_headers).http_response_code);
! 445: }
! 446: }
! 447: }
! 448: }
! 449:
! 450: if (!has_status) {
! 451: PHPWRITE_H(buf, len);
! 452: ignore_status = 1;
! 453: }
! 454: }
! 455:
! 456: h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);
! 457: while (h) {
! 458: /* prevent CRLFCRLF */
! 459: if (h->header_len) {
! 460: if (h->header_len > sizeof("Status:")-1 &&
! 461: strncasecmp(h->header, "Status:", sizeof("Status:")-1) == 0
! 462: ) {
! 463: if (!ignore_status) {
! 464: ignore_status = 1;
! 465: PHPWRITE_H(h->header, h->header_len);
! 466: PHPWRITE_H("\r\n", 2);
! 467: }
! 468: } else if (response_status == 304 && h->header_len > sizeof("Content-Type:")-1 &&
! 469: strncasecmp(h->header, "Content-Type:", sizeof("Content-Type:")-1) == 0
! 470: ) {
! 471: h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);
! 472: continue;
! 473: } else {
! 474: PHPWRITE_H(h->header, h->header_len);
! 475: PHPWRITE_H("\r\n", 2);
! 476: }
! 477: }
! 478: h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);
! 479: }
! 480: PHPWRITE_H("\r\n", 2);
! 481:
! 482: return SAPI_HEADER_SENT_SUCCESSFULLY;
! 483: }
! 484:
! 485: #ifndef STDIN_FILENO
! 486: # define STDIN_FILENO 0
! 487: #endif
! 488:
! 489: static int sapi_cgi_read_post(char *buffer, uint count_bytes TSRMLS_DC)
! 490: {
! 491: uint read_bytes = 0;
! 492: int tmp_read_bytes;
! 493:
! 494: count_bytes = MIN(count_bytes, (uint) SG(request_info).content_length - SG(read_post_bytes));
! 495: while (read_bytes < count_bytes) {
! 496: if (fcgi_is_fastcgi()) {
! 497: fcgi_request *request = (fcgi_request*) SG(server_context);
! 498: tmp_read_bytes = fcgi_read(request, buffer + read_bytes, count_bytes - read_bytes);
! 499: } else {
! 500: tmp_read_bytes = read(STDIN_FILENO, buffer + read_bytes, count_bytes - read_bytes);
! 501: }
! 502: if (tmp_read_bytes <= 0) {
! 503: break;
! 504: }
! 505: read_bytes += tmp_read_bytes;
! 506: }
! 507: return read_bytes;
! 508: }
! 509:
! 510: static char *sapi_cgibin_getenv(char *name, size_t name_len TSRMLS_DC)
! 511: {
! 512: /* when php is started by mod_fastcgi, no regular environment
! 513: * is provided to PHP. It is always sent to PHP at the start
! 514: * of a request. So we have to do our own lookup to get env
! 515: * vars. This could probably be faster somehow. */
! 516: if (fcgi_is_fastcgi()) {
! 517: fcgi_request *request = (fcgi_request*) SG(server_context);
! 518: return fcgi_getenv(request, name, name_len);
! 519: }
! 520: /* if cgi, or fastcgi and not found in fcgi env
! 521: check the regular environment */
! 522: return getenv(name);
! 523: }
! 524:
! 525: static char *_sapi_cgibin_putenv(char *name, char *value TSRMLS_DC)
! 526: {
! 527: int name_len;
! 528: #if !HAVE_SETENV || !HAVE_UNSETENV
! 529: int len;
! 530: char *buf;
! 531: #endif
! 532:
! 533: if (!name) {
! 534: return NULL;
! 535: }
! 536: name_len = strlen(name);
! 537:
! 538: /* when php is started by mod_fastcgi, no regular environment
! 539: * is provided to PHP. It is always sent to PHP at the start
! 540: * of a request. So we have to do our own lookup to get env
! 541: * vars. This could probably be faster somehow. */
! 542: if (fcgi_is_fastcgi()) {
! 543: fcgi_request *request = (fcgi_request*) SG(server_context);
! 544: return fcgi_putenv(request, name, name_len, value);
! 545: }
! 546:
! 547: #if HAVE_SETENV
! 548: if (value) {
! 549: setenv(name, value, 1);
! 550: }
! 551: #endif
! 552: #if HAVE_UNSETENV
! 553: if (!value) {
! 554: unsetenv(name);
! 555: }
! 556: #endif
! 557:
! 558: #if !HAVE_SETENV || !HAVE_UNSETENV
! 559: /* if cgi, or fastcgi and not found in fcgi env
! 560: check the regular environment
! 561: this leaks, but it's only cgi anyway, we'll fix
! 562: it for 5.0
! 563: */
! 564: len = name_len + (value ? strlen(value) : 0) + sizeof("=") + 2;
! 565: buf = (char *) malloc(len);
! 566: if (buf == NULL) {
! 567: return getenv(name);
! 568: }
! 569: #endif
! 570: #if !HAVE_SETENV
! 571: if (value) {
! 572: len = slprintf(buf, len - 1, "%s=%s", name, value);
! 573: putenv(buf);
! 574: }
! 575: #endif
! 576: #if !HAVE_UNSETENV
! 577: if (!value) {
! 578: len = slprintf(buf, len - 1, "%s=", name);
! 579: putenv(buf);
! 580: }
! 581: #endif
! 582: return getenv(name);
! 583: }
! 584:
! 585: static char *sapi_cgi_read_cookies(TSRMLS_D)
! 586: {
! 587: return sapi_cgibin_getenv((char *) "HTTP_COOKIE", sizeof("HTTP_COOKIE")-1 TSRMLS_CC);
! 588: }
! 589:
! 590: void cgi_php_import_environment_variables(zval *array_ptr TSRMLS_DC)
! 591: {
! 592: if (PG(http_globals)[TRACK_VARS_ENV] &&
! 593: array_ptr != PG(http_globals)[TRACK_VARS_ENV] &&
! 594: Z_TYPE_P(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&
! 595: zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_ENV])) > 0
! 596: ) {
! 597: zval_dtor(array_ptr);
! 598: *array_ptr = *PG(http_globals)[TRACK_VARS_ENV];
! 599: INIT_PZVAL(array_ptr);
! 600: zval_copy_ctor(array_ptr);
! 601: return;
! 602: } else if (PG(http_globals)[TRACK_VARS_SERVER] &&
! 603: array_ptr != PG(http_globals)[TRACK_VARS_SERVER] &&
! 604: Z_TYPE_P(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY &&
! 605: zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER])) > 0
! 606: ) {
! 607: zval_dtor(array_ptr);
! 608: *array_ptr = *PG(http_globals)[TRACK_VARS_SERVER];
! 609: INIT_PZVAL(array_ptr);
! 610: zval_copy_ctor(array_ptr);
! 611: return;
! 612: }
! 613:
! 614: /* call php's original import as a catch-all */
! 615: php_php_import_environment_variables(array_ptr TSRMLS_CC);
! 616:
! 617: if (fcgi_is_fastcgi()) {
! 618: fcgi_request *request = (fcgi_request*) SG(server_context);
! 619: HashPosition pos;
! 620: int magic_quotes_gpc = PG(magic_quotes_gpc);
! 621: char *var, **val;
! 622: uint var_len;
! 623: ulong idx;
! 624: int filter_arg = (array_ptr == PG(http_globals)[TRACK_VARS_ENV])?PARSE_ENV:PARSE_SERVER;
! 625:
! 626: /* turn off magic_quotes while importing environment variables */
! 627: PG(magic_quotes_gpc) = 0;
! 628: for (zend_hash_internal_pointer_reset_ex(request->env, &pos);
! 629: zend_hash_get_current_key_ex(request->env, &var, &var_len, &idx, 0, &pos) == HASH_KEY_IS_STRING &&
! 630: zend_hash_get_current_data_ex(request->env, (void **) &val, &pos) == SUCCESS;
! 631: zend_hash_move_forward_ex(request->env, &pos)
! 632: ) {
! 633: unsigned int new_val_len;
! 634:
! 635: if (sapi_module.input_filter(filter_arg, var, val, strlen(*val), &new_val_len TSRMLS_CC)) {
! 636: php_register_variable_safe(var, *val, new_val_len, array_ptr TSRMLS_CC);
! 637: }
! 638: }
! 639: PG(magic_quotes_gpc) = magic_quotes_gpc;
! 640: }
! 641: }
! 642:
! 643: static void sapi_cgi_register_variables(zval *track_vars_array TSRMLS_DC)
! 644: {
! 645: unsigned int php_self_len;
! 646: char *php_self;
! 647:
! 648: /* In CGI mode, we consider the environment to be a part of the server
! 649: * variables
! 650: */
! 651: php_import_environment_variables(track_vars_array TSRMLS_CC);
! 652:
! 653: if (CGIG(fix_pathinfo)) {
! 654: char *script_name = SG(request_info).request_uri;
! 655: unsigned int script_name_len = script_name ? strlen(script_name) : 0;
! 656: char *path_info = sapi_cgibin_getenv("PATH_INFO", sizeof("PATH_INFO")-1 TSRMLS_CC);
! 657: unsigned int path_info_len = path_info ? strlen(path_info) : 0;
! 658:
! 659: php_self_len = script_name_len + path_info_len;
! 660: php_self = emalloc(php_self_len + 1);
! 661:
! 662: if (script_name) {
! 663: memcpy(php_self, script_name, script_name_len + 1);
! 664: }
! 665: if (path_info) {
! 666: memcpy(php_self + script_name_len, path_info, path_info_len + 1);
! 667: }
! 668:
! 669: /* Build the special-case PHP_SELF variable for the CGI version */
! 670: if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, php_self_len, &php_self_len TSRMLS_CC)) {
! 671: php_register_variable_safe("PHP_SELF", php_self, php_self_len, track_vars_array TSRMLS_CC);
! 672: }
! 673: efree(php_self);
! 674: } else {
! 675: php_self = SG(request_info).request_uri ? SG(request_info).request_uri : "";
! 676: php_self_len = strlen(php_self);
! 677: if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, php_self_len, &php_self_len TSRMLS_CC)) {
! 678: php_register_variable_safe("PHP_SELF", php_self, php_self_len, track_vars_array TSRMLS_CC);
! 679: }
! 680: }
! 681: }
! 682:
! 683: static void sapi_cgi_log_message(char *message)
! 684: {
! 685: TSRMLS_FETCH();
! 686:
! 687: if (fcgi_is_fastcgi() && CGIG(fcgi_logging)) {
! 688: fcgi_request *request;
! 689:
! 690: request = (fcgi_request*) SG(server_context);
! 691: if (request) {
! 692: int len = strlen(message);
! 693: char *buf = malloc(len+2);
! 694:
! 695: memcpy(buf, message, len);
! 696: memcpy(buf + len, "\n", sizeof("\n"));
! 697: fcgi_write(request, FCGI_STDERR, buf, len+1);
! 698: free(buf);
! 699: } else {
! 700: fprintf(stderr, "%s\n", message);
! 701: }
! 702: /* ignore return code */
! 703: } else {
! 704: fprintf(stderr, "%s\n", message);
! 705: }
! 706: }
! 707:
! 708: /* {{{ php_cgi_ini_activate_user_config
! 709: */
! 710: static void php_cgi_ini_activate_user_config(char *path, int path_len, const char *doc_root, int doc_root_len, int start TSRMLS_DC)
! 711: {
! 712: char *ptr;
! 713: user_config_cache_entry *new_entry, *entry;
! 714: time_t request_time = sapi_get_request_time(TSRMLS_C);
! 715:
! 716: /* Find cached config entry: If not found, create one */
! 717: if (zend_hash_find(&CGIG(user_config_cache), path, path_len + 1, (void **) &entry) == FAILURE) {
! 718: new_entry = pemalloc(sizeof(user_config_cache_entry), 1);
! 719: new_entry->expires = 0;
! 720: new_entry->user_config = (HashTable *) pemalloc(sizeof(HashTable), 1);
! 721: zend_hash_init(new_entry->user_config, 0, NULL, (dtor_func_t) config_zval_dtor, 1);
! 722: zend_hash_update(&CGIG(user_config_cache), path, path_len + 1, new_entry, sizeof(user_config_cache_entry), (void **) &entry);
! 723: free(new_entry);
! 724: }
! 725:
! 726: /* Check whether cache entry has expired and rescan if it is */
! 727: if (request_time > entry->expires) {
! 728: char *real_path = NULL;
! 729: int real_path_len;
! 730: char *s1, *s2;
! 731: int s_len;
! 732:
! 733: /* Clear the expired config */
! 734: zend_hash_clean(entry->user_config);
! 735:
! 736: if (!IS_ABSOLUTE_PATH(path, path_len)) {
! 737: real_path = tsrm_realpath(path, NULL TSRMLS_CC);
! 738: /* see #51688, looks like we may get invalid path as doc root using cgi with apache */
! 739: if (real_path == NULL) {
! 740: return;
! 741: }
! 742: real_path_len = strlen(real_path);
! 743: path = real_path;
! 744: path_len = real_path_len;
! 745: }
! 746:
! 747: if (path_len > doc_root_len) {
! 748: s1 = (char *) doc_root;
! 749: s2 = path;
! 750: s_len = doc_root_len;
! 751: } else {
! 752: s1 = path;
! 753: s2 = (char *) doc_root;
! 754: s_len = path_len;
! 755: }
! 756:
! 757: /* we have to test if path is part of DOCUMENT_ROOT.
! 758: if it is inside the docroot, we scan the tree up to the docroot
! 759: to find more user.ini, if not we only scan the current path.
! 760: */
! 761: #ifdef PHP_WIN32
! 762: if (strnicmp(s1, s2, s_len) == 0) {
! 763: #else
! 764: if (strncmp(s1, s2, s_len) == 0) {
! 765: #endif
! 766: ptr = s2 + start; /* start is the point where doc_root ends! */
! 767: while ((ptr = strchr(ptr, DEFAULT_SLASH)) != NULL) {
! 768: *ptr = 0;
! 769: php_parse_user_ini_file(path, PG(user_ini_filename), entry->user_config TSRMLS_CC);
! 770: *ptr = '/';
! 771: ptr++;
! 772: }
! 773: } else {
! 774: php_parse_user_ini_file(path, PG(user_ini_filename), entry->user_config TSRMLS_CC);
! 775: }
! 776:
! 777: if (real_path) {
! 778: free(real_path);
! 779: }
! 780: entry->expires = request_time + PG(user_ini_cache_ttl);
! 781: }
! 782:
! 783: /* Activate ini entries with values from the user config hash */
! 784: php_ini_activate_config(entry->user_config, PHP_INI_PERDIR, PHP_INI_STAGE_HTACCESS TSRMLS_CC);
! 785: }
! 786: /* }}} */
! 787:
! 788: static int sapi_cgi_activate(TSRMLS_D)
! 789: {
! 790: char *path, *doc_root, *server_name;
! 791: uint path_len, doc_root_len, server_name_len;
! 792:
! 793: /* PATH_TRANSLATED should be defined at this stage but better safe than sorry :) */
! 794: if (!SG(request_info).path_translated) {
! 795: return FAILURE;
! 796: }
! 797:
! 798: if (php_ini_has_per_host_config()) {
! 799: /* Activate per-host-system-configuration defined in php.ini and stored into configuration_hash during startup */
! 800: server_name = sapi_cgibin_getenv("SERVER_NAME", sizeof("SERVER_NAME") - 1 TSRMLS_CC);
! 801: /* SERVER_NAME should also be defined at this stage..but better check it anyway */
! 802: if (server_name) {
! 803: server_name_len = strlen(server_name);
! 804: server_name = estrndup(server_name, server_name_len);
! 805: zend_str_tolower(server_name, server_name_len);
! 806: php_ini_activate_per_host_config(server_name, server_name_len + 1 TSRMLS_CC);
! 807: efree(server_name);
! 808: }
! 809: }
! 810:
! 811: if (php_ini_has_per_dir_config() ||
! 812: (PG(user_ini_filename) && *PG(user_ini_filename))
! 813: ) {
! 814: /* Prepare search path */
! 815: path_len = strlen(SG(request_info).path_translated);
! 816:
! 817: /* Make sure we have trailing slash! */
! 818: if (!IS_SLASH(SG(request_info).path_translated[path_len])) {
! 819: path = emalloc(path_len + 2);
! 820: memcpy(path, SG(request_info).path_translated, path_len + 1);
! 821: path_len = zend_dirname(path, path_len);
! 822: path[path_len++] = DEFAULT_SLASH;
! 823: } else {
! 824: path = estrndup(SG(request_info).path_translated, path_len);
! 825: path_len = zend_dirname(path, path_len);
! 826: }
! 827: path[path_len] = 0;
! 828:
! 829: /* Activate per-dir-system-configuration defined in php.ini and stored into configuration_hash during startup */
! 830: php_ini_activate_per_dir_config(path, path_len TSRMLS_CC); /* Note: for global settings sake we check from root to path */
! 831:
! 832: /* Load and activate user ini files in path starting from DOCUMENT_ROOT */
! 833: if (PG(user_ini_filename) && *PG(user_ini_filename)) {
! 834: doc_root = sapi_cgibin_getenv("DOCUMENT_ROOT", sizeof("DOCUMENT_ROOT") - 1 TSRMLS_CC);
! 835: /* DOCUMENT_ROOT should also be defined at this stage..but better check it anyway */
! 836: if (doc_root) {
! 837: doc_root_len = strlen(doc_root);
! 838: if (doc_root_len > 0 && IS_SLASH(doc_root[doc_root_len - 1])) {
! 839: --doc_root_len;
! 840: }
! 841: #ifdef PHP_WIN32
! 842: /* paths on windows should be case-insensitive */
! 843: doc_root = estrndup(doc_root, doc_root_len);
! 844: zend_str_tolower(doc_root, doc_root_len);
! 845: #endif
! 846: php_cgi_ini_activate_user_config(path, path_len, doc_root, doc_root_len, doc_root_len - 1 TSRMLS_CC);
! 847: }
! 848: }
! 849:
! 850: #ifdef PHP_WIN32
! 851: efree(doc_root);
! 852: #endif
! 853: efree(path);
! 854: }
! 855:
! 856: return SUCCESS;
! 857: }
! 858:
! 859: static int sapi_cgi_deactivate(TSRMLS_D)
! 860: {
! 861: /* flush only when SAPI was started. The reasons are:
! 862: 1. SAPI Deactivate is called from two places: module init and request shutdown
! 863: 2. When the first call occurs and the request is not set up, flush fails on FastCGI.
! 864: */
! 865: if (SG(sapi_started)) {
! 866: if (fcgi_is_fastcgi()) {
! 867: if (
! 868: #ifndef PHP_WIN32
! 869: !parent &&
! 870: #endif
! 871: !fcgi_finish_request((fcgi_request*)SG(server_context), 0)) {
! 872: php_handle_aborted_connection();
! 873: }
! 874: } else {
! 875: sapi_cgibin_flush(SG(server_context));
! 876: }
! 877: }
! 878: return SUCCESS;
! 879: }
! 880:
! 881: static int php_cgi_startup(sapi_module_struct *sapi_module)
! 882: {
! 883: if (php_module_startup(sapi_module, &cgi_module_entry, 1) == FAILURE) {
! 884: return FAILURE;
! 885: }
! 886: return SUCCESS;
! 887: }
! 888:
! 889: /* {{{ sapi_module_struct cgi_sapi_module
! 890: */
! 891: static sapi_module_struct cgi_sapi_module = {
! 892: "cgi-fcgi", /* name */
! 893: "CGI/FastCGI", /* pretty name */
! 894:
! 895: php_cgi_startup, /* startup */
! 896: php_module_shutdown_wrapper, /* shutdown */
! 897:
! 898: sapi_cgi_activate, /* activate */
! 899: sapi_cgi_deactivate, /* deactivate */
! 900:
! 901: sapi_cgibin_ub_write, /* unbuffered write */
! 902: sapi_cgibin_flush, /* flush */
! 903: NULL, /* get uid */
! 904: sapi_cgibin_getenv, /* getenv */
! 905:
! 906: php_error, /* error handler */
! 907:
! 908: NULL, /* header handler */
! 909: sapi_cgi_send_headers, /* send headers handler */
! 910: NULL, /* send header handler */
! 911:
! 912: sapi_cgi_read_post, /* read POST data */
! 913: sapi_cgi_read_cookies, /* read Cookies */
! 914:
! 915: sapi_cgi_register_variables, /* register server variables */
! 916: sapi_cgi_log_message, /* Log message */
! 917: NULL, /* Get request time */
! 918: NULL, /* Child terminate */
! 919:
! 920: STANDARD_SAPI_MODULE_PROPERTIES
! 921: };
! 922: /* }}} */
! 923:
! 924: /* {{{ arginfo ext/standard/dl.c */
! 925: ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)
! 926: ZEND_ARG_INFO(0, extension_filename)
! 927: ZEND_END_ARG_INFO()
! 928: /* }}} */
! 929:
! 930: static const zend_function_entry additional_functions[] = {
! 931: ZEND_FE(dl, arginfo_dl)
! 932: {NULL, NULL, NULL}
! 933: };
! 934:
! 935: /* {{{ php_cgi_usage
! 936: */
! 937: static void php_cgi_usage(char *argv0)
! 938: {
! 939: char *prog;
! 940:
! 941: prog = strrchr(argv0, '/');
! 942: if (prog) {
! 943: prog++;
! 944: } else {
! 945: prog = "php";
! 946: }
! 947:
! 948: php_printf( "Usage: %s [-q] [-h] [-s] [-v] [-i] [-f <file>]\n"
! 949: " %s <file> [args...]\n"
! 950: " -a Run interactively\n"
! 951: " -b <address:port>|<port> Bind Path for external FASTCGI Server mode\n"
! 952: " -C Do not chdir to the script's directory\n"
! 953: " -c <path>|<file> Look for php.ini file in this directory\n"
! 954: " -n No php.ini file will be used\n"
! 955: " -d foo[=bar] Define INI entry foo with value 'bar'\n"
! 956: " -e Generate extended information for debugger/profiler\n"
! 957: " -f <file> Parse <file>. Implies `-q'\n"
! 958: " -h This help\n"
! 959: " -i PHP information\n"
! 960: " -l Syntax check only (lint)\n"
! 961: " -m Show compiled in modules\n"
! 962: " -q Quiet-mode. Suppress HTTP Header output.\n"
! 963: " -s Display colour syntax highlighted source.\n"
! 964: " -v Version number\n"
! 965: " -w Display source with stripped comments and whitespace.\n"
! 966: " -z <file> Load Zend extension <file>.\n"
! 967: " -T <count> Measure execution time of script repeated <count> times.\n",
! 968: prog, prog);
! 969: }
! 970: /* }}} */
! 971:
! 972: /* {{{ is_valid_path
! 973: *
! 974: * some server configurations allow '..' to slip through in the
! 975: * translated path. We'll just refuse to handle such a path.
! 976: */
! 977: static int is_valid_path(const char *path)
! 978: {
! 979: const char *p;
! 980:
! 981: if (!path) {
! 982: return 0;
! 983: }
! 984: p = strstr(path, "..");
! 985: if (p) {
! 986: if ((p == path || IS_SLASH(*(p-1))) &&
! 987: (*(p+2) == 0 || IS_SLASH(*(p+2)))
! 988: ) {
! 989: return 0;
! 990: }
! 991: while (1) {
! 992: p = strstr(p+1, "..");
! 993: if (!p) {
! 994: break;
! 995: }
! 996: if (IS_SLASH(*(p-1)) &&
! 997: (*(p+2) == 0 || IS_SLASH(*(p+2)))
! 998: ) {
! 999: return 0;
! 1000: }
! 1001: }
! 1002: }
! 1003: return 1;
! 1004: }
! 1005: /* }}} */
! 1006:
! 1007: /* {{{ init_request_info
! 1008:
! 1009: initializes request_info structure
! 1010:
! 1011: specificly in this section we handle proper translations
! 1012: for:
! 1013:
! 1014: PATH_INFO
! 1015: derived from the portion of the URI path following
! 1016: the script name but preceding any query data
! 1017: may be empty
! 1018:
! 1019: PATH_TRANSLATED
! 1020: derived by taking any path-info component of the
! 1021: request URI and performing any virtual-to-physical
! 1022: translation appropriate to map it onto the server's
! 1023: document repository structure
! 1024:
! 1025: empty if PATH_INFO is empty
! 1026:
! 1027: The env var PATH_TRANSLATED **IS DIFFERENT** than the
! 1028: request_info.path_translated variable, the latter should
! 1029: match SCRIPT_FILENAME instead.
! 1030:
! 1031: SCRIPT_NAME
! 1032: set to a URL path that could identify the CGI script
! 1033: rather than the interpreter. PHP_SELF is set to this
! 1034:
! 1035: REQUEST_URI
! 1036: uri section following the domain:port part of a URI
! 1037:
! 1038: SCRIPT_FILENAME
! 1039: The virtual-to-physical translation of SCRIPT_NAME (as per
! 1040: PATH_TRANSLATED)
! 1041:
! 1042: These settings are documented at
! 1043: http://cgi-spec.golux.com/
! 1044:
! 1045:
! 1046: Based on the following URL request:
! 1047:
! 1048: http://localhost/info.php/test?a=b
! 1049:
! 1050: should produce, which btw is the same as if
! 1051: we were running under mod_cgi on apache (ie. not
! 1052: using ScriptAlias directives):
! 1053:
! 1054: PATH_INFO=/test
! 1055: PATH_TRANSLATED=/docroot/test
! 1056: SCRIPT_NAME=/info.php
! 1057: REQUEST_URI=/info.php/test?a=b
! 1058: SCRIPT_FILENAME=/docroot/info.php
! 1059: QUERY_STRING=a=b
! 1060:
! 1061: but what we get is (cgi/mod_fastcgi under apache):
! 1062:
! 1063: PATH_INFO=/info.php/test
! 1064: PATH_TRANSLATED=/docroot/info.php/test
! 1065: SCRIPT_NAME=/php/php-cgi (from the Action setting I suppose)
! 1066: REQUEST_URI=/info.php/test?a=b
! 1067: SCRIPT_FILENAME=/path/to/php/bin/php-cgi (Action setting translated)
! 1068: QUERY_STRING=a=b
! 1069:
! 1070: Comments in the code below refer to using the above URL in a request
! 1071:
! 1072: */
! 1073: static void init_request_info(TSRMLS_D)
! 1074: {
! 1075: char *env_script_filename = sapi_cgibin_getenv("SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1 TSRMLS_CC);
! 1076: char *env_path_translated = sapi_cgibin_getenv("PATH_TRANSLATED", sizeof("PATH_TRANSLATED")-1 TSRMLS_CC);
! 1077: char *script_path_translated = env_script_filename;
! 1078:
! 1079: /* some broken servers do not have script_filename or argv0
! 1080: * an example, IIS configured in some ways. then they do more
! 1081: * broken stuff and set path_translated to the cgi script location */
! 1082: if (!script_path_translated && env_path_translated) {
! 1083: script_path_translated = env_path_translated;
! 1084: }
! 1085:
! 1086: /* initialize the defaults */
! 1087: SG(request_info).path_translated = NULL;
! 1088: SG(request_info).request_method = NULL;
! 1089: SG(request_info).proto_num = 1000;
! 1090: SG(request_info).query_string = NULL;
! 1091: SG(request_info).request_uri = NULL;
! 1092: SG(request_info).content_type = NULL;
! 1093: SG(request_info).content_length = 0;
! 1094: SG(sapi_headers).http_response_code = 200;
! 1095:
! 1096: /* script_path_translated being set is a good indication that
! 1097: * we are running in a cgi environment, since it is always
! 1098: * null otherwise. otherwise, the filename
! 1099: * of the script will be retreived later via argc/argv */
! 1100: if (script_path_translated) {
! 1101: const char *auth;
! 1102: char *content_length = sapi_cgibin_getenv("CONTENT_LENGTH", sizeof("CONTENT_LENGTH")-1 TSRMLS_CC);
! 1103: char *content_type = sapi_cgibin_getenv("CONTENT_TYPE", sizeof("CONTENT_TYPE")-1 TSRMLS_CC);
! 1104: char *env_path_info = sapi_cgibin_getenv("PATH_INFO", sizeof("PATH_INFO")-1 TSRMLS_CC);
! 1105: char *env_script_name = sapi_cgibin_getenv("SCRIPT_NAME", sizeof("SCRIPT_NAME")-1 TSRMLS_CC);
! 1106:
! 1107: /* Hack for buggy IIS that sets incorrect PATH_INFO */
! 1108: char *env_server_software = sapi_cgibin_getenv("SERVER_SOFTWARE", sizeof("SERVER_SOFTWARE")-1 TSRMLS_CC);
! 1109: if (env_server_software &&
! 1110: env_script_name &&
! 1111: env_path_info &&
! 1112: strncmp(env_server_software, "Microsoft-IIS", sizeof("Microsoft-IIS")-1) == 0 &&
! 1113: strncmp(env_path_info, env_script_name, strlen(env_script_name)) == 0
! 1114: ) {
! 1115: env_path_info = _sapi_cgibin_putenv("ORIG_PATH_INFO", env_path_info TSRMLS_CC);
! 1116: env_path_info += strlen(env_script_name);
! 1117: if (*env_path_info == 0) {
! 1118: env_path_info = NULL;
! 1119: }
! 1120: env_path_info = _sapi_cgibin_putenv("PATH_INFO", env_path_info TSRMLS_CC);
! 1121: }
! 1122:
! 1123: if (CGIG(fix_pathinfo)) {
! 1124: struct stat st;
! 1125: char *real_path = NULL;
! 1126: char *env_redirect_url = sapi_cgibin_getenv("REDIRECT_URL", sizeof("REDIRECT_URL")-1 TSRMLS_CC);
! 1127: char *env_document_root = sapi_cgibin_getenv("DOCUMENT_ROOT", sizeof("DOCUMENT_ROOT")-1 TSRMLS_CC);
! 1128: char *orig_path_translated = env_path_translated;
! 1129: char *orig_path_info = env_path_info;
! 1130: char *orig_script_name = env_script_name;
! 1131: char *orig_script_filename = env_script_filename;
! 1132: int script_path_translated_len;
! 1133:
! 1134: if (!env_document_root && PG(doc_root)) {
! 1135: env_document_root = _sapi_cgibin_putenv("DOCUMENT_ROOT", PG(doc_root) TSRMLS_CC);
! 1136: /* fix docroot */
! 1137: TRANSLATE_SLASHES(env_document_root);
! 1138: }
! 1139:
! 1140: if (env_path_translated != NULL && env_redirect_url != NULL &&
! 1141: env_path_translated != script_path_translated &&
! 1142: strcmp(env_path_translated, script_path_translated) != 0) {
! 1143: /*
! 1144: * pretty much apache specific. If we have a redirect_url
! 1145: * then our script_filename and script_name point to the
! 1146: * php executable
! 1147: */
! 1148: script_path_translated = env_path_translated;
! 1149: /* we correct SCRIPT_NAME now in case we don't have PATH_INFO */
! 1150: env_script_name = env_redirect_url;
! 1151: }
! 1152:
! 1153: #ifdef __riscos__
! 1154: /* Convert path to unix format*/
! 1155: __riscosify_control |= __RISCOSIFY_DONT_CHECK_DIR;
! 1156: script_path_translated = __unixify(script_path_translated, 0, NULL, 1, 0);
! 1157: #endif
! 1158:
! 1159: /*
! 1160: * if the file doesn't exist, try to extract PATH_INFO out
! 1161: * of it by stat'ing back through the '/'
! 1162: * this fixes url's like /info.php/test
! 1163: */
! 1164: if (script_path_translated &&
! 1165: (script_path_translated_len = strlen(script_path_translated)) > 0 &&
! 1166: (script_path_translated[script_path_translated_len-1] == '/' ||
! 1167: #ifdef PHP_WIN32
! 1168: script_path_translated[script_path_translated_len-1] == '\\' ||
! 1169: #endif
! 1170: (real_path = tsrm_realpath(script_path_translated, NULL TSRMLS_CC)) == NULL)
! 1171: ) {
! 1172: char *pt = estrndup(script_path_translated, script_path_translated_len);
! 1173: int len = script_path_translated_len;
! 1174: char *ptr;
! 1175:
! 1176: while ((ptr = strrchr(pt, '/')) || (ptr = strrchr(pt, '\\'))) {
! 1177: *ptr = 0;
! 1178: if (stat(pt, &st) == 0 && S_ISREG(st.st_mode)) {
! 1179: /*
! 1180: * okay, we found the base script!
! 1181: * work out how many chars we had to strip off;
! 1182: * then we can modify PATH_INFO
! 1183: * accordingly
! 1184: *
! 1185: * we now have the makings of
! 1186: * PATH_INFO=/test
! 1187: * SCRIPT_FILENAME=/docroot/info.php
! 1188: *
! 1189: * we now need to figure out what docroot is.
! 1190: * if DOCUMENT_ROOT is set, this is easy, otherwise,
! 1191: * we have to play the game of hide and seek to figure
! 1192: * out what SCRIPT_NAME should be
! 1193: */
! 1194: int slen = len - strlen(pt);
! 1195: int pilen = env_path_info ? strlen(env_path_info) : 0;
! 1196: char *path_info = env_path_info ? env_path_info + pilen - slen : NULL;
! 1197:
! 1198: if (orig_path_info != path_info) {
! 1199: if (orig_path_info) {
! 1200: char old;
! 1201:
! 1202: _sapi_cgibin_putenv("ORIG_PATH_INFO", orig_path_info TSRMLS_CC);
! 1203: old = path_info[0];
! 1204: path_info[0] = 0;
! 1205: if (!orig_script_name ||
! 1206: strcmp(orig_script_name, env_path_info) != 0) {
! 1207: if (orig_script_name) {
! 1208: _sapi_cgibin_putenv("ORIG_SCRIPT_NAME", orig_script_name TSRMLS_CC);
! 1209: }
! 1210: SG(request_info).request_uri = _sapi_cgibin_putenv("SCRIPT_NAME", env_path_info TSRMLS_CC);
! 1211: } else {
! 1212: SG(request_info).request_uri = orig_script_name;
! 1213: }
! 1214: path_info[0] = old;
! 1215: }
! 1216: env_path_info = _sapi_cgibin_putenv("PATH_INFO", path_info TSRMLS_CC);
! 1217: }
! 1218: if (!orig_script_filename ||
! 1219: strcmp(orig_script_filename, pt) != 0) {
! 1220: if (orig_script_filename) {
! 1221: _sapi_cgibin_putenv("ORIG_SCRIPT_FILENAME", orig_script_filename TSRMLS_CC);
! 1222: }
! 1223: script_path_translated = _sapi_cgibin_putenv("SCRIPT_FILENAME", pt TSRMLS_CC);
! 1224: }
! 1225: TRANSLATE_SLASHES(pt);
! 1226:
! 1227: /* figure out docroot
! 1228: * SCRIPT_FILENAME minus SCRIPT_NAME
! 1229: */
! 1230: if (env_document_root) {
! 1231: int l = strlen(env_document_root);
! 1232: int path_translated_len = 0;
! 1233: char *path_translated = NULL;
! 1234:
! 1235: if (l && env_document_root[l - 1] == '/') {
! 1236: --l;
! 1237: }
! 1238:
! 1239: /* we have docroot, so we should have:
! 1240: * DOCUMENT_ROOT=/docroot
! 1241: * SCRIPT_FILENAME=/docroot/info.php
! 1242: */
! 1243:
! 1244: /* PATH_TRANSLATED = DOCUMENT_ROOT + PATH_INFO */
! 1245: path_translated_len = l + (env_path_info ? strlen(env_path_info) : 0);
! 1246: path_translated = (char *) emalloc(path_translated_len + 1);
! 1247: memcpy(path_translated, env_document_root, l);
! 1248: if (env_path_info) {
! 1249: memcpy(path_translated + l, env_path_info, (path_translated_len - l));
! 1250: }
! 1251: path_translated[path_translated_len] = '\0';
! 1252: if (orig_path_translated) {
! 1253: _sapi_cgibin_putenv("ORIG_PATH_TRANSLATED", orig_path_translated TSRMLS_CC);
! 1254: }
! 1255: env_path_translated = _sapi_cgibin_putenv("PATH_TRANSLATED", path_translated TSRMLS_CC);
! 1256: efree(path_translated);
! 1257: } else if ( env_script_name &&
! 1258: strstr(pt, env_script_name)
! 1259: ) {
! 1260: /* PATH_TRANSLATED = PATH_TRANSLATED - SCRIPT_NAME + PATH_INFO */
! 1261: int ptlen = strlen(pt) - strlen(env_script_name);
! 1262: int path_translated_len = ptlen + (env_path_info ? strlen(env_path_info) : 0);
! 1263: char *path_translated = NULL;
! 1264:
! 1265: path_translated = (char *) emalloc(path_translated_len + 1);
! 1266: memcpy(path_translated, pt, ptlen);
! 1267: if (env_path_info) {
! 1268: memcpy(path_translated + ptlen, env_path_info, path_translated_len - ptlen);
! 1269: }
! 1270: path_translated[path_translated_len] = '\0';
! 1271: if (orig_path_translated) {
! 1272: _sapi_cgibin_putenv("ORIG_PATH_TRANSLATED", orig_path_translated TSRMLS_CC);
! 1273: }
! 1274: env_path_translated = _sapi_cgibin_putenv("PATH_TRANSLATED", path_translated TSRMLS_CC);
! 1275: efree(path_translated);
! 1276: }
! 1277: break;
! 1278: }
! 1279: }
! 1280: if (!ptr) {
! 1281: /*
! 1282: * if we stripped out all the '/' and still didn't find
! 1283: * a valid path... we will fail, badly. of course we would
! 1284: * have failed anyway... we output 'no input file' now.
! 1285: */
! 1286: if (orig_script_filename) {
! 1287: _sapi_cgibin_putenv("ORIG_SCRIPT_FILENAME", orig_script_filename TSRMLS_CC);
! 1288: }
! 1289: script_path_translated = _sapi_cgibin_putenv("SCRIPT_FILENAME", NULL TSRMLS_CC);
! 1290: SG(sapi_headers).http_response_code = 404;
! 1291: }
! 1292: if (!SG(request_info).request_uri) {
! 1293: if (!orig_script_name ||
! 1294: strcmp(orig_script_name, env_script_name) != 0) {
! 1295: if (orig_script_name) {
! 1296: _sapi_cgibin_putenv("ORIG_SCRIPT_NAME", orig_script_name TSRMLS_CC);
! 1297: }
! 1298: SG(request_info).request_uri = _sapi_cgibin_putenv("SCRIPT_NAME", env_script_name TSRMLS_CC);
! 1299: } else {
! 1300: SG(request_info).request_uri = orig_script_name;
! 1301: }
! 1302: }
! 1303: if (pt) {
! 1304: efree(pt);
! 1305: }
! 1306: } else {
! 1307: /* make sure path_info/translated are empty */
! 1308: if (!orig_script_filename ||
! 1309: (script_path_translated != orig_script_filename &&
! 1310: strcmp(script_path_translated, orig_script_filename) != 0)) {
! 1311: if (orig_script_filename) {
! 1312: _sapi_cgibin_putenv("ORIG_SCRIPT_FILENAME", orig_script_filename TSRMLS_CC);
! 1313: }
! 1314: script_path_translated = _sapi_cgibin_putenv("SCRIPT_FILENAME", script_path_translated TSRMLS_CC);
! 1315: }
! 1316: if (env_redirect_url) {
! 1317: if (orig_path_info) {
! 1318: _sapi_cgibin_putenv("ORIG_PATH_INFO", orig_path_info TSRMLS_CC);
! 1319: _sapi_cgibin_putenv("PATH_INFO", NULL TSRMLS_CC);
! 1320: }
! 1321: if (orig_path_translated) {
! 1322: _sapi_cgibin_putenv("ORIG_PATH_TRANSLATED", orig_path_translated TSRMLS_CC);
! 1323: _sapi_cgibin_putenv("PATH_TRANSLATED", NULL TSRMLS_CC);
! 1324: }
! 1325: }
! 1326: if (env_script_name != orig_script_name) {
! 1327: if (orig_script_name) {
! 1328: _sapi_cgibin_putenv("ORIG_SCRIPT_NAME", orig_script_name TSRMLS_CC);
! 1329: }
! 1330: SG(request_info).request_uri = _sapi_cgibin_putenv("SCRIPT_NAME", env_script_name TSRMLS_CC);
! 1331: } else {
! 1332: SG(request_info).request_uri = env_script_name;
! 1333: }
! 1334: free(real_path);
! 1335: }
! 1336: } else {
! 1337: /* pre 4.3 behaviour, shouldn't be used but provides BC */
! 1338: if (env_path_info) {
! 1339: SG(request_info).request_uri = env_path_info;
! 1340: } else {
! 1341: SG(request_info).request_uri = env_script_name;
! 1342: }
! 1343: if (!CGIG(discard_path) && env_path_translated) {
! 1344: script_path_translated = env_path_translated;
! 1345: }
! 1346: }
! 1347:
! 1348: if (is_valid_path(script_path_translated)) {
! 1349: SG(request_info).path_translated = estrdup(script_path_translated);
! 1350: }
! 1351:
! 1352: SG(request_info).request_method = sapi_cgibin_getenv("REQUEST_METHOD", sizeof("REQUEST_METHOD")-1 TSRMLS_CC);
! 1353: /* FIXME - Work out proto_num here */
! 1354: SG(request_info).query_string = sapi_cgibin_getenv("QUERY_STRING", sizeof("QUERY_STRING")-1 TSRMLS_CC);
! 1355: SG(request_info).content_type = (content_type ? content_type : "" );
! 1356: SG(request_info).content_length = (content_length ? atol(content_length) : 0);
! 1357:
! 1358: /* The CGI RFC allows servers to pass on unvalidated Authorization data */
! 1359: auth = sapi_cgibin_getenv("HTTP_AUTHORIZATION", sizeof("HTTP_AUTHORIZATION")-1 TSRMLS_CC);
! 1360: php_handle_auth_data(auth TSRMLS_CC);
! 1361: }
! 1362: }
! 1363: /* }}} */
! 1364:
! 1365: #ifndef PHP_WIN32
! 1366: /**
! 1367: * Clean up child processes upon exit
! 1368: */
! 1369: void fastcgi_cleanup(int signal)
! 1370: {
! 1371: #ifdef DEBUG_FASTCGI
! 1372: fprintf(stderr, "FastCGI shutdown, pid %d\n", getpid());
! 1373: #endif
! 1374:
! 1375: sigaction(SIGTERM, &old_term, 0);
! 1376:
! 1377: /* Kill all the processes in our process group */
! 1378: kill(-pgroup, SIGTERM);
! 1379:
! 1380: if (parent && parent_waiting) {
! 1381: exit_signal = 1;
! 1382: } else {
! 1383: exit(0);
! 1384: }
! 1385: }
! 1386: #endif
! 1387:
! 1388: PHP_INI_BEGIN()
! 1389: STD_PHP_INI_ENTRY("cgi.rfc2616_headers", "0", PHP_INI_ALL, OnUpdateBool, rfc2616_headers, php_cgi_globals_struct, php_cgi_globals)
! 1390: STD_PHP_INI_ENTRY("cgi.nph", "0", PHP_INI_ALL, OnUpdateBool, nph, php_cgi_globals_struct, php_cgi_globals)
! 1391: STD_PHP_INI_ENTRY("cgi.check_shebang_line", "1", PHP_INI_SYSTEM, OnUpdateBool, check_shebang_line, php_cgi_globals_struct, php_cgi_globals)
! 1392: STD_PHP_INI_ENTRY("cgi.force_redirect", "1", PHP_INI_SYSTEM, OnUpdateBool, force_redirect, php_cgi_globals_struct, php_cgi_globals)
! 1393: STD_PHP_INI_ENTRY("cgi.redirect_status_env", NULL, PHP_INI_SYSTEM, OnUpdateString, redirect_status_env, php_cgi_globals_struct, php_cgi_globals)
! 1394: STD_PHP_INI_ENTRY("cgi.fix_pathinfo", "1", PHP_INI_SYSTEM, OnUpdateBool, fix_pathinfo, php_cgi_globals_struct, php_cgi_globals)
! 1395: STD_PHP_INI_ENTRY("cgi.discard_path", "0", PHP_INI_SYSTEM, OnUpdateBool, discard_path, php_cgi_globals_struct, php_cgi_globals)
! 1396: STD_PHP_INI_ENTRY("fastcgi.logging", "1", PHP_INI_SYSTEM, OnUpdateBool, fcgi_logging, php_cgi_globals_struct, php_cgi_globals)
! 1397: #ifdef PHP_WIN32
! 1398: STD_PHP_INI_ENTRY("fastcgi.impersonate", "0", PHP_INI_SYSTEM, OnUpdateBool, impersonate, php_cgi_globals_struct, php_cgi_globals)
! 1399: #endif
! 1400: PHP_INI_END()
! 1401:
! 1402: /* {{{ php_cgi_globals_ctor
! 1403: */
! 1404: static void php_cgi_globals_ctor(php_cgi_globals_struct *php_cgi_globals TSRMLS_DC)
! 1405: {
! 1406: php_cgi_globals->rfc2616_headers = 0;
! 1407: php_cgi_globals->nph = 0;
! 1408: php_cgi_globals->check_shebang_line = 1;
! 1409: php_cgi_globals->force_redirect = 1;
! 1410: php_cgi_globals->redirect_status_env = NULL;
! 1411: php_cgi_globals->fix_pathinfo = 1;
! 1412: php_cgi_globals->discard_path = 0;
! 1413: php_cgi_globals->fcgi_logging = 1;
! 1414: #ifdef PHP_WIN32
! 1415: php_cgi_globals->impersonate = 0;
! 1416: #endif
! 1417: zend_hash_init(&php_cgi_globals->user_config_cache, 0, NULL, (dtor_func_t) user_config_cache_entry_dtor, 1);
! 1418: }
! 1419: /* }}} */
! 1420:
! 1421: /* {{{ PHP_MINIT_FUNCTION
! 1422: */
! 1423: static PHP_MINIT_FUNCTION(cgi)
! 1424: {
! 1425: #ifdef ZTS
! 1426: ts_allocate_id(&php_cgi_globals_id, sizeof(php_cgi_globals_struct), (ts_allocate_ctor) php_cgi_globals_ctor, NULL);
! 1427: #else
! 1428: php_cgi_globals_ctor(&php_cgi_globals TSRMLS_CC);
! 1429: #endif
! 1430: REGISTER_INI_ENTRIES();
! 1431: return SUCCESS;
! 1432: }
! 1433: /* }}} */
! 1434:
! 1435: /* {{{ PHP_MSHUTDOWN_FUNCTION
! 1436: */
! 1437: static PHP_MSHUTDOWN_FUNCTION(cgi)
! 1438: {
! 1439: zend_hash_destroy(&CGIG(user_config_cache));
! 1440:
! 1441: UNREGISTER_INI_ENTRIES();
! 1442: return SUCCESS;
! 1443: }
! 1444: /* }}} */
! 1445:
! 1446: /* {{{ PHP_MINFO_FUNCTION
! 1447: */
! 1448: static PHP_MINFO_FUNCTION(cgi)
! 1449: {
! 1450: DISPLAY_INI_ENTRIES();
! 1451: }
! 1452: /* }}} */
! 1453:
! 1454: static zend_module_entry cgi_module_entry = {
! 1455: STANDARD_MODULE_HEADER,
! 1456: "cgi-fcgi",
! 1457: NULL,
! 1458: PHP_MINIT(cgi),
! 1459: PHP_MSHUTDOWN(cgi),
! 1460: NULL,
! 1461: NULL,
! 1462: PHP_MINFO(cgi),
! 1463: NO_VERSION_YET,
! 1464: STANDARD_MODULE_PROPERTIES
! 1465: };
! 1466:
! 1467: /* {{{ main
! 1468: */
! 1469: int main(int argc, char *argv[])
! 1470: {
! 1471: int free_query_string = 0;
! 1472: int exit_status = SUCCESS;
! 1473: int cgi = 0, c, i, len;
! 1474: zend_file_handle file_handle;
! 1475: char *s;
! 1476:
! 1477: /* temporary locals */
! 1478: int behavior = PHP_MODE_STANDARD;
! 1479: int no_headers = 0;
! 1480: int orig_optind = php_optind;
! 1481: char *orig_optarg = php_optarg;
! 1482: char *script_file = NULL;
! 1483: int ini_entries_len = 0;
! 1484: /* end of temporary locals */
! 1485:
! 1486: #ifdef ZTS
! 1487: void ***tsrm_ls;
! 1488: #endif
! 1489:
! 1490: int max_requests = 500;
! 1491: int requests = 0;
! 1492: int fastcgi = fcgi_is_fastcgi();
! 1493: char *bindpath = NULL;
! 1494: int fcgi_fd = 0;
! 1495: fcgi_request request;
! 1496: int repeats = 1;
! 1497: int benchmark = 0;
! 1498: #if HAVE_GETTIMEOFDAY
! 1499: struct timeval start, end;
! 1500: #else
! 1501: time_t start, end;
! 1502: #endif
! 1503: #ifndef PHP_WIN32
! 1504: int status = 0;
! 1505: #endif
! 1506:
! 1507: #if 0 && defined(PHP_DEBUG)
! 1508: /* IIS is always making things more difficult. This allows
! 1509: * us to stop PHP and attach a debugger before much gets started */
! 1510: {
! 1511: char szMessage [256];
! 1512: wsprintf (szMessage, "Please attach a debugger to the process 0x%X [%d] (%s) and click OK", GetCurrentProcessId(), GetCurrentProcessId(), argv[0]);
! 1513: MessageBox(NULL, szMessage, "CGI Debug Time!", MB_OK|MB_SERVICE_NOTIFICATION);
! 1514: }
! 1515: #endif
! 1516:
! 1517: #ifdef HAVE_SIGNAL_H
! 1518: #if defined(SIGPIPE) && defined(SIG_IGN)
! 1519: signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE in standalone mode so
! 1520: that sockets created via fsockopen()
! 1521: don't kill PHP if the remote site
! 1522: closes it. in apache|apxs mode apache
! 1523: does that for us! thies@thieso.net
! 1524: 20000419 */
! 1525: #endif
! 1526: #endif
! 1527:
! 1528: #ifdef ZTS
! 1529: tsrm_startup(1, 1, 0, NULL);
! 1530: tsrm_ls = ts_resource(0);
! 1531: #endif
! 1532:
! 1533: sapi_startup(&cgi_sapi_module);
! 1534: cgi_sapi_module.php_ini_path_override = NULL;
! 1535:
! 1536: #ifdef PHP_WIN32
! 1537: _fmode = _O_BINARY; /* sets default for file streams to binary */
! 1538: setmode(_fileno(stdin), O_BINARY); /* make the stdio mode be binary */
! 1539: setmode(_fileno(stdout), O_BINARY); /* make the stdio mode be binary */
! 1540: setmode(_fileno(stderr), O_BINARY); /* make the stdio mode be binary */
! 1541: #endif
! 1542:
! 1543: if (!fastcgi) {
! 1544: /* Make sure we detect we are a cgi - a bit redundancy here,
! 1545: * but the default case is that we have to check only the first one. */
! 1546: if (getenv("SERVER_SOFTWARE") ||
! 1547: getenv("SERVER_NAME") ||
! 1548: getenv("GATEWAY_INTERFACE") ||
! 1549: getenv("REQUEST_METHOD")
! 1550: ) {
! 1551: cgi = 1;
! 1552: }
! 1553: }
! 1554:
! 1555: while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
! 1556: switch (c) {
! 1557: case 'c':
! 1558: if (cgi_sapi_module.php_ini_path_override) {
! 1559: free(cgi_sapi_module.php_ini_path_override);
! 1560: }
! 1561: cgi_sapi_module.php_ini_path_override = strdup(php_optarg);
! 1562: break;
! 1563: case 'n':
! 1564: cgi_sapi_module.php_ini_ignore = 1;
! 1565: break;
! 1566: case 'd': {
! 1567: /* define ini entries on command line */
! 1568: int len = strlen(php_optarg);
! 1569: char *val;
! 1570:
! 1571: if ((val = strchr(php_optarg, '='))) {
! 1572: val++;
! 1573: if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
! 1574: cgi_sapi_module.ini_entries = realloc(cgi_sapi_module.ini_entries, ini_entries_len + len + sizeof("\"\"\n\0"));
! 1575: memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
! 1576: ini_entries_len += (val - php_optarg);
! 1577: memcpy(cgi_sapi_module.ini_entries + ini_entries_len, "\"", 1);
! 1578: ini_entries_len++;
! 1579: memcpy(cgi_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
! 1580: ini_entries_len += len - (val - php_optarg);
! 1581: memcpy(cgi_sapi_module.ini_entries + ini_entries_len, "\"\n\0", sizeof("\"\n\0"));
! 1582: ini_entries_len += sizeof("\n\0\"") - 2;
! 1583: } else {
! 1584: cgi_sapi_module.ini_entries = realloc(cgi_sapi_module.ini_entries, ini_entries_len + len + sizeof("\n\0"));
! 1585: memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
! 1586: memcpy(cgi_sapi_module.ini_entries + ini_entries_len + len, "\n\0", sizeof("\n\0"));
! 1587: ini_entries_len += len + sizeof("\n\0") - 2;
! 1588: }
! 1589: } else {
! 1590: cgi_sapi_module.ini_entries = realloc(cgi_sapi_module.ini_entries, ini_entries_len + len + sizeof("=1\n\0"));
! 1591: memcpy(cgi_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
! 1592: memcpy(cgi_sapi_module.ini_entries + ini_entries_len + len, "=1\n\0", sizeof("=1\n\0"));
! 1593: ini_entries_len += len + sizeof("=1\n\0") - 2;
! 1594: }
! 1595: break;
! 1596: }
! 1597: /* if we're started on command line, check to see if
! 1598: * we are being started as an 'external' fastcgi
! 1599: * server by accepting a bindpath parameter. */
! 1600: case 'b':
! 1601: if (!fastcgi) {
! 1602: bindpath = strdup(php_optarg);
! 1603: }
! 1604: break;
! 1605: case 's': /* generate highlighted HTML from source */
! 1606: behavior = PHP_MODE_HIGHLIGHT;
! 1607: break;
! 1608: }
! 1609: }
! 1610: php_optind = orig_optind;
! 1611: php_optarg = orig_optarg;
! 1612:
! 1613: #ifdef ZTS
! 1614: SG(request_info).path_translated = NULL;
! 1615: #endif
! 1616:
! 1617: cgi_sapi_module.executable_location = argv[0];
! 1618: if (!cgi && !fastcgi && !bindpath) {
! 1619: cgi_sapi_module.additional_functions = additional_functions;
! 1620: }
! 1621:
! 1622: /* startup after we get the above ini override se we get things right */
! 1623: if (cgi_sapi_module.startup(&cgi_sapi_module) == FAILURE) {
! 1624: #ifdef ZTS
! 1625: tsrm_shutdown();
! 1626: #endif
! 1627: return FAILURE;
! 1628: }
! 1629:
! 1630: /* check force_cgi after startup, so we have proper output */
! 1631: if (cgi && CGIG(force_redirect)) {
! 1632: /* Apache will generate REDIRECT_STATUS,
! 1633: * Netscape and redirect.so will generate HTTP_REDIRECT_STATUS.
! 1634: * redirect.so and installation instructions available from
! 1635: * http://www.koehntopp.de/php.
! 1636: * -- kk@netuse.de
! 1637: */
! 1638: if (!getenv("REDIRECT_STATUS") &&
! 1639: !getenv ("HTTP_REDIRECT_STATUS") &&
! 1640: /* this is to allow a different env var to be configured
! 1641: * in case some server does something different than above */
! 1642: (!CGIG(redirect_status_env) || !getenv(CGIG(redirect_status_env)))
! 1643: ) {
! 1644: zend_try {
! 1645: SG(sapi_headers).http_response_code = 400;
! 1646: PUTS("<b>Security Alert!</b> The PHP CGI cannot be accessed directly.\n\n\
! 1647: <p>This PHP CGI binary was compiled with force-cgi-redirect enabled. This\n\
! 1648: means that a page will only be served up if the REDIRECT_STATUS CGI variable is\n\
! 1649: set, e.g. via an Apache Action directive.</p>\n\
! 1650: <p>For more information as to <i>why</i> this behaviour exists, see the <a href=\"http://php.net/security.cgi-bin\">\
! 1651: manual page for CGI security</a>.</p>\n\
! 1652: <p>For more information about changing this behaviour or re-enabling this webserver,\n\
! 1653: consult the installation file that came with this distribution, or visit \n\
! 1654: <a href=\"http://php.net/install.windows\">the manual page</a>.</p>\n");
! 1655: } zend_catch {
! 1656: } zend_end_try();
! 1657: #if defined(ZTS) && !defined(PHP_DEBUG)
! 1658: /* XXX we're crashing here in msvc6 debug builds at
! 1659: * php_message_handler_for_zend:839 because
! 1660: * SG(request_info).path_translated is an invalid pointer.
! 1661: * It still happens even though I set it to null, so something
! 1662: * weird is going on.
! 1663: */
! 1664: tsrm_shutdown();
! 1665: #endif
! 1666: return FAILURE;
! 1667: }
! 1668: }
! 1669:
! 1670: if (bindpath) {
! 1671: fcgi_fd = fcgi_listen(bindpath, 128);
! 1672: if (fcgi_fd < 0) {
! 1673: fprintf(stderr, "Couldn't create FastCGI listen socket on port %s\n", bindpath);
! 1674: #ifdef ZTS
! 1675: tsrm_shutdown();
! 1676: #endif
! 1677: return FAILURE;
! 1678: }
! 1679: fastcgi = fcgi_is_fastcgi();
! 1680: }
! 1681: if (fastcgi) {
! 1682: /* How many times to run PHP scripts before dying */
! 1683: if (getenv("PHP_FCGI_MAX_REQUESTS")) {
! 1684: max_requests = atoi(getenv("PHP_FCGI_MAX_REQUESTS"));
! 1685: if (max_requests < 0) {
! 1686: fprintf(stderr, "PHP_FCGI_MAX_REQUESTS is not valid\n");
! 1687: return FAILURE;
! 1688: }
! 1689: }
! 1690:
! 1691: /* make php call us to get _ENV vars */
! 1692: php_php_import_environment_variables = php_import_environment_variables;
! 1693: php_import_environment_variables = cgi_php_import_environment_variables;
! 1694:
! 1695: /* library is already initialized, now init our request */
! 1696: fcgi_init_request(&request, fcgi_fd);
! 1697:
! 1698: #ifndef PHP_WIN32
! 1699: /* Pre-fork, if required */
! 1700: if (getenv("PHP_FCGI_CHILDREN")) {
! 1701: char * children_str = getenv("PHP_FCGI_CHILDREN");
! 1702: children = atoi(children_str);
! 1703: if (children < 0) {
! 1704: fprintf(stderr, "PHP_FCGI_CHILDREN is not valid\n");
! 1705: return FAILURE;
! 1706: }
! 1707: fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-1, children_str, strlen(children_str));
! 1708: /* This is the number of concurrent requests, equals FCGI_MAX_CONNS */
! 1709: fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-1, children_str, strlen(children_str));
! 1710: } else {
! 1711: fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-1, "1", sizeof("1")-1);
! 1712: fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-1, "1", sizeof("1")-1);
! 1713: }
! 1714:
! 1715: if (children) {
! 1716: int running = 0;
! 1717: pid_t pid;
! 1718:
! 1719: /* Create a process group for ourself & children */
! 1720: setsid();
! 1721: pgroup = getpgrp();
! 1722: #ifdef DEBUG_FASTCGI
! 1723: fprintf(stderr, "Process group %d\n", pgroup);
! 1724: #endif
! 1725:
! 1726: /* Set up handler to kill children upon exit */
! 1727: act.sa_flags = 0;
! 1728: act.sa_handler = fastcgi_cleanup;
! 1729: if (sigaction(SIGTERM, &act, &old_term) ||
! 1730: sigaction(SIGINT, &act, &old_int) ||
! 1731: sigaction(SIGQUIT, &act, &old_quit)
! 1732: ) {
! 1733: perror("Can't set signals");
! 1734: exit(1);
! 1735: }
! 1736:
! 1737: if (fcgi_in_shutdown()) {
! 1738: goto parent_out;
! 1739: }
! 1740:
! 1741: while (parent) {
! 1742: do {
! 1743: #ifdef DEBUG_FASTCGI
! 1744: fprintf(stderr, "Forking, %d running\n", running);
! 1745: #endif
! 1746: pid = fork();
! 1747: switch (pid) {
! 1748: case 0:
! 1749: /* One of the children.
! 1750: * Make sure we don't go round the
! 1751: * fork loop any more
! 1752: */
! 1753: parent = 0;
! 1754:
! 1755: /* don't catch our signals */
! 1756: sigaction(SIGTERM, &old_term, 0);
! 1757: sigaction(SIGQUIT, &old_quit, 0);
! 1758: sigaction(SIGINT, &old_int, 0);
! 1759: break;
! 1760: case -1:
! 1761: perror("php (pre-forking)");
! 1762: exit(1);
! 1763: break;
! 1764: default:
! 1765: /* Fine */
! 1766: running++;
! 1767: break;
! 1768: }
! 1769: } while (parent && (running < children));
! 1770:
! 1771: if (parent) {
! 1772: #ifdef DEBUG_FASTCGI
! 1773: fprintf(stderr, "Wait for kids, pid %d\n", getpid());
! 1774: #endif
! 1775: parent_waiting = 1;
! 1776: while (1) {
! 1777: if (wait(&status) >= 0) {
! 1778: running--;
! 1779: break;
! 1780: } else if (exit_signal) {
! 1781: break;
! 1782: }
! 1783: }
! 1784: if (exit_signal) {
! 1785: #if 0
! 1786: while (running > 0) {
! 1787: while (wait(&status) < 0) {
! 1788: }
! 1789: running--;
! 1790: }
! 1791: #endif
! 1792: goto parent_out;
! 1793: }
! 1794: }
! 1795: }
! 1796: } else {
! 1797: parent = 0;
! 1798: }
! 1799:
! 1800: #endif /* WIN32 */
! 1801: }
! 1802:
! 1803: zend_first_try {
! 1804: while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 1, 2)) != -1) {
! 1805: switch (c) {
! 1806: case 'T':
! 1807: benchmark = 1;
! 1808: repeats = atoi(php_optarg);
! 1809: #ifdef HAVE_GETTIMEOFDAY
! 1810: gettimeofday(&start, NULL);
! 1811: #else
! 1812: time(&start);
! 1813: #endif
! 1814: break;
! 1815: case 'h':
! 1816: case '?':
! 1817: fcgi_shutdown();
! 1818: no_headers = 1;
! 1819: php_output_startup();
! 1820: php_output_activate(TSRMLS_C);
! 1821: SG(headers_sent) = 1;
! 1822: php_cgi_usage(argv[0]);
! 1823: php_end_ob_buffers(1 TSRMLS_CC);
! 1824: exit_status = 0;
! 1825: goto out;
! 1826: }
! 1827: }
! 1828: php_optind = orig_optind;
! 1829: php_optarg = orig_optarg;
! 1830:
! 1831: /* start of FAST CGI loop */
! 1832: /* Initialise FastCGI request structure */
! 1833: #ifdef PHP_WIN32
! 1834: /* attempt to set security impersonation for fastcgi
! 1835: * will only happen on NT based OS, others will ignore it. */
! 1836: if (fastcgi && CGIG(impersonate)) {
! 1837: fcgi_impersonate();
! 1838: }
! 1839: #endif
! 1840: while (!fastcgi || fcgi_accept_request(&request) >= 0) {
! 1841: SG(server_context) = (void *) &request;
! 1842: init_request_info(TSRMLS_C);
! 1843: CG(interactive) = 0;
! 1844:
! 1845: if (!cgi && !fastcgi) {
! 1846: while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
! 1847: switch (c) {
! 1848:
! 1849: case 'a': /* interactive mode */
! 1850: printf("Interactive mode enabled\n\n");
! 1851: CG(interactive) = 1;
! 1852: break;
! 1853:
! 1854: case 'C': /* don't chdir to the script directory */
! 1855: SG(options) |= SAPI_OPTION_NO_CHDIR;
! 1856: break;
! 1857:
! 1858: case 'e': /* enable extended info output */
! 1859: CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
! 1860: break;
! 1861:
! 1862: case 'f': /* parse file */
! 1863: if (script_file) {
! 1864: efree(script_file);
! 1865: }
! 1866: script_file = estrdup(php_optarg);
! 1867: no_headers = 1;
! 1868: break;
! 1869:
! 1870: case 'i': /* php info & quit */
! 1871: if (script_file) {
! 1872: efree(script_file);
! 1873: }
! 1874: if (php_request_startup(TSRMLS_C) == FAILURE) {
! 1875: SG(server_context) = NULL;
! 1876: php_module_shutdown(TSRMLS_C);
! 1877: return FAILURE;
! 1878: }
! 1879: if (no_headers) {
! 1880: SG(headers_sent) = 1;
! 1881: SG(request_info).no_headers = 1;
! 1882: }
! 1883: php_print_info(0xFFFFFFFF TSRMLS_CC);
! 1884: php_request_shutdown((void *) 0);
! 1885: fcgi_shutdown();
! 1886: exit_status = 0;
! 1887: goto out;
! 1888:
! 1889: case 'l': /* syntax check mode */
! 1890: no_headers = 1;
! 1891: behavior = PHP_MODE_LINT;
! 1892: break;
! 1893:
! 1894: case 'm': /* list compiled in modules */
! 1895: if (script_file) {
! 1896: efree(script_file);
! 1897: }
! 1898: php_output_startup();
! 1899: php_output_activate(TSRMLS_C);
! 1900: SG(headers_sent) = 1;
! 1901: php_printf("[PHP Modules]\n");
! 1902: print_modules(TSRMLS_C);
! 1903: php_printf("\n[Zend Modules]\n");
! 1904: print_extensions(TSRMLS_C);
! 1905: php_printf("\n");
! 1906: php_end_ob_buffers(1 TSRMLS_CC);
! 1907: fcgi_shutdown();
! 1908: exit_status = 0;
! 1909: goto out;
! 1910:
! 1911: #if 0 /* not yet operational, see also below ... */
! 1912: case '': /* generate indented source mode*/
! 1913: behavior=PHP_MODE_INDENT;
! 1914: break;
! 1915: #endif
! 1916:
! 1917: case 'q': /* do not generate HTTP headers */
! 1918: no_headers = 1;
! 1919: break;
! 1920:
! 1921: case 'v': /* show php version & quit */
! 1922: if (script_file) {
! 1923: efree(script_file);
! 1924: }
! 1925: no_headers = 1;
! 1926: if (php_request_startup(TSRMLS_C) == FAILURE) {
! 1927: SG(server_context) = NULL;
! 1928: php_module_shutdown(TSRMLS_C);
! 1929: return FAILURE;
! 1930: }
! 1931: if (no_headers) {
! 1932: SG(headers_sent) = 1;
! 1933: SG(request_info).no_headers = 1;
! 1934: }
! 1935: #if SUHOSIN_PATCH
! 1936: #if ZEND_DEBUG
! 1937: php_printf("PHP %s with Suhosin-Patch (%s) (built: %s %s) (DEBUG)\nCopyright (c) 1997-2012 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
! 1938: #else
! 1939: php_printf("PHP %s with Suhosin-Patch (%s) (built: %s %s)\nCopyright (c) 1997-2012 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
! 1940: #endif
! 1941: #else
! 1942: #if ZEND_DEBUG
! 1943: php_printf("PHP %s (%s) (built: %s %s) (DEBUG)\nCopyright (c) 1997-2012 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
! 1944: #else
! 1945: php_printf("PHP %s (%s) (built: %s %s)\nCopyright (c) 1997-2012 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
! 1946: #endif
! 1947: #endif
! 1948: php_request_shutdown((void *) 0);
! 1949: fcgi_shutdown();
! 1950: exit_status = 0;
! 1951: goto out;
! 1952:
! 1953: case 'w':
! 1954: behavior = PHP_MODE_STRIP;
! 1955: break;
! 1956:
! 1957: case 'z': /* load extension file */
! 1958: zend_load_extension(php_optarg);
! 1959: break;
! 1960:
! 1961: default:
! 1962: break;
! 1963: }
! 1964: }
! 1965:
! 1966: if (script_file) {
! 1967: /* override path_translated if -f on command line */
! 1968: STR_FREE(SG(request_info).path_translated);
! 1969: SG(request_info).path_translated = script_file;
! 1970: /* before registering argv to module exchange the *new* argv[0] */
! 1971: /* we can achieve this without allocating more memory */
! 1972: SG(request_info).argc = argc - (php_optind - 1);
! 1973: SG(request_info).argv = &argv[php_optind - 1];
! 1974: SG(request_info).argv[0] = script_file;
! 1975: } else if (argc > php_optind) {
! 1976: /* file is on command line, but not in -f opt */
! 1977: STR_FREE(SG(request_info).path_translated);
! 1978: SG(request_info).path_translated = estrdup(argv[php_optind]);
! 1979: /* arguments after the file are considered script args */
! 1980: SG(request_info).argc = argc - php_optind;
! 1981: SG(request_info).argv = &argv[php_optind];
! 1982: }
! 1983:
! 1984: if (no_headers) {
! 1985: SG(headers_sent) = 1;
! 1986: SG(request_info).no_headers = 1;
! 1987: }
! 1988:
! 1989: /* all remaining arguments are part of the query string
! 1990: * this section of code concatenates all remaining arguments
! 1991: * into a single string, seperating args with a &
! 1992: * this allows command lines like:
! 1993: *
! 1994: * test.php v1=test v2=hello+world!
! 1995: * test.php "v1=test&v2=hello world!"
! 1996: * test.php v1=test "v2=hello world!"
! 1997: */
! 1998: if (!SG(request_info).query_string && argc > php_optind) {
! 1999: int slen = strlen(PG(arg_separator).input);
! 2000: len = 0;
! 2001: for (i = php_optind; i < argc; i++) {
! 2002: if (i < (argc - 1)) {
! 2003: len += strlen(argv[i]) + slen;
! 2004: } else {
! 2005: len += strlen(argv[i]);
! 2006: }
! 2007: }
! 2008:
! 2009: len += 2;
! 2010: s = malloc(len);
! 2011: *s = '\0'; /* we are pretending it came from the environment */
! 2012: for (i = php_optind; i < argc; i++) {
! 2013: strlcat(s, argv[i], len);
! 2014: if (i < (argc - 1)) {
! 2015: strlcat(s, PG(arg_separator).input, len);
! 2016: }
! 2017: }
! 2018: SG(request_info).query_string = s;
! 2019: free_query_string = 1;
! 2020: }
! 2021: } /* end !cgi && !fastcgi */
! 2022:
! 2023: /*
! 2024: we never take stdin if we're (f)cgi, always
! 2025: rely on the web server giving us the info
! 2026: we need in the environment.
! 2027: */
! 2028: if (SG(request_info).path_translated || cgi || fastcgi) {
! 2029: file_handle.type = ZEND_HANDLE_FILENAME;
! 2030: file_handle.filename = SG(request_info).path_translated;
! 2031: file_handle.handle.fp = NULL;
! 2032: } else {
! 2033: file_handle.filename = "-";
! 2034: file_handle.type = ZEND_HANDLE_FP;
! 2035: file_handle.handle.fp = stdin;
! 2036: }
! 2037:
! 2038: file_handle.opened_path = NULL;
! 2039: file_handle.free_filename = 0;
! 2040:
! 2041: /* request startup only after we've done all we can to
! 2042: * get path_translated */
! 2043: if (php_request_startup(TSRMLS_C) == FAILURE) {
! 2044: if (fastcgi) {
! 2045: fcgi_finish_request(&request, 1);
! 2046: }
! 2047: SG(server_context) = NULL;
! 2048: php_module_shutdown(TSRMLS_C);
! 2049: return FAILURE;
! 2050: }
! 2051: if (no_headers) {
! 2052: SG(headers_sent) = 1;
! 2053: SG(request_info).no_headers = 1;
! 2054: }
! 2055:
! 2056: /*
! 2057: at this point path_translated will be set if:
! 2058: 1. we are running from shell and got filename was there
! 2059: 2. we are running as cgi or fastcgi
! 2060: */
! 2061: if (cgi || fastcgi || SG(request_info).path_translated) {
! 2062: if (php_fopen_primary_script(&file_handle TSRMLS_CC) == FAILURE) {
! 2063: zend_try {
! 2064: if (errno == EACCES) {
! 2065: SG(sapi_headers).http_response_code = 403;
! 2066: PUTS("Access denied.\n");
! 2067: } else {
! 2068: SG(sapi_headers).http_response_code = 404;
! 2069: PUTS("No input file specified.\n");
! 2070: }
! 2071: } zend_catch {
! 2072: } zend_end_try();
! 2073: /* we want to serve more requests if this is fastcgi
! 2074: * so cleanup and continue, request shutdown is
! 2075: * handled later */
! 2076: if (fastcgi) {
! 2077: goto fastcgi_request_done;
! 2078: }
! 2079:
! 2080: STR_FREE(SG(request_info).path_translated);
! 2081:
! 2082: if (free_query_string && SG(request_info).query_string) {
! 2083: free(SG(request_info).query_string);
! 2084: SG(request_info).query_string = NULL;
! 2085: }
! 2086:
! 2087: php_request_shutdown((void *) 0);
! 2088: SG(server_context) = NULL;
! 2089: php_module_shutdown(TSRMLS_C);
! 2090: sapi_shutdown();
! 2091: #ifdef ZTS
! 2092: tsrm_shutdown();
! 2093: #endif
! 2094: return FAILURE;
! 2095: }
! 2096: }
! 2097:
! 2098: if (CGIG(check_shebang_line) && file_handle.handle.fp && (file_handle.handle.fp != stdin)) {
! 2099: /* #!php support */
! 2100: c = fgetc(file_handle.handle.fp);
! 2101: if (c == '#') {
! 2102: while (c != '\n' && c != '\r' && c != EOF) {
! 2103: c = fgetc(file_handle.handle.fp); /* skip to end of line */
! 2104: }
! 2105: /* handle situations where line is terminated by \r\n */
! 2106: if (c == '\r') {
! 2107: if (fgetc(file_handle.handle.fp) != '\n') {
! 2108: long pos = ftell(file_handle.handle.fp);
! 2109: fseek(file_handle.handle.fp, pos - 1, SEEK_SET);
! 2110: }
! 2111: }
! 2112: CG(start_lineno) = 2;
! 2113: } else {
! 2114: rewind(file_handle.handle.fp);
! 2115: }
! 2116: }
! 2117:
! 2118: switch (behavior) {
! 2119: case PHP_MODE_STANDARD:
! 2120: php_execute_script(&file_handle TSRMLS_CC);
! 2121: break;
! 2122: case PHP_MODE_LINT:
! 2123: PG(during_request_startup) = 0;
! 2124: exit_status = php_lint_script(&file_handle TSRMLS_CC);
! 2125: if (exit_status == SUCCESS) {
! 2126: zend_printf("No syntax errors detected in %s\n", file_handle.filename);
! 2127: } else {
! 2128: zend_printf("Errors parsing %s\n", file_handle.filename);
! 2129: }
! 2130: break;
! 2131: case PHP_MODE_STRIP:
! 2132: if (open_file_for_scanning(&file_handle TSRMLS_CC) == SUCCESS) {
! 2133: zend_strip(TSRMLS_C);
! 2134: zend_file_handle_dtor(&file_handle TSRMLS_CC);
! 2135: php_end_ob_buffers(1 TSRMLS_CC);
! 2136: }
! 2137: return SUCCESS;
! 2138: break;
! 2139: case PHP_MODE_HIGHLIGHT:
! 2140: {
! 2141: zend_syntax_highlighter_ini syntax_highlighter_ini;
! 2142:
! 2143: if (open_file_for_scanning(&file_handle TSRMLS_CC) == SUCCESS) {
! 2144: php_get_highlight_struct(&syntax_highlighter_ini);
! 2145: zend_highlight(&syntax_highlighter_ini TSRMLS_CC);
! 2146: if (fastcgi) {
! 2147: goto fastcgi_request_done;
! 2148: }
! 2149: zend_file_handle_dtor(&file_handle TSRMLS_CC);
! 2150: php_end_ob_buffers(1 TSRMLS_CC);
! 2151: }
! 2152: return SUCCESS;
! 2153: }
! 2154: break;
! 2155: #if 0
! 2156: /* Zeev might want to do something with this one day */
! 2157: case PHP_MODE_INDENT:
! 2158: open_file_for_scanning(&file_handle TSRMLS_CC);
! 2159: zend_indent();
! 2160: zend_file_handle_dtor(&file_handle TSRMLS_CC);
! 2161: return SUCCESS;
! 2162: break;
! 2163: #endif
! 2164: }
! 2165:
! 2166: fastcgi_request_done:
! 2167: {
! 2168: STR_FREE(SG(request_info).path_translated);
! 2169:
! 2170: php_request_shutdown((void *) 0);
! 2171:
! 2172: if (exit_status == 0) {
! 2173: exit_status = EG(exit_status);
! 2174: }
! 2175:
! 2176: if (free_query_string && SG(request_info).query_string) {
! 2177: free(SG(request_info).query_string);
! 2178: SG(request_info).query_string = NULL;
! 2179: }
! 2180: }
! 2181:
! 2182: if (!fastcgi) {
! 2183: if (benchmark) {
! 2184: repeats--;
! 2185: if (repeats > 0) {
! 2186: script_file = NULL;
! 2187: php_optind = orig_optind;
! 2188: php_optarg = orig_optarg;
! 2189: continue;
! 2190: }
! 2191: }
! 2192: break;
! 2193: }
! 2194:
! 2195: /* only fastcgi will get here */
! 2196: requests++;
! 2197: if (max_requests && (requests == max_requests)) {
! 2198: fcgi_finish_request(&request, 1);
! 2199: if (bindpath) {
! 2200: free(bindpath);
! 2201: }
! 2202: if (max_requests != 1) {
! 2203: /* no need to return exit_status of the last request */
! 2204: exit_status = 0;
! 2205: }
! 2206: break;
! 2207: }
! 2208: /* end of fastcgi loop */
! 2209: }
! 2210: fcgi_shutdown();
! 2211:
! 2212: if (cgi_sapi_module.php_ini_path_override) {
! 2213: free(cgi_sapi_module.php_ini_path_override);
! 2214: }
! 2215: if (cgi_sapi_module.ini_entries) {
! 2216: free(cgi_sapi_module.ini_entries);
! 2217: }
! 2218: } zend_catch {
! 2219: exit_status = 255;
! 2220: } zend_end_try();
! 2221:
! 2222: out:
! 2223: if (benchmark) {
! 2224: int sec;
! 2225: #ifdef HAVE_GETTIMEOFDAY
! 2226: int usec;
! 2227:
! 2228: gettimeofday(&end, NULL);
! 2229: sec = (int)(end.tv_sec - start.tv_sec);
! 2230: if (end.tv_usec >= start.tv_usec) {
! 2231: usec = (int)(end.tv_usec - start.tv_usec);
! 2232: } else {
! 2233: sec -= 1;
! 2234: usec = (int)(end.tv_usec + 1000000 - start.tv_usec);
! 2235: }
! 2236: fprintf(stderr, "\nElapsed time: %d.%06d sec\n", sec, usec);
! 2237: #else
! 2238: time(&end);
! 2239: sec = (int)(end - start);
! 2240: fprintf(stderr, "\nElapsed time: %d sec\n", sec);
! 2241: #endif
! 2242: }
! 2243:
! 2244: #ifndef PHP_WIN32
! 2245: parent_out:
! 2246: #endif
! 2247:
! 2248: SG(server_context) = NULL;
! 2249: php_module_shutdown(TSRMLS_C);
! 2250: sapi_shutdown();
! 2251:
! 2252: #ifdef ZTS
! 2253: tsrm_shutdown();
! 2254: #endif
! 2255:
! 2256: #if defined(PHP_WIN32) && ZEND_DEBUG && 0
! 2257: _CrtDumpMemoryLeaks();
! 2258: #endif
! 2259:
! 2260: return exit_status;
! 2261: }
! 2262: /* }}} */
! 2263:
! 2264: /*
! 2265: * Local variables:
! 2266: * tab-width: 4
! 2267: * c-basic-offset: 4
! 2268: * End:
! 2269: * vim600: sw=4 ts=4 fdm=marker
! 2270: * vim<600: sw=4 ts=4
! 2271: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cgi_main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / sapi / cgi