#include "php.h"

#include "php_globals.h"

#include "php_variables.h"

#include "php_ini_builder.h"

#include "zend_modules.h"

#include "SAPI.h"

#include <stdio.h>

#ifdef PHP_WIN32

# include "win32/time.h"

# include "win32/signal.h"

# include "win32/winutil.h"

# include <process.h>

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#include <signal.h>

#include <locale.h>

#ifdef HAVE_SYS_TYPES_H

# include <sys/types.h>

#ifdef HAVE_SYS_WAIT_H

# include <sys/wait.h>

#include "zend.h"

#include "zend_extensions.h"

#include "php_ini.h"

#include "php_main.h"

#include "fopen_wrappers.h"

#include "http_status_codes.h"

#include "ext/standard/php_standard.h"

#include "ext/standard/dl_arginfo.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 "php_getopt.h"

#include "fastcgi.h"

#include "cgi_main_arginfo.h"

#if defined(PHP_WIN32) && defined(HAVE_OPENSSL_EXT)

# include "openssl/applink.c"

#ifdef HAVE_VALGRIND

# include "valgrind/callgrind.h"

# ifdef HAVE_VALGRIND_CACHEGRIND_H

# include "valgrind/cachegrind.h"

#include "zend_perf_stat.h"

#ifndef PHP_WIN32

static struct sigaction act, old_term, old_quit, old_int;

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

static int children = 0;

static int parent = 1;

#ifndef PHP_WIN32

static volatile sig_atomic_t 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_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"},

{'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(zval *el)

{

user_config_cache_entry *entry = (user_config_cache_entry *)Z_PTR_P(el);

zend_hash_destroy(entry->user_config);

free(entry->user_config);

free(entry);

}

#ifdef ZTS

static int php_cgi_globals_id;

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

#if defined(PHP_WIN32)

ZEND_TSRMLS_CACHE_DEFINE()

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)

#ifdef PHP_WIN32

#define WIN32_MAX_SPAWN_CHILDREN 64

HANDLE kid_cgi_ps[WIN32_MAX_SPAWN_CHILDREN];

int kids, cleaning_up = 0;

HANDLE job = NULL;

JOBOBJECT_EXTENDED_LIMIT_INFORMATION job_info = { 0 };

CRITICAL_SECTION cleanup_lock;

#ifndef HAVE_ATTRIBUTE_WEAK

static void fcgi_log(int type, const char *format, ...) {

va_list ap;

va_start(ap, format);

vfprintf(stderr, format, ap);

va_end(ap);

}

static int module_name_cmp(Bucket *f, Bucket *s)

{

return strcasecmp( ((zend_module_entry *)Z_PTR(f->val))->name,

((zend_module_entry *)Z_PTR(s->val))->name);

}

static void print_modules(void)

{

HashTable sorted_registry;

zend_module_entry *module;

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

zend_hash_copy(&sorted_registry, &module_registry, NULL);

zend_hash_sort(&sorted_registry, module_name_cmp, 0);

ZEND_HASH_MAP_FOREACH_PTR(&sorted_registry, module) {

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

} ZEND_HASH_FOREACH_END();

zend_hash_destroy(&sorted_registry);

}

static void print_extension_info(zend_extension *ext)

{

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

}

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

{

zend_extension *fe = (zend_extension*)(*f)->data;

zend_extension *se = (zend_extension*)(*s)->data;

return strcmp(fe->name, se->name);

}

static void print_extensions(void)

{

zend_llist sorted_exts;

zend_llist_copy(&sorted_exts, &zend_extensions);

sorted_exts.dtor = NULL;

zend_llist_sort(&sorted_exts, extension_name_cmp);

zend_llist_apply(&sorted_exts, (llist_apply_func_t) print_extension_info);

zend_llist_destroy(&sorted_exts);

}

#ifndef STDOUT_FILENO

#define STDOUT_FILENO 1

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

