mirror of
https://github.com/php/php-src.git
synced 2024-12-14 04:16:30 +08:00
756 lines
21 KiB
C
756 lines
21 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| PHP version 4.0 |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 1997, 1998, 1999 The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 2.0 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available at through the world-wide-web at |
|
|
| http://www.php.net/license/2_0.txt. |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Author: David Hedbor <neotron@php.net> |
|
|
| Based on aolserver SAPI by Sascha Schumann <sascha@schumann.cx> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
/* $Id$ */
|
|
|
|
#include "php.h"
|
|
#ifdef HAVE_ROXEN
|
|
|
|
#include "php_ini.h"
|
|
#include "php_globals.h"
|
|
#include "SAPI.h"
|
|
#include "main.h"
|
|
|
|
#include "php_version.h"
|
|
|
|
#ifndef ZTS
|
|
/* Only valid if thread safety is enabled. */
|
|
#undef ROXEN_USE_ZTS
|
|
#endif
|
|
|
|
|
|
/* Pike Include Files
|
|
*
|
|
* conflicts with pike avoided by only using long names. Requires a new
|
|
* Pike 0.7 since it was implemented for this interface only.
|
|
*
|
|
*/
|
|
#define NO_PIKE_SHORTHAND
|
|
|
|
|
|
#include <fdlib.h>
|
|
#include <program.h>
|
|
#include <pike_types.h>
|
|
#include <interpret.h>
|
|
#include <module_support.h>
|
|
#include <error.h>
|
|
#include <array.h>
|
|
#include <backend.h>
|
|
#include <stralloc.h>
|
|
#include <mapping.h>
|
|
#include <object.h>
|
|
#include <threads.h>
|
|
#include <builtin_functions.h>
|
|
#include <operators.h>
|
|
|
|
/* php_roxen_request is per-request object storage */
|
|
|
|
typedef struct {
|
|
struct mapping *request_data;
|
|
struct object *my_fd_obj;
|
|
int my_fd;
|
|
char *filename;
|
|
} php_roxen_request;
|
|
|
|
|
|
/* Defines to get to the data supplied when the script is started. */
|
|
|
|
#ifdef ROXEN_USE_ZTS
|
|
|
|
/* ZTS does work now, but it seems like it's faster using the "serialization"
|
|
* method I previously used. Thus it's not used unless ROXEN_USE_ZTS is defined.
|
|
*/
|
|
|
|
/* Per thread storage area id... */
|
|
static int roxen_globals_id;
|
|
|
|
# define GET_THIS() php_roxen_request *_request = ts_resource(roxen_globals_id)
|
|
# define THIS _request
|
|
#else
|
|
static php_roxen_request *current_request = NULL;
|
|
|
|
# define GET_THIS() current_request = ((php_roxen_request *)fp->current_storage)
|
|
# define THIS current_request
|
|
#endif
|
|
|
|
/* File descriptor integer. Used to write directly to the FD without
|
|
* passing Pike
|
|
*/
|
|
#define MY_FD (THIS->my_fd)
|
|
|
|
/* FD object. Really a PHPScript object from Pike which implements a couple
|
|
* of functions to handle headers, writing and buffering.
|
|
*/
|
|
#define MY_FD_OBJ ((struct object *)(THIS->my_fd_obj))
|
|
|
|
/* Mapping with data supplied from the calling Roxen module. Contains
|
|
* a mapping with headers, an FD object etc.
|
|
*/
|
|
#define REQUEST_DATA ((struct mapping *)(THIS->request_data))
|
|
|
|
|
|
#if defined(_REENTRANT) && !defined(ROXEN_USE_ZTS)
|
|
/* Lock used to serialize the PHP execution. If ROXEN_USE_ZTS is defined, we
|
|
* are using the PHP thread safe mechanism instead.
|
|
*/
|
|
static PIKE_MUTEX_T roxen_php_execution_lock;
|
|
# define PHP_INIT_LOCK() mt_init(&roxen_php_execution_lock)
|
|
# define PHP_LOCK(X) fprintf(stderr, "*** php lock (thr_id=%d, glob=%d).\n", th_self(), current_thread);THREADS_ALLOW();mt_lock(&roxen_php_execution_lock);fprintf(stderr, "*** php locked.\n");THREADS_DISALLOW()
|
|
# define PHP_UNLOCK(X) mt_unlock(&roxen_php_execution_lock);fprintf(stderr, "*** php unlocked (thr_id=%d, glob=%d).\n", th_self(), current_thread);
|
|
# define PHP_DESTROY() mt_destroy(&roxen_php_execution_lock)
|
|
#else /* !_REENTRANT */
|
|
# define PHP_INIT_LOCK()
|
|
# define PHP_LOCK(X) fprintf(stderr, "*** php lock (thr_id=%d).\n", th_self());
|
|
# define PHP_UNLOCK(X) fprintf(stderr, "*** php unlock (thr_id=%d).\n", th_self());
|
|
# define PHP_DESTROY()
|
|
#endif /* _REENTRANT */
|
|
|
|
extern int fd_from_object(struct object *o);
|
|
static unsigned char roxen_php_initialized;
|
|
|
|
/* This allows calling of pike functions from the PHP callbacks,
|
|
* which requires the Pike interpretor to be locked.
|
|
*/
|
|
#define THREAD_SAFE_RUN(COMMAND, what) do {\
|
|
struct thread_state *state;\
|
|
fprintf(stderr,"threads: %d disabled: %d id: %d\n",num_threads, threads_disabled, th_self());\
|
|
if((state = thread_state_for_id(th_self()))!=NULL) {\
|
|
if(!state->swapped) {\
|
|
fprintf(stderr, "MT lock (%s).\n", what);\
|
|
COMMAND;\
|
|
fprintf(stderr, "MT locked done (%s).\n", what);\
|
|
} else {\
|
|
fprintf(stderr, "MT nonlock (%s).\n", what); \
|
|
mt_lock(&interpreter_lock);\
|
|
SWAP_IN_THREAD(state);\
|
|
fprintf(stderr, "MT locked.\n", what); \
|
|
COMMAND;\
|
|
fprintf(stderr, "MT locked done.\n", what); \
|
|
SWAP_OUT_THREAD(state);\
|
|
mt_unlock(&interpreter_lock);\
|
|
fprintf(stderr, "MT unlocked.\n", what); \
|
|
}\
|
|
}\
|
|
} while(0)
|
|
|
|
/* Toggle debug printouts, for now... */
|
|
/*#define MUCH_DEBUG */
|
|
#ifndef MUCH_DEBUG
|
|
void no_fprintf(){}
|
|
#define fprintf no_fprintf
|
|
#endif
|
|
|
|
struct program *php_program;
|
|
|
|
|
|
/* To avoid executing a PHP script from a PHP callback, which would
|
|
* create a deadlock, a global thread id is used. If the thread calling the
|
|
* php-script is the same as the current thread, it fails.
|
|
*/
|
|
static int current_thread = -1;
|
|
|
|
|
|
/* Low level header lookup. Basically looks for the named header in the mapping
|
|
* headers in the supplied options mapping.
|
|
*/
|
|
|
|
static INLINE struct svalue *lookup_header(char *headername)
|
|
{
|
|
struct svalue *headers, *value;
|
|
struct pike_string *sind;
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
sind = make_shared_string("env");
|
|
headers = low_mapping_string_lookup(REQUEST_DATA, sind);
|
|
free_string(sind);
|
|
if(!headers || headers->type != PIKE_T_MAPPING) return NULL;
|
|
sind = make_shared_string(headername);
|
|
value = low_mapping_string_lookup(headers->u.mapping, sind);
|
|
free_string(sind);
|
|
if(!value) return NULL;
|
|
return value;
|
|
}
|
|
|
|
/* Lookup a header in the mapping and return the value as a string, or
|
|
* return the default if it's missing
|
|
*/
|
|
INLINE static char *lookup_string_header(char *headername, char *default_value)
|
|
{
|
|
struct svalue *head = NULL;
|
|
THREAD_SAFE_RUN(head = lookup_header(headername), "header lookup");
|
|
if(!head || head->type != PIKE_T_STRING) {
|
|
fprintf(stderr, "Header lookup for %s: default (%s)\n", headername,
|
|
default_value);
|
|
return default_value;
|
|
}
|
|
fprintf(stderr, "Header lookup for %s: %s(%d)\n", headername,
|
|
head->u.string->str, head->u.string->len);
|
|
return head->u.string->str;
|
|
}
|
|
|
|
/* Lookup a header in the mapping and return the value as if it's an integer
|
|
* and otherwise return the default.
|
|
*/
|
|
INLINE static int lookup_integer_header(char *headername, int default_value)
|
|
{
|
|
struct svalue *head = NULL;
|
|
THREAD_SAFE_RUN(head = lookup_header(headername), "header lookup");
|
|
if(!head || head->type != PIKE_T_INT) {
|
|
fprintf(stderr, "Header lookup for %s: default (%d)\n", headername,
|
|
default_value);
|
|
return default_value;
|
|
}
|
|
fprintf(stderr, "Header lookup for %s: %d \n", headername,
|
|
head->u.integer);
|
|
return head->u.integer;
|
|
}
|
|
|
|
/*
|
|
* php_roxen_low_ub_write() writes data to the client connection. Might be
|
|
* rewritten to do more direct IO to save CPU and the need to lock the *
|
|
* interpretor for better threading.
|
|
*/
|
|
|
|
static int
|
|
php_roxen_low_ub_write(const char *str, uint str_length) {
|
|
int sent_bytes = 0;
|
|
struct pike_string *to_write = NULL;
|
|
#ifdef ZTS
|
|
PLS_FETCH();
|
|
#endif
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
if(!MY_FD_OBJ->prog) {
|
|
PG(connection_status) = PHP_CONNECTION_ABORTED;
|
|
zend_bailout();
|
|
return -1;
|
|
}
|
|
to_write = make_shared_binary_string(str, str_length);
|
|
push_string(to_write);
|
|
safe_apply(MY_FD_OBJ, "write", 1);
|
|
if(sp[-1].type == PIKE_T_INT)
|
|
sent_bytes = sp[-1].u.integer;
|
|
pop_stack();
|
|
if(sent_bytes != str_length) {
|
|
/* This means the connection is closed. Dead. Gone. *sniff* */
|
|
PG(connection_status) = PHP_CONNECTION_ABORTED;
|
|
zend_bailout();
|
|
}
|
|
fprintf(stderr, "low_write done.\n");
|
|
return sent_bytes;
|
|
}
|
|
|
|
/*
|
|
* php_roxen_sapi_ub_write() calls php_roxen_low_ub_write in a Pike thread
|
|
* safe manner.
|
|
*/
|
|
|
|
static int
|
|
php_roxen_sapi_ub_write(const char *str, uint str_length)
|
|
{
|
|
#ifdef ZTS
|
|
PLS_FETCH();
|
|
#endif
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
int sent_bytes = 0, fd = MY_FD;
|
|
if(fd)
|
|
{
|
|
for(sent_bytes=0;sent_bytes < str_length;)
|
|
{
|
|
int written;
|
|
written = fd_write(fd, str + sent_bytes, str_length - sent_bytes);
|
|
if(written < 0)
|
|
{
|
|
switch(errno)
|
|
{
|
|
default:
|
|
/* This means the connection is closed. Dead. Gone. *sniff* */
|
|
PG(connection_status) = PHP_CONNECTION_ABORTED;
|
|
zend_bailout();
|
|
return sent_bytes;
|
|
case EINTR:
|
|
case EWOULDBLOCK:
|
|
continue;
|
|
}
|
|
|
|
} else {
|
|
sent_bytes += written;
|
|
}
|
|
}
|
|
} else {
|
|
THREAD_SAFE_RUN(sent_bytes = php_roxen_low_ub_write(str, str_length),
|
|
"write");
|
|
}
|
|
fprintf(stderr, "write done.\n");
|
|
return sent_bytes;
|
|
}
|
|
|
|
/* php_roxen_set_header() sets a header in the header mapping. Called in a
|
|
* thread safe manner from php_roxen_sapi_header_handler.
|
|
*/
|
|
static void php_roxen_set_header(char *header_name, char *value, char *p)
|
|
{
|
|
struct svalue hsval;
|
|
struct pike_string *hval, *ind, *hind;
|
|
struct mapping *headermap;
|
|
struct svalue *s_headermap;
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
hval = make_shared_string(value);
|
|
ind = make_shared_string(" _headers");
|
|
hind = make_shared_binary_string(header_name,
|
|
(int)(p - header_name));
|
|
|
|
s_headermap = low_mapping_string_lookup(REQUEST_DATA, ind);
|
|
if(!s_headermap)
|
|
{
|
|
struct svalue mappie;
|
|
mappie.type = PIKE_T_MAPPING;
|
|
headermap = allocate_mapping(1);
|
|
mappie.u.mapping = headermap;
|
|
mapping_string_insert(REQUEST_DATA, ind, &mappie);
|
|
free_mapping(headermap);
|
|
} else
|
|
headermap = s_headermap->u.mapping;
|
|
|
|
hsval.type = PIKE_T_STRING;
|
|
hsval.u.string = hval;
|
|
mapping_string_insert(headermap, hind, &hsval);
|
|
|
|
fprintf(stderr, "Setting header %s to %s\n", hind->str, value);
|
|
free_string(hval);
|
|
free_string(ind);
|
|
free_string(hind);
|
|
}
|
|
|
|
/*
|
|
* php_roxen_sapi_header_handler() sets a HTTP reply header to be
|
|
* sent to the client.
|
|
*/
|
|
static int
|
|
php_roxen_sapi_header_handler(sapi_header_struct *sapi_header,
|
|
sapi_headers_struct *sapi_headers SLS_DC)
|
|
{
|
|
char *header_name, *header_content, *p;
|
|
header_name = sapi_header->header;
|
|
header_content = p = strchr(header_name, ':');
|
|
|
|
if(!p) return 0;
|
|
do {
|
|
header_content++;
|
|
} while(*header_content == ' ');
|
|
THREAD_SAFE_RUN(php_roxen_set_header(header_name, header_content, p), "header handler");
|
|
efree(sapi_header->header);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* php_roxen_sapi_send_headers() flushes the headers to the client.
|
|
* Called before real content is sent by PHP.
|
|
*/
|
|
|
|
static int
|
|
php_roxen_low_send_headers(sapi_headers_struct *sapi_headers SLS_DC)
|
|
{
|
|
#ifdef ZTS
|
|
PLS_FETCH();
|
|
#endif
|
|
struct pike_string *ind;
|
|
struct svalue *s_headermap;
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
if(!MY_FD_OBJ->prog) {
|
|
PG(connection_status) = PHP_CONNECTION_ABORTED;
|
|
zend_bailout();
|
|
return SAPI_HEADER_SEND_FAILED;
|
|
}
|
|
ind = make_shared_string(" _headers");
|
|
s_headermap = low_mapping_string_lookup(REQUEST_DATA, ind);
|
|
free_string(ind);
|
|
fprintf(stderr, "Send Headers (%d)...\n", SG(sapi_headers).http_response_code);
|
|
|
|
push_int(SG(sapi_headers).http_response_code);
|
|
if(s_headermap && s_headermap->type == PIKE_T_MAPPING)
|
|
ref_push_mapping(s_headermap->u.mapping);
|
|
else
|
|
push_int(0);
|
|
safe_apply(MY_FD_OBJ, "send_headers", 2);
|
|
pop_stack();
|
|
|
|
return SAPI_HEADER_SENT_SUCCESSFULLY;
|
|
}
|
|
|
|
static int
|
|
php_roxen_sapi_send_headers(sapi_headers_struct *sapi_headers SLS_DC)
|
|
{
|
|
int res = 0;
|
|
THREAD_SAFE_RUN(res = php_roxen_low_send_headers(sapi_headers SLS_CC), "send headers");
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* php_roxen_sapi_read_post() reads a specified number of bytes from
|
|
* the client. Used for POST/PUT requests.
|
|
*/
|
|
|
|
INLINE static int php_roxen_low_read_post(char *buf, uint count_bytes)
|
|
{
|
|
uint total_read = 0;
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
#ifdef ZTS
|
|
PLS_FETCH();
|
|
#endif
|
|
|
|
fprintf(stderr, "read post (%d bytes max)\n", count_bytes);
|
|
|
|
if(!MY_FD_OBJ->prog) {
|
|
PG(connection_status) = PHP_CONNECTION_ABORTED;
|
|
zend_bailout();
|
|
return -1;
|
|
}
|
|
|
|
push_int(count_bytes);
|
|
safe_apply(MY_FD_OBJ, "read_post", 1);
|
|
if(sp[-1].type == PIKE_T_STRING) {
|
|
MEMCPY(buf, sp[-1].u.string->str, total_read = sp[-1].u.string->len);
|
|
buf[total_read] = '\0';
|
|
} else
|
|
total_read = -1;
|
|
pop_stack();
|
|
return total_read;
|
|
}
|
|
|
|
static int
|
|
php_roxen_sapi_read_post(char *buf, uint count_bytes SLS_DC)
|
|
{
|
|
uint total_read = 0;
|
|
THREAD_SAFE_RUN(total_read = php_roxen_low_read_post(buf, count_bytes), "read post");
|
|
return total_read;
|
|
}
|
|
|
|
/*
|
|
* php_roxen_sapi_read_cookies() returns the Cookie header from
|
|
* the HTTP request header
|
|
*/
|
|
|
|
static char *
|
|
php_roxen_sapi_read_cookies(SLS_D)
|
|
{
|
|
char *cookies;
|
|
cookies = lookup_string_header("HTTP_COOKIE", NULL);
|
|
return cookies;
|
|
}
|
|
|
|
static void php_info_roxen(ZEND_MODULE_INFO_FUNC_ARGS)
|
|
{
|
|
/* char buf[512]; */
|
|
|
|
PUTS("<table border=5 width=600>\n");
|
|
php_info_print_table_row(2, "SAPI module version", "$Id$");
|
|
/* php_info_print_table_row(2, "Build date", Ns_InfoBuildDate());
|
|
php_info_print_table_row(2, "Config file path", Ns_InfoConfigFile());
|
|
php_info_print_table_row(2, "Error Log path", Ns_InfoErrorLog());
|
|
php_info_print_table_row(2, "Installation path", Ns_InfoHomePath());
|
|
php_info_print_table_row(2, "Hostname of server", Ns_InfoHostname());
|
|
php_info_print_table_row(2, "Source code label", Ns_InfoLabel());
|
|
php_info_print_table_row(2, "Server platform", Ns_InfoPlatform());
|
|
snprintf(buf, 511, "%s/%s", Ns_InfoServerName(), Ns_InfoServerVersion());
|
|
php_info_print_table_row(2, "Server version", buf);
|
|
snprintf(buf, 511, "%d day(s), %02d:%02d:%02d",
|
|
uptime / 86400,
|
|
(uptime / 3600) % 24,
|
|
(uptime / 60) % 60,
|
|
uptime % 60);
|
|
php_info_print_table_row(2, "Server uptime", buf);
|
|
*/
|
|
PUTS("</table>");
|
|
}
|
|
|
|
static zend_module_entry php_roxen_module = {
|
|
"Roxen",
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
php_info_roxen,
|
|
STANDARD_MODULE_PROPERTIES
|
|
};
|
|
|
|
static int php_roxen_startup(sapi_module_struct *sapi_module)
|
|
{
|
|
if(php_module_startup(sapi_module) == FAILURE
|
|
|| zend_register_module(&php_roxen_module) == FAILURE) {
|
|
return FAILURE;
|
|
} else {
|
|
return SUCCESS;
|
|
}
|
|
}
|
|
|
|
/* this structure is static (as in "it does not change") */
|
|
|
|
void pike_module_exit(void);
|
|
|
|
static sapi_module_struct sapi_module = {
|
|
"Roxen",
|
|
|
|
php_module_startup, /* startup */
|
|
pike_module_exit, /* shutdown */
|
|
|
|
php_roxen_sapi_ub_write, /* unbuffered write */
|
|
|
|
php_error, /* error handler */
|
|
|
|
php_roxen_sapi_header_handler, /* header handler */
|
|
php_roxen_sapi_send_headers, /* send headers handler */
|
|
NULL, /* send header handler */
|
|
|
|
php_roxen_sapi_read_post, /* read POST data */
|
|
php_roxen_sapi_read_cookies, /* read Cookies */
|
|
|
|
STANDARD_SAPI_MODULE_PROPERTIES
|
|
};
|
|
|
|
/*
|
|
* php_roxen_hash_environment() populates the php script environment
|
|
* with a number of variables. HTTP_* variables are created for
|
|
* the HTTP header data, so that a script can access these.
|
|
*/
|
|
#define ADD_STRING(name) \
|
|
MAKE_STD_ZVAL(pval); \
|
|
pval->type = IS_STRING; \
|
|
pval->value.str.len = strlen(buf); \
|
|
pval->value.str.val = estrndup(buf, pval->value.str.len); \
|
|
zend_hash_update(&EG(symbol_table), name, sizeof(name), \
|
|
&pval, sizeof(zval *), NULL)
|
|
|
|
static void
|
|
php_roxen_hash_environment(CLS_D ELS_DC PLS_DC SLS_DC)
|
|
{
|
|
int i;
|
|
char buf[512];
|
|
zval *pval;
|
|
struct svalue *headers;
|
|
struct pike_string *sind;
|
|
struct array *indices;
|
|
struct svalue *ind, *val;
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
sind = make_shared_string("env");
|
|
headers = low_mapping_string_lookup(REQUEST_DATA, sind);
|
|
free_string(sind);
|
|
if(headers && headers->type == PIKE_T_MAPPING) {
|
|
indices = mapping_indices(headers->u.mapping);
|
|
for(i = 0; i < indices->size; i++) {
|
|
ind = &indices->item[i];
|
|
val = low_mapping_lookup(headers->u.mapping, ind);
|
|
if(ind && ind->type == PIKE_T_STRING &&
|
|
val && val->type == PIKE_T_STRING) {
|
|
int buf_len;
|
|
buf_len = MIN(511, ind->u.string->len);
|
|
strncpy(buf, ind->u.string->str, buf_len);
|
|
buf[buf_len] = '\0'; /* Terminate correctly */
|
|
MAKE_STD_ZVAL(pval);
|
|
pval->type = IS_STRING;
|
|
pval->value.str.len = val->u.string->len;
|
|
pval->value.str.val = estrndup(val->u.string->str, pval->value.str.len);
|
|
fprintf(stderr, "Header: %s(%d)=%s\n", buf, buf_len, val->u.string->str);
|
|
|
|
zend_hash_update(&EG(symbol_table), buf, buf_len + 1, &pval, sizeof(zval *), NULL);
|
|
}
|
|
}
|
|
free_array(indices);
|
|
}
|
|
|
|
/*
|
|
MAKE_STD_ZVAL(pval);
|
|
pval->type = IS_LONG;
|
|
pval->value.lval = Ns_InfoBootTime();
|
|
zend_hash_update(&EG(symbol_table), "SERVER_BOOTTIME", sizeof("SERVER_BOOTTIME"), &pval, sizeof(zval *), NULL);
|
|
|
|
fprintf(stderr, "Set up header environment.\n");
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* php_roxen_module_main() is called by the per-request handler and
|
|
* "executes" the script
|
|
*/
|
|
|
|
static int php_roxen_module_main(SLS_D)
|
|
{
|
|
int res;
|
|
zend_file_handle file_handle;
|
|
#ifdef ZTS
|
|
CLS_FETCH();
|
|
PLS_FETCH();
|
|
ELS_FETCH();
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
#endif
|
|
file_handle.type = ZEND_HANDLE_FILENAME;
|
|
file_handle.filename = THIS->filename;
|
|
file_handle.free_filename = 0;
|
|
THREADS_ALLOW();
|
|
fprintf(stderr, "Request Startup.\n");
|
|
res = php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC);
|
|
THREADS_DISALLOW();
|
|
if(res == FAILURE) {
|
|
return 0;
|
|
}
|
|
php_roxen_hash_environment(CLS_C ELS_CC PLS_CC SLS_CC);
|
|
THREADS_ALLOW();
|
|
fprintf(stderr, "Script Execute.\n");
|
|
php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
|
|
php_request_shutdown(NULL);
|
|
THREADS_DISALLOW();
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* The php_roxen_request_handler() is called per request and handles
|
|
* everything for one request.
|
|
*/
|
|
|
|
void f_php_roxen_request_handler(INT32 args)
|
|
{
|
|
struct object *my_fd_obj;
|
|
struct mapping *request_data;
|
|
struct svalue *done_callback, *raw_fd;
|
|
struct pike_string *script, *ind;
|
|
int status = 1;
|
|
SLS_FETCH();
|
|
#ifdef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
|
|
if(current_thread == th_self())
|
|
error("PHP4.Interpetor->run: Tried to run a PHP-script from a PHP "
|
|
"callback!");
|
|
get_all_args("PHP4.Interpretor->run", args, "%S%m%O%*", &script,
|
|
&request_data, &my_fd_obj, &done_callback);
|
|
if(done_callback->type != PIKE_T_FUNCTION)
|
|
error("PHP4.Interpretor->run: Bad argument 4, expected function.\n");
|
|
PHP_LOCK(THIS); /* Need to lock here or reusing the same object might cause
|
|
* problems in changing stuff in that object */
|
|
#ifndef ROXEN_USE_ZTS
|
|
GET_THIS();
|
|
#endif
|
|
THIS->request_data = request_data;
|
|
THIS->my_fd_obj = my_fd_obj;
|
|
THIS->filename = script->str;
|
|
current_thread = th_self();
|
|
SG(request_info).query_string = lookup_string_header("QUERY_STRING", 0);;
|
|
SG(server_context) = (void *)1; /* avoid server_context == NULL */
|
|
/* path_translated is the absolute path to the file */
|
|
SG(request_info).path_translated =
|
|
lookup_string_header("PATH_TRANSLATED", NULL);
|
|
SG(request_info).request_uri = lookup_string_header("DOCUMENT_URI", NULL);
|
|
if(!SG(request_info).request_uri)
|
|
SG(request_info).request_uri = lookup_string_header("SCRIPT_NAME", NULL);
|
|
SG(request_info).request_method = lookup_string_header("REQUEST_METHOD", "GET");
|
|
SG(request_info).content_length = lookup_integer_header("CONTENT_LENGTH", 0);
|
|
SG(request_info).content_type = "text/html";
|
|
SG(request_info).auth_user = NULL;
|
|
SG(request_info).auth_password = NULL;
|
|
|
|
ind = make_shared_binary_string("my_fd", 5);
|
|
raw_fd = low_mapping_string_lookup(THIS->request_data, ind);
|
|
if(raw_fd && raw_fd->type == PIKE_T_OBJECT)
|
|
{
|
|
int fd = fd_from_object(raw_fd->u.object);
|
|
if(fd == -1)
|
|
error("PHP4.Interpretor->run: my_fd object not open or not an FD.\n");
|
|
THIS->my_fd = fd;
|
|
} else
|
|
THIS->my_fd = 0;
|
|
|
|
status = php_roxen_module_main(SLS_C);
|
|
current_thread = -1;
|
|
|
|
apply_svalue(done_callback, 0);
|
|
pop_stack();
|
|
pop_n_elems(args);
|
|
push_int(status);
|
|
PHP_UNLOCK(THIS);
|
|
}
|
|
|
|
|
|
/* Clear the object global struct */
|
|
static void clear_struct(struct object *o)
|
|
{
|
|
MEMSET(fp->current_storage, 0, sizeof(php_roxen_request));
|
|
}
|
|
|
|
|
|
/*
|
|
* pike_module_init() is called by Pike once at startup
|
|
*
|
|
* This functions allocates basic structures
|
|
*/
|
|
|
|
void pike_module_init()
|
|
{
|
|
if (!roxen_php_initialized) {
|
|
#ifdef ZTS
|
|
tsrm_startup(1, 1, 0);
|
|
#ifdef ROXEN_USE_ZTS
|
|
roxen_globals_id = ts_allocate_id(sizeof(php_roxen_request), NULL, NULL);
|
|
#endif
|
|
#endif
|
|
sapi_startup(&sapi_module);
|
|
php_roxen_startup(&sapi_module);
|
|
roxen_php_initialized = 1;
|
|
PHP_INIT_LOCK();
|
|
}
|
|
start_new_program(); /* Text */
|
|
ADD_STORAGE(php_roxen_request);
|
|
set_init_callback(clear_struct);
|
|
pike_add_function("run", f_php_roxen_request_handler,
|
|
"function(string,mapping,object,function:int)", 0);
|
|
add_program_constant("Interpretor", (php_program = end_program()), 0);
|
|
}
|
|
|
|
/*
|
|
* pike_module_exit() performs the last steps before the
|
|
* server exists. Shutdowns basic services and frees memory
|
|
*/
|
|
|
|
void pike_module_exit(void)
|
|
{
|
|
roxen_php_initialized = 0;
|
|
sapi_module.shutdown(&sapi_module);
|
|
if(php_program) free_program(php_program);
|
|
#ifdef ZTS
|
|
tsrm_shutdown();
|
|
#endif
|
|
PHP_DESTROY();
|
|
}
|
|
#endif
|