#include "php.h"

#include "php_globals.h"

#include "php_variables.h"

#include "zend_modules.h"

#include "SAPI.h"

#include <stdio.h>

#include "php.h"

#ifdef PHP_WIN32

# include "win32/time.h"

# include "win32/signal.h"

# include <process.h>

#if HAVE_SYS_TIME_H

# include <sys/time.h>

#if HAVE_UNISTD_H

# include <unistd.h>

#if HAVE_SIGNAL_H

# include <signal.h>

#if HAVE_SETLOCALE

# include <locale.h>

#if HAVE_SYS_TYPES_H

# include <sys/types.h>

#if HAVE_SYS_WAIT_H

# include <sys/wait.h>

#include "zend.h"

#include "zend_extensions.h"

#include "php_ini.h"

#include "php_globals.h"

#include "php_main.h"

#include "fopen_wrappers.h"

#include "ext/standard/php_standard.h"

#include "ext/standard/url.h"

#ifdef PHP_WIN32

# include <io.h>

# include <fcntl.h>

# include "win32/php_registry.h"

#ifdef __riscos__

# include <unixlib/local.h>

int __riscosify_control = __RISCOSIFY_STRICT_UNIX_SPECS;

#include "zend_compile.h"

#include "zend_execute.h"

#include "zend_highlight.h"

#include "zend_indent.h"

#include "php_getopt.h"

#include "fastcgi.h"

#ifndef PHP_WIN32

struct sigaction act, old_term, old_quit, old_int;

static void (*php_php_import_environment_variables)(zval *array_ptr TSRMLS_DC);

#ifndef PHP_WIN32

static int children = 0;

static int parent = 1;

static int exit_signal = 0;

static int parent_waiting = 0;

static pid_t pgroup;

#define PHP_MODE_STANDARD 1

#define PHP_MODE_HIGHLIGHT 2

#define PHP_MODE_INDENT 3

#define PHP_MODE_LINT 4

#define PHP_MODE_STRIP 5

static char *php_optarg = NULL;

static int php_optind = 1;

static zend_module_entry cgi_module_entry;

static const opt_struct OPTIONS[] = {

{'a', 0, "interactive"},

{'b', 1, "bindpath"},

{'C', 0, "no-chdir"},

{'c', 1, "php-ini"},

{'d', 1, "define"},

{'e', 0, "profile-info"},

{'f', 1, "file"},

{'h', 0, "help"},

{'i', 0, "info"},

{'l', 0, "syntax-check"},

{'m', 0, "modules"},

{'n', 0, "no-php-ini"},

{'q', 0, "no-header"},

{'s', 0, "syntax-highlight"},

{'s', 0, "syntax-highlighting"},

{'w', 0, "strip"},

{'?', 0, "usage"},/* help alias (both '?' and 'usage') */

{'v', 0, "version"},

{'z', 1, "zend-extension"},

{'T', 1, "timing"},

{'-', 0, NULL} /* end of args */

};

typedef struct _php_cgi_globals_struct {

} php_cgi_globals_struct;

typedef struct _user_config_cache_entry {

time_t expires;

HashTable *user_config;

} user_config_cache_entry;

static void user_config_cache_entry_dtor(user_config_cache_entry *entry)

{

zend_hash_destroy(entry->user_config);

free(entry->user_config);

}

#ifdef ZTS

static int php_cgi_globals_id;

#define CGIG(v) TSRMG(php_cgi_globals_id, php_cgi_globals_struct *, v)

static php_cgi_globals_struct php_cgi_globals;

#define CGIG(v) (php_cgi_globals.v)

#ifdef PHP_WIN32

#define TRANSLATE_SLASHES(path) \

{ \

char *tmp = path; \

while (*tmp) { \

if (*tmp == '\\') *tmp = '/'; \

tmp++; \

} \

}

#define TRANSLATE_SLASHES(path)