{

#ifdef PHP_WRITE_STDOUT

int 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 size_t sapi_cgi_ub_write(const char *str, size_t str_length)

{

const char *ptr = str;

size_t remaining = str_length;

size_t ret;

while (remaining > 0) {

ret = sapi_cgi_single_write(ptr, remaining);

if (!ret) {

php_handle_aborted_connection();

return str_length - remaining;

}

ptr += ret;

remaining -= ret;

}

return str_length;

}

static size_t sapi_fcgi_ub_write(const char *str, size_t str_length)

{

const char *ptr = str;

size_t remaining = str_length;

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

while (remaining > 0) {

int to_write = remaining > INT_MAX ? INT_MAX : (int)remaining;

int ret = fcgi_write(request, FCGI_STDOUT, ptr, to_write);

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 (!parent && request) {

sapi_send_headers();

if (!fcgi_flush(request, 0)) {

php_handle_aborted_connection();

}

}

}

#define SAPI_CGI_MAX_HEADER_LENGTH 1024

static int sapi_cgi_send_headers(sapi_headers_struct *sapi_headers)

{

sapi_header_struct *h;

zend_llist_position pos;

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;

bool has_status = 0;

char buf[SAPI_CGI_MAX_HEADER_LENGTH];

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

char *s;

len = slprintf(buf, SAPI_CGI_MAX_HEADER_LENGTH, "%s", 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", 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_response_status_code_pair *err = (http_response_status_code_pair*)http_status_map;

while (err->code != 0) {

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

break;

}

err++;

}

if (err->str) {

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

} else {

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

}

}

}

}