static int print_module_info(zend_module_entry *module, void *arg TSRMLS_DC)

{

php_printf("%s\n", module->name);

return 0;

}

static int module_name_cmp(const void *a, const void *b TSRMLS_DC)

{

Bucket *f = *((Bucket **) a);

Bucket *s = *((Bucket **) b);

return strcasecmp( ((zend_module_entry *)f->pData)->name,

((zend_module_entry *)s->pData)->name);

}

static void print_modules(TSRMLS_D)

{

HashTable sorted_registry;

zend_module_entry tmp;

zend_hash_init(&sorted_registry, 50, NULL, NULL, 1);

zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));

zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);

zend_hash_apply_with_argument(&sorted_registry, (apply_func_arg_t) print_module_info, NULL TSRMLS_CC);

zend_hash_destroy(&sorted_registry);

}

static int print_extension_info(zend_extension *ext, void *arg TSRMLS_DC)

{

php_printf("%s\n", ext->name);

return 0;

}

static int extension_name_cmp(const zend_llist_element **f, const zend_llist_element **s TSRMLS_DC)

{

return strcmp( ((zend_extension *)(*f)->data)->name,

((zend_extension *)(*s)->data)->name);

}

static void print_extensions(TSRMLS_D)

{

zend_llist sorted_exts;

zend_llist_copy(&sorted_exts, &zend_extensions);

sorted_exts.dtor = NULL;

zend_llist_sort(&sorted_exts, extension_name_cmp TSRMLS_CC);

zend_llist_apply_with_argument(&sorted_exts, (llist_apply_with_arg_func_t) print_extension_info, NULL TSRMLS_CC);

zend_llist_destroy(&sorted_exts);

}

#ifndef STDOUT_FILENO

#define STDOUT_FILENO 1

static inline size_t sapi_cgi_single_write(const char *str, uint str_length TSRMLS_DC)

{

#ifdef PHP_WRITE_STDOUT

long ret;

ret = write(STDOUT_FILENO, str, str_length);

if (ret <= 0) return 0;

return ret;

size_t ret;

ret = fwrite(str, 1, MIN(str_length, 16384), stdout);

return ret;

}

static int sapi_cgi_ub_write(const char *str, uint str_length TSRMLS_DC)

{

const char *ptr = str;

uint remaining = str_length;

size_t ret;

while (remaining > 0) {

ret = sapi_cgi_single_write(ptr, remaining TSRMLS_CC);

if (!ret) {

php_handle_aborted_connection();

return str_length - remaining;

}

ptr += ret;

remaining -= ret;

}

return str_length;

}

static int sapi_fcgi_ub_write(const char *str, uint str_length TSRMLS_DC)

{

const char *ptr = str;

uint remaining = str_length;

fcgi_request *request = (fcgi_request*) SG(server_context);

while (remaining > 0) {

long ret = fcgi_write(request, FCGI_STDOUT, ptr, remaining);

if (ret <= 0) {

php_handle_aborted_connection();

return str_length - remaining;

}

ptr += ret;

remaining -= ret;

}

return str_length;

}

static void sapi_cgi_flush(void *server_context)

{

if (fflush(stdout) == EOF) {

php_handle_aborted_connection();

}

}

static void sapi_fcgi_flush(void *server_context)

{

fcgi_request *request = (fcgi_request*) server_context;

if (

#ifndef PHP_WIN32

!parent &&

request && !fcgi_flush(request, 0)) {

php_handle_aborted_connection();

}

}

#define SAPI_CGI_MAX_HEADER_LENGTH 1024

typedef struct _http_error {

int code;

const char* msg;

} http_error;

static const http_error http_error_codes[] = {

{100, "Continue"},

{101, "Switching Protocols"},

{200, "OK"},

{201, "Created"},

{202, "Accepted"},

{203, "Non-Authoritative Information"},

{204, "No Content"},

{205, "Reset Content"},

{206, "Partial Content"},

{300, "Multiple Choices"},

{301, "Moved Permanently"},

{302, "Moved Temporarily"},

{303, "See Other"},

{304, "Not Modified"},

{305, "Use Proxy"},

{400, "Bad Request"},

{401, "Unauthorized"},

{402, "Payment Required"},

{403, "Forbidden"},

{404, "Not Found"},

{405, "Method Not Allowed"},

{406, "Not Acceptable"},

{407, "Proxy Authentication Required"},

{408, "Request Time-out"},

{409, "Conflict"},

{410, "Gone"},

{411, "Length Required"},

{412, "Precondition Failed"},

{413, "Request Entity Too Large"},

{414, "Request-URI Too Large"},

{415, "Unsupported Media Type"},

{500, "Internal Server Error"},

{501, "Not Implemented"},

{502, "Bad Gateway"},

{503, "Service Unavailable"},

{504, "Gateway Time-out"},

{505, "HTTP Version not supported"},

{0, NULL}

};

static int sapi_cgi_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)

{

char buf[SAPI_CGI_MAX_HEADER_LENGTH];

sapi_header_struct *h;

zend_llist_position pos;

zend_bool ignore_status = 0;

int response_status = SG(sapi_headers).http_response_code;

if (SG(request_info).no_headers == 1) {

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

if (CGIG(nph) || SG(sapi_headers).http_response_code != 200)

{

int len;

zend_bool has_status = 0;

if (CGIG(rfc2616_headers) && SG(sapi_headers).http_status_line) {

char *s;

len = slprintf(buf, SAPI_CGI_MAX_HEADER_LENGTH, "%s\r\n", SG(sapi_headers).http_status_line);

if ((s = strchr(SG(sapi_headers).http_status_line, ' '))) {

response_status = atoi((s + 1));

}

if (len > SAPI_CGI_MAX_HEADER_LENGTH) {

len = SAPI_CGI_MAX_HEADER_LENGTH;

}

} else {

char *s;

if (SG(sapi_headers).http_status_line &&

(s = strchr(SG(sapi_headers).http_status_line, ' ')) != 0 &&

(s - SG(sapi_headers).http_status_line) >= 5 &&

strncasecmp(SG(sapi_headers).http_status_line, "HTTP/", 5) == 0

) {

len = slprintf(buf, sizeof(buf), "Status:%s\r\n", s);

response_status = atoi((s + 1));

} else {

h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);

while (h) {

if (h->header_len > sizeof("Status:")-1 &&

strncasecmp(h->header, "Status:", sizeof("Status:")-1) == 0

) {

has_status = 1;

break;

}

h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);

}

if (!has_status) {

http_error *err = (http_error*)http_error_codes;

while (err->code != 0) {

if (err->code == SG(sapi_headers).http_response_code) {

break;

}

err++;

}

if (err->msg) {

len = slprintf(buf, sizeof(buf), "Status: %d %s\r\n", SG(sapi_headers).http_response_code, err->msg);

} else {

len = slprintf(buf, sizeof(buf), "Status: %d\r\n", SG(sapi_headers).http_response_code);

}

}

}

}

if (!has_status) {

PHPWRITE_H(buf, len);

ignore_status = 1;

}

}

h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);

while (h) {

/* prevent CRLFCRLF */

if (h->header_len) {

if (h->header_len > sizeof("Status:")-1 &&

strncasecmp(h->header, "Status:", sizeof("Status:")-1) == 0

) {

if (!ignore_status) {

ignore_status = 1;

PHPWRITE_H(h->header, h->header_len);

PHPWRITE_H("\r\n", 2);

}

} else if (response_status == 304 && h->header_len > sizeof("Content-Type:")-1 &&

strncasecmp(h->header, "Content-Type:", sizeof("Content-Type:")-1) == 0

) {

h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);

continue;

} else {

PHPWRITE_H(h->header, h->header_len);

PHPWRITE_H("\r\n", 2);

}

}