if (!has_status) {

PHPWRITE_H(buf, len);

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

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 size_t sapi_cgi_read_post(char *buffer, size_t count_bytes)

{

size_t read_bytes = 0;

int tmp_read_bytes;

size_t remaining_bytes;

assert(SG(request_info).content_length >= SG(read_post_bytes));

remaining_bytes = (size_t)(SG(request_info).content_length - SG(read_post_bytes));

count_bytes = MIN(count_bytes, remaining_bytes);

while (read_bytes < count_bytes) {

#ifdef PHP_WIN32

size_t diff = count_bytes - read_bytes;

unsigned int to_read = (diff > INT_MAX) ? INT_MAX : (unsigned int)diff;

tmp_read_bytes = _read(STDIN_FILENO, buffer + read_bytes, to_read);

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 size_t sapi_fcgi_read_post(char *buffer, size_t count_bytes)

{

size_t read_bytes = 0;

int tmp_read_bytes;

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

size_t remaining = SG(request_info).content_length - SG(read_post_bytes);

if (remaining < count_bytes) {

count_bytes = remaining;

}

while (read_bytes < count_bytes) {

size_t diff = count_bytes - read_bytes;

int to_read = (diff > INT_MAX) ? INT_MAX : (int)diff;

tmp_read_bytes = fcgi_read(request, buffer + read_bytes, to_read);

if (tmp_read_bytes <= 0) {

break;

}

read_bytes += tmp_read_bytes;

}

return read_bytes;

}

#ifdef PHP_WIN32

static char *cgi_getenv_win32(const char *name, size_t name_len)

{

char *ret = NULL;

wchar_t *keyw, *valw;

size_t size;

int rc;

keyw = php_win32_cp_conv_any_to_w(name, name_len, PHP_WIN32_CP_IGNORE_LEN_P);

if (!keyw) {

return NULL;

}

rc = _wgetenv_s(&size, NULL, 0, keyw);

if (rc || 0 == size) {

free(keyw);

return NULL;

}

valw = emalloc((size + 1) * sizeof(wchar_t));

rc = _wgetenv_s(&size, valw, size, keyw);

if (!rc) {

ret = php_win32_cp_w_to_any(valw);

}

free(keyw);

efree(valw);

return ret;

}

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

{

#ifndef PHP_WIN32

return getenv(name);

return cgi_getenv_win32(name, name_len);

}

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

{

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

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

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

#ifndef PHP_WIN32

if (ret) return ret;

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

return getenv(name);

if (ret) {

/* The functions outside here don't know, where does it come

return strdup(ret);

}

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

return cgi_getenv_win32(name, name_len);

}

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

{

#if !defined(HAVE_SETENV) || !defined(HAVE_UNSETENV)

size_t len;

char *buf;

#ifdef HAVE_SETENV

if (value) {

setenv(name, value, 1);

}

#ifdef HAVE_UNSETENV

if (!value) {

unsetenv(name);

}

#if !defined(HAVE_SETENV) || !defined(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 !defined(HAVE_SETENV)

if (value) {

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

putenv(buf);

}

#if !defined(HAVE_UNSETENV)

if (!value) {

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

putenv(buf);

}

return getenv(name);

}

static char *sapi_cgi_read_cookies(void)

{

return getenv("HTTP_COOKIE");

}

static char *sapi_fcgi_read_cookies(void)

{

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

return FCGI_GETENV(request, "HTTP_COOKIE");

}

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

{

zval *array_ptr = (zval *) arg;

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

size_t new_val_len;

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

php_register_variable_safe(var, val, new_val_len, array_ptr);

}

}

static void cgi_php_import_environment_variables(zval *array_ptr)

{

if (PG(variables_order) && (strchr(PG(variables_order),'E') || strchr(PG(variables_order),'e'))) {

if (Z_TYPE(PG(http_globals)[TRACK_VARS_ENV]) != IS_ARRAY) {

zend_is_auto_global(ZSTR_KNOWN(ZEND_STR_AUTOGLOBAL_ENV));

}

if (Z_TYPE(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&

Z_ARR_P(array_ptr) != Z_ARR(PG(http_globals)[TRACK_VARS_ENV])) {

zend_array_destroy(Z_ARR_P(array_ptr));

Z_ARR_P(array_ptr) = zend_array_dup(Z_ARR(PG(http_globals)[TRACK_VARS_ENV]));

return;

}

}

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

php_php_import_environment_variables(array_ptr);

if (fcgi_is_fastcgi()) {

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

fcgi_loadenv(request, cgi_php_load_env_var, array_ptr);

}

}

static void sapi_cgi_register_variables(zval *track_vars_array)

{

size_t 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);

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) {

size_t path_info_len = strlen(path_info);

if (script_name) {

size_t 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)) {

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

}

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)) {

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

}

}

}

static void sapi_cgi_log_message(const char *message, int syslog_type_int)

{

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

fcgi_request *request;

request = (fcgi_request*) SG(server_context);

if (request) {

int ret, len = (int)strlen(message);

char *buf = malloc(len+2);

memcpy(buf, message, len);

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

ret = fcgi_write(request, FCGI_STDERR, buf, (int)(len + 1));

free(buf);

if (ret < 0) {

php_handle_aborted_connection();

}

} 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, size_t path_len, const char *doc_root, size_t doc_root_len)

{

user_config_cache_entry *new_entry, *entry;

time_t request_time = (time_t)sapi_get_request_time();

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

if ((entry = zend_hash_str_find_ptr(&CGIG(user_config_cache), path, path_len)) == NULL) {

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, 8, NULL, (dtor_func_t) config_zval_dtor, 1);

entry = zend_hash_str_update_ptr(&CGIG(user_config_cache), path, path_len, new_entry);

}

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

if (request_time > entry->expires) {

char *real_path = NULL;

char *s1, *s2;

size_t s_len;

/* Clear the expired config */

zend_hash_clean(entry->user_config);

if (!IS_ABSOLUTE_PATH(path, path_len)) {

size_t real_path_len;

real_path = tsrm_realpath(path, NULL);

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) {

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

char *ptr = s2 + doc_root_len;

#ifdef PHP_WIN32

while ((ptr = strpbrk(ptr, "\\/")) != NULL) {

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

*ptr = 0;

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

*ptr = '/';

ptr++;

}

} else {

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

}

if (real_path) {

efree(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);

}

static int sapi_cgi_activate(void)

{

/* 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()) {

char *server_name;

/* 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) {

size_t 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);

efree(server_name);

}

}

if (php_ini_has_per_dir_config() ||

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

) {

char *path;

size_t path_len;

/* 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); /* 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)) {

char *doc_root;

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) {

size_t 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);

#ifdef PHP_WIN32

efree(doc_root);

}

}

efree(path);

}

return SUCCESS;

}

static int sapi_cgi_deactivate(void)

{

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

if (SG(sapi_started)) {

if (fcgi_is_fastcgi()) {

if (

!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_ptr)

{

return php_module_startup(sapi_module_ptr, &cgi_module_entry);

}

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 */