h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);

}

PHPWRITE_H("\r\n", 2);

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

#ifndef STDIN_FILENO

# define STDIN_FILENO 0

static int sapi_cgi_read_post(char *buffer, uint count_bytes TSRMLS_DC)

{

uint read_bytes = 0;

int tmp_read_bytes;

count_bytes = MIN(count_bytes, (uint) SG(request_info).content_length - SG(read_post_bytes));

while (read_bytes < count_bytes) {

tmp_read_bytes = read(STDIN_FILENO, buffer + read_bytes, count_bytes - read_bytes);

if (tmp_read_bytes <= 0) {

break;

}

read_bytes += tmp_read_bytes;

}

return read_bytes;

}

static int sapi_fcgi_read_post(char *buffer, uint count_bytes TSRMLS_DC)

{

uint read_bytes = 0;

int tmp_read_bytes;

fcgi_request *request = (fcgi_request*) SG(server_context);

count_bytes = MIN(count_bytes, (uint) SG(request_info).content_length - SG(read_post_bytes));

while (read_bytes < count_bytes) {

tmp_read_bytes = fcgi_read(request, buffer + read_bytes, count_bytes - read_bytes);

if (tmp_read_bytes <= 0) {

break;

}

read_bytes += tmp_read_bytes;

}

return read_bytes;

}

static char *sapi_cgi_getenv(char *name, size_t name_len TSRMLS_DC)

{

return getenv(name);

}

static char *sapi_fcgi_getenv(char *name, size_t name_len TSRMLS_DC)

{

/* when php is started by mod_fastcgi, no regular environment

fcgi_request *request = (fcgi_request*) SG(server_context);

char *ret = fcgi_getenv(request, name, name_len);

if (ret) return ret;

/* if cgi, or fastcgi and not found in fcgi env

return getenv(name);

}

static char *_sapi_cgi_putenv(char *name, int name_len, char *value)

{

#if !HAVE_SETENV || !HAVE_UNSETENV

int len;

char *buf;

#if HAVE_SETENV

if (value) {

setenv(name, value, 1);

}

#if HAVE_UNSETENV

if (!value) {

unsetenv(name);

}

#if !HAVE_SETENV || !HAVE_UNSETENV

/* if cgi, or fastcgi and not found in fcgi env

len = name_len + (value ? strlen(value) : 0) + sizeof("=") + 2;

buf = (char *) malloc(len);

if (buf == NULL) {

return getenv(name);

}

#if !HAVE_SETENV

if (value) {

len = slprintf(buf, len - 1, "%s=%s", name, value);

putenv(buf);

}

#if !HAVE_UNSETENV

if (!value) {

len = slprintf(buf, len - 1, "%s=", name);

putenv(buf);

}

return getenv(name);

}

static char *sapi_cgi_read_cookies(TSRMLS_D)

{

return getenv("HTTP_COOKIE");

}

static char *sapi_fcgi_read_cookies(TSRMLS_D)

{

fcgi_request *request = (fcgi_request*) SG(server_context);

return FCGI_GETENV(request, "HTTP_COOKIE");

}

static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg TSRMLS_DC)

{

zval *array_ptr = (zval*)arg;

int filter_arg = (array_ptr == PG(http_globals)[TRACK_VARS_ENV])?PARSE_ENV:PARSE_SERVER;

unsigned int new_val_len;

if (sapi_module.input_filter(filter_arg, var, &val, strlen(val), &new_val_len TSRMLS_CC)) {

php_register_variable_safe(var, val, new_val_len, array_ptr TSRMLS_CC);

}

}

static void cgi_php_import_environment_variables(zval *array_ptr TSRMLS_DC)

{

if (PG(http_globals)[TRACK_VARS_ENV] &&

array_ptr != PG(http_globals)[TRACK_VARS_ENV] &&

Z_TYPE_P(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&

zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_ENV])) > 0

) {

zval_dtor(array_ptr);

*array_ptr = *PG(http_globals)[TRACK_VARS_ENV];

INIT_PZVAL(array_ptr);

zval_copy_ctor(array_ptr);

return;

} else if (PG(http_globals)[TRACK_VARS_SERVER] &&

array_ptr != PG(http_globals)[TRACK_VARS_SERVER] &&

Z_TYPE_P(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY &&

zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER])) > 0

) {

zval_dtor(array_ptr);

*array_ptr = *PG(http_globals)[TRACK_VARS_SERVER];

INIT_PZVAL(array_ptr);

zval_copy_ctor(array_ptr);

return;

}

/* call php's original import as a catch-all */

php_php_import_environment_variables(array_ptr TSRMLS_CC);

if (fcgi_is_fastcgi()) {

fcgi_request *request = (fcgi_request*) SG(server_context);

fcgi_loadenv(request, cgi_php_load_env_var, array_ptr TSRMLS_CC);

}

}

static void sapi_cgi_register_variables(zval *track_vars_array TSRMLS_DC)

{

unsigned int php_self_len;

char *php_self;

/* In CGI mode, we consider the environment to be a part of the server

php_import_environment_variables(track_vars_array TSRMLS_CC);

if (CGIG(fix_pathinfo)) {

char *script_name = SG(request_info).request_uri;

char *path_info;

int free_php_self;

ALLOCA_FLAG(use_heap)

if (fcgi_is_fastcgi()) {

fcgi_request *request = (fcgi_request*) SG(server_context);

path_info = FCGI_GETENV(request, "PATH_INFO");

} else {

path_info = getenv("PATH_INFO");

}

if (path_info) {

unsigned int path_info_len = strlen(path_info);

if (script_name) {

unsigned int script_name_len = strlen(script_name);

php_self_len = script_name_len + path_info_len;

php_self = do_alloca(php_self_len + 1, use_heap);

memcpy(php_self, script_name, script_name_len + 1);

memcpy(php_self + script_name_len, path_info, path_info_len + 1);

free_php_self = 1;

} else {

php_self = path_info;

php_self_len = path_info_len;

free_php_self = 0;

}

} else if (script_name) {

php_self = script_name;

php_self_len = strlen(script_name);

free_php_self = 0;

} else {

php_self = "";

php_self_len = 0;

free_php_self = 0;

}

/* Build the special-case PHP_SELF variable for the CGI version */

if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, php_self_len, &php_self_len TSRMLS_CC)) {

php_register_variable_safe("PHP_SELF", php_self, php_self_len, track_vars_array TSRMLS_CC);

}

if (free_php_self) {

free_alloca(php_self, use_heap);

}

} else {

php_self = SG(request_info).request_uri ? SG(request_info).request_uri : "";

php_self_len = strlen(php_self);

if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, php_self_len, &php_self_len TSRMLS_CC)) {

php_register_variable_safe("PHP_SELF", php_self, php_self_len, track_vars_array TSRMLS_CC);

}

}

}

static void sapi_cgi_log_message(char *message TSRMLS_DC)

{

if (fcgi_is_fastcgi() && CGIG(fcgi_logging)) {

fcgi_request *request;

request = (fcgi_request*) SG(server_context);

if (request) {

int len = strlen(message);

char *buf = malloc(len+2);

memcpy(buf, message, len);

memcpy(buf + len, "\n", sizeof("\n"));

fcgi_write(request, FCGI_STDERR, buf, len+1);

free(buf);

} else {

fprintf(stderr, "%s\n", message);

}

/* ignore return code */

} else {

fprintf(stderr, "%s\n", message);

}

}

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)

{

char *ptr;

user_config_cache_entry *new_entry, *entry;

time_t request_time = sapi_get_request_time(TSRMLS_C);

/* Find cached config entry: If not found, create one */

if (zend_hash_find(&CGIG(user_config_cache), path, path_len + 1, (void **) &entry) == FAILURE) {

new_entry = pemalloc(sizeof(user_config_cache_entry), 1);

new_entry->expires = 0;

new_entry->user_config = (HashTable *) pemalloc(sizeof(HashTable), 1);

zend_hash_init(new_entry->user_config, 0, NULL, (dtor_func_t) config_zval_dtor, 1);

zend_hash_update(&CGIG(user_config_cache), path, path_len + 1, new_entry, sizeof(user_config_cache_entry), (void **) &entry);

free(new_entry);

}

/* Check whether cache entry has expired and rescan if it is */

if (request_time > entry->expires) {

char *real_path = NULL;

int real_path_len;

char *s1, *s2;

int s_len;

/* Clear the expired config */

zend_hash_clean(entry->user_config);

if (!IS_ABSOLUTE_PATH(path, path_len)) {

real_path = tsrm_realpath(path, NULL TSRMLS_CC);

if (real_path == NULL) {

return;

}

real_path_len = strlen(real_path);

path = real_path;

path_len = real_path_len;

}

if (path_len > doc_root_len) {

s1 = (char *) doc_root;

s2 = path;

s_len = doc_root_len;

} else {

s1 = path;

s2 = (char *) doc_root;

s_len = path_len;

}

/* we have to test if path is part of DOCUMENT_ROOT.

#ifdef PHP_WIN32

if (strnicmp(s1, s2, s_len) == 0) {

#else

if (strncmp(s1, s2, s_len) == 0) {

ptr = s2 + start; /* start is the point where doc_root ends! */

while ((ptr = strchr(ptr, DEFAULT_SLASH)) != NULL) {

*ptr = 0;

php_parse_user_ini_file(path, PG(user_ini_filename), entry->user_config TSRMLS_CC);

*ptr = '/';

ptr++;

}

} else {

php_parse_user_ini_file(path, PG(user_ini_filename), entry->user_config TSRMLS_CC);

}

if (real_path) {

free(real_path);

}

entry->expires = request_time + PG(user_ini_cache_ttl);

}

/* Activate ini entries with values from the user config hash */

php_ini_activate_config(entry->user_config, PHP_INI_PERDIR, PHP_INI_STAGE_HTACCESS TSRMLS_CC);

}

static int sapi_cgi_activate(TSRMLS_D)

{

char *path, *doc_root, *server_name;

uint path_len, doc_root_len, server_name_len;

/* PATH_TRANSLATED should be defined at this stage but better safe than sorry :) */

if (!SG(request_info).path_translated) {

return FAILURE;

}

if (php_ini_has_per_host_config()) {

/* Activate per-host-system-configuration defined in php.ini and stored into configuration_hash during startup */

if (fcgi_is_fastcgi()) {

fcgi_request *request = (fcgi_request*) SG(server_context);

server_name = FCGI_GETENV(request, "SERVER_NAME");

} else {

server_name = getenv("SERVER_NAME");

}

/* SERVER_NAME should also be defined at this stage..but better check it anyway */

if (server_name) {

server_name_len = strlen(server_name);

server_name = estrndup(server_name, server_name_len);

zend_str_tolower(server_name, server_name_len);

php_ini_activate_per_host_config(server_name, server_name_len + 1 TSRMLS_CC);

efree(server_name);

}

}

if (php_ini_has_per_dir_config() ||

(PG(user_ini_filename) && *PG(user_ini_filename))

) {

/* Prepare search path */

path_len = strlen(SG(request_info).path_translated);

/* Make sure we have trailing slash! */

if (!IS_SLASH(SG(request_info).path_translated[path_len])) {

path = emalloc(path_len + 2);

memcpy(path, SG(request_info).path_translated, path_len + 1);

path_len = zend_dirname(path, path_len);

path[path_len++] = DEFAULT_SLASH;

} else {

path = estrndup(SG(request_info).path_translated, path_len);

path_len = zend_dirname(path, path_len);

}

path[path_len] = 0;

/* Activate per-dir-system-configuration defined in php.ini and stored into configuration_hash during startup */

php_ini_activate_per_dir_config(path, path_len TSRMLS_CC); /* Note: for global settings sake we check from root to path */

/* Load and activate user ini files in path starting from DOCUMENT_ROOT */

if (PG(user_ini_filename) && *PG(user_ini_filename)) {

if (fcgi_is_fastcgi()) {

fcgi_request *request = (fcgi_request*) SG(server_context);

doc_root = FCGI_GETENV(request, "DOCUMENT_ROOT");

} else {

doc_root = getenv("DOCUMENT_ROOT");

}

/* DOCUMENT_ROOT should also be defined at this stage..but better check it anyway */

if (doc_root) {

doc_root_len = strlen(doc_root);

if (doc_root_len > 0 && IS_SLASH(doc_root[doc_root_len - 1])) {

--doc_root_len;

}

#ifdef PHP_WIN32

/* paths on windows should be case-insensitive */

doc_root = estrndup(doc_root, doc_root_len);

zend_str_tolower(doc_root, doc_root_len);

php_cgi_ini_activate_user_config(path, path_len, doc_root, doc_root_len, doc_root_len - 1 TSRMLS_CC);

#ifdef PHP_WIN32

efree(doc_root);

}

}

efree(path);

}

return SUCCESS;

}

static int sapi_cgi_deactivate(TSRMLS_D)

{

/* flush only when SAPI was started. The reasons are:

if (SG(sapi_started)) {

if (fcgi_is_fastcgi()) {

if (

#ifndef PHP_WIN32

!parent &&

!fcgi_finish_request((fcgi_request*)SG(server_context), 0)) {

php_handle_aborted_connection();

}

} else {

sapi_cgi_flush(SG(server_context));

}

}

return SUCCESS;

}

static int php_cgi_startup(sapi_module_struct *sapi_module)

{

if (php_module_startup(sapi_module, &cgi_module_entry, 1) == FAILURE) {

return FAILURE;

}

return SUCCESS;

}

static sapi_module_struct cgi_sapi_module = {

"cgi-fcgi", /* name */

"CGI/FastCGI", /* pretty name */

php_cgi_startup, /* startup */

php_module_shutdown_wrapper, /* shutdown */

sapi_cgi_activate, /* activate */

sapi_cgi_deactivate, /* deactivate */

sapi_cgi_ub_write, /* unbuffered write */

sapi_cgi_flush, /* flush */

NULL, /* get uid */

sapi_cgi_getenv, /* getenv */

php_error, /* error handler */

NULL, /* header handler */

sapi_cgi_send_headers, /* send headers handler */

NULL, /* send header handler */

sapi_cgi_read_post, /* read POST data */

sapi_cgi_read_cookies, /* read Cookies */

sapi_cgi_register_variables, /* register server variables */

sapi_cgi_log_message, /* Log message */

NULL, /* Get request time */

NULL, /* Child terminate */

STANDARD_SAPI_MODULE_PROPERTIES

};

ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)

ZEND_ARG_INFO(0, extension_filename)

ZEND_END_ARG_INFO()

static const zend_function_entry additional_functions[] = {

ZEND_FE(dl, arginfo_dl)

{NULL, NULL, NULL}

};

static void php_cgi_usage(char *argv0)

{

char *prog;

prog = strrchr(argv0, '/');

if (prog) {

prog++;

} else {

prog = "php";

}

php_printf( "Usage: %s [-q] [-h] [-s] [-v] [-i] [-f <file>]\n"

" %s <file> [args...]\n"

" -a Run interactively\n"

" -b <address:port>|<port> Bind Path for external FASTCGI Server mode\n"