Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

Deletes patch leftovers

pull/805/head
Florian MARGAINE 12 years ago
parent
cf0303e782
commit
58ed832fc9
5 changed files with 0 additions and 2801 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 40
      ext/tidy/examples/cleanhtml.php.orig
  2. 39
      ext/tidy/examples/cleanhtml5.php.orig
  3. 5
      ext/xmlreader/README.orig
  4. 783
      sapi/caudium/caudium.c.orig
  5. 1934
      win32/install.txt.orig

40
ext/tidy/examples/cleanhtml.php.orig
View File

@ -1,40 +0,0 @@
<?php
/*
* cleanhtml.php
*
* A simple script to clean and repair HTML,XHTML,PHP,ASP,etc. documents
* if no file is provided, it reads from standard input.
*
* NOTE: Works only with tidy for PHP 4.3.x, for tidy in PHP 5 see cleanhtml5.php
*
* By: John Coggeshall <john@php.net>
*
* Usage: php cleanhtml.php [filename]
*
*/
if(!isset($_SERVER['argv'][1])) {
$data = file_get_contents("php://stdin");
tidy_parse_string($data);
} else {
tidy_parse_file($_SERVER['argv'][1]);
}
tidy_clean_repair();
if(tidy_warning_count() ||
tidy_error_count()) {
echo "\n\nThe following errors or warnings occurred:\n";
echo tidy_get_error_buffer();
echo "\n";
}
echo tidy_get_output();
?>

39
ext/tidy/examples/cleanhtml5.php.orig
View File

@ -1,39 +0,0 @@
<?php
/*
* cleanhtml5.php
*
* A simple script to clean and repair HTML,XHTML,PHP,ASP,etc. documents
* if no file is provided, it reads from standard input.
*
* NOTE: Works only with tidy for PHP 5, for tidy in PHP 4.3.x see cleanhtml.php
*
* By: John Coggeshall <john@php.net>
*
* Usage: php cleanhtml5.php [filename]
*
*/
if(!isset($_SERVER['argv'][1])) {
$data = file_get_contents("php://stdin");
$tidy = tidy_parse_string($data);
} else {
$tidy = tidy_parse_file($_SERVER['argv'][1]);
}
$tidy->cleanRepair();
if(!empty($tidy->errorBuffer)) {
echo "\n\nThe following errors or warnings occurred:\n";
echo "{$tidy->errorBuffer}\n";
}
echo $tidy;
?>

5
ext/xmlreader/README.orig
View File

@ -1,5 +0,0 @@
XMLReader represents a reader that provides non-cached,
forward-only access to XML data. It is based upon the
xmlTextReader api from libxml
This extension is designed to only work under PHP 5.

783
sapi/caudium/caudium.c.orig
View File

@ -1,783 +0,0 @@
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2014 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.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_CAUDIUM
#include "php_ini.h"
#include "php_globals.h"
#include "SAPI.h"
#include "php_main.h"
#include "ext/standard/info.h"
#include "php_version.h"
/* 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
/* Ok, we are now using Pike level threads to handle PHP5 since
* the nice th_farm threads aren't working on Linux with glibc 2.2
* (why this is I don't know).
*/
#define USE_PIKE_LEVEL_THREADS
#include <fdlib.h>
#include <program.h>
#include <pike_types.h>
#include <interpret.h>
#include <module_support.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>
#include <version.h>
#if (PIKE_MAJOR_VERSION == 7 && PIKE_MINOR_VERSION == 1 && PIKE_BUILD_VERSION >= 12) || PIKE_MAJOR_VERSION > 7 || (PIKE_MAJOR_VERSION == 7 && PIKE_MINOR_VERSION > 1)
# include "pike_error.h"
#else
# include "error.h"
# ifndef Pike_error
# define Pike_error error
# endif
#endif
/* Pike 7.x and newer */
#define MY_MAPPING_LOOP(md, COUNT, KEY) \
for(COUNT=0;COUNT < md->data->hashsize; COUNT++ ) \
for(KEY=md->data->hash[COUNT];KEY;KEY=KEY->next)
#ifndef ZTS
/* Need thread safety */
#error You need to compile PHP with threads.
#endif
#ifndef PIKE_THREADS
#error The PHP5 module requires that your Pike has thread support.
#endif
#undef HIDE_GLOBAL_VARIABLES
#undef REVEAL_GLOBAL_VARIABLES
#define HIDE_GLOBAL_VARIABLES()
#define REVEAL_GLOBAL_VARIABLES()
/* php_caudium_request is per-request object storage */
typedef struct
{
struct mapping *request_data;
struct object *my_fd_obj;
struct svalue done_cb;
struct pike_string *filename;
int my_fd;
int written;
TSRMLS_D;
} php_caudium_request;
void pike_module_init(void);
void pike_module_exit(void);
static void free_struct(TSRMLS_D);
void f_php_caudium_request_handler(INT32 args);
/* Defines to get to the data supplied when the script is started. */
/* Per thread storage area id... */
static int caudium_globals_id;
#define GET_THIS() php_caudium_request *_request = ts_resource(caudium_globals_id)
#define THIS _request
#define PTHIS ((php_caudium_request *)(Pike_fp->current_storage))
/* 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 Caudium module. Contains
* a mapping with headers, an FD object etc.
*/
#define REQUEST_DATA ((struct mapping *)(THIS->request_data))
extern int fd_from_object(struct object *o);
static unsigned char caudium_php_initialized;
#ifndef mt_lock_interpreter
#define mt_lock_interpreter() mt_lock(&interpreter_lock);
#define mt_unlock_interpreter() mt_unlock(&interpreter_lock);
#endif
/* This allows calling of pike functions from the PHP callbacks,
* which requires the Pike interpreter to be locked.
*/
#define THREAD_SAFE_RUN(COMMAND, what) do {\
struct thread_state *state;\
if((state = thread_state_for_id(th_self()))!=NULL) {\
if(!state->swapped) {\
COMMAND;\
} else {\
mt_lock_interpreter();\
SWAP_IN_THREAD(state);\
COMMAND;\
SWAP_OUT_THREAD(state);\
mt_unlock_interpreter();\
}\
}\
} while(0)
/* Low level header lookup. Basically looks for the named header in the mapping
* headers in the supplied options mapping.
*/
INLINE static struct svalue *lookup_header(char *headername)
{
struct svalue *headers, *value;
struct pike_string *sind;
GET_THIS();
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)
return default_value;
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)
return default_value;
return head->u.integer;
}
/*
* php_caudium_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
* interpreter for better threading.
*/
INLINE static int
php_caudium_low_ub_write(const char *str, uint str_length TSRMLS_DC) {
int sent_bytes = 0;
struct pike_string *to_write = NULL;
GET_THIS();
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(Pike_sp[-1].type == PIKE_T_INT)
sent_bytes = Pike_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();
}
return sent_bytes;
}
/*
* php_caudium_sapi_ub_write() calls php_caudium_low_ub_write in a Pike thread
* safe manner or writes directly to the output FD if RXML post-parsing is
* disabled.
*/
static int
php_caudium_sapi_ub_write(const char *str, uint str_length TSRMLS_DC)
{
GET_THIS();
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();
THIS->written += sent_bytes;
return sent_bytes;
case EINTR:
case EWOULDBLOCK:
continue;
}
} else {
sent_bytes += written;
}
}
THIS->written += sent_bytes;
} else {
THREAD_SAFE_RUN(sent_bytes = php_caudium_low_ub_write(str, str_length TSRMLS_CC),
"write");
}
return sent_bytes;
}
/* php_caudium_set_header() sets a header in the header mapping. Called in a
* thread safe manner from php_caudium_sapi_header_handler.
*/
INLINE static void
php_caudium_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, *soldval;
int vallen;
GET_THIS();
/* 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 || s_headermap->type != PIKE_T_MAPPING)
{
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);
hval = make_shared_string(value);
} else {
headermap = s_headermap->u.mapping;
soldval = low_mapping_string_lookup(headermap, hind);
vallen = strlen(value);
if(soldval != NULL &&
soldval->type == PIKE_T_STRING &&
soldval->u.string->size_shift == 0) {
/* Existing, valid header. Prepend.*/
hval = begin_shared_string(soldval->u.string->len + 1 + vallen);
MEMCPY(hval->str, soldval->u.string->str, soldval->u.string->len);
STR0(hval)[soldval->u.string->len] = '\0';
MEMCPY(hval->str+soldval->u.string->len+1, value, vallen);
hval = end_shared_string(hval);
} else {
hval = make_shared_string(value);
}
}
hsval.type = PIKE_T_STRING;
hsval.u.string = hval;
mapping_string_insert(headermap, hind, &hsval);
free_string(hval);
free_string(ind);
free_string(hind);
}
/*
* php_caudium_sapi_header_handler() sets a HTTP reply header to be
* sent to the client.
*/
static int
php_caudium_sapi_header_handler(sapi_header_struct *sapi_header,
sapi_headers_struct *sapi_headers TSRMLS_DC)
{
char *header_name, *header_content, *p;
header_name = sapi_header->header;
header_content = p = strchr(header_name, ':');
if(p) {
do {
header_content++;
} while(*header_content == ' ');
THREAD_SAFE_RUN(php_caudium_set_header(header_name, header_content, p), "header handler");
}
sapi_free_header(sapi_header);
return 0;
}
/*
* php_caudium_sapi_send_headers() flushes the headers to the client.
* Called before real content is sent by PHP.
*/
INLINE static int
php_caudium_low_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
{
struct pike_string *ind;
struct svalue *s_headermap;
GET_THIS();
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);
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_caudium_sapi_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
{
int res = 0;
THREAD_SAFE_RUN(res = php_caudium_low_send_headers(sapi_headers TSRMLS_CC), "send headers");
return res;
}
/*
* php_caudium_sapi_read_post() reads a specified number of bytes from
* the client. Used for POST/PUT requests.
*/
INLINE static int php_caudium_low_read_post(char *buf, uint count_bytes TSRMLS_DC)
{
uint total_read = 0;
GET_THIS();
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(Pike_sp[-1].type == PIKE_T_STRING) {
MEMCPY(buf, Pike_sp[-1].u.string->str,
(total_read = Pike_sp[-1].u.string->len));
buf[total_read] = '\0';
} else
total_read = 0;
pop_stack();
return total_read;
}
static int
php_caudium_sapi_read_post(char *buf, uint count_bytes TSRMLS_DC)
{
uint total_read = 0;
THREAD_SAFE_RUN(total_read = php_caudium_low_read_post(buf, count_bytes TSRMLS_CC), "read post");
return total_read;
}
/*
* php_caudium_sapi_read_cookies() returns the Cookie header from
* the HTTP request header
*/
static char *
php_caudium_sapi_read_cookies(TSRMLS_D)
{
char *cookies;
cookies = lookup_string_header("HTTP_COOKIE", NULL);
return cookies;
}
static void php_info_caudium(ZEND_MODULE_INFO_FUNC_ARGS)
{
/* char buf[512]; */
php_info_print_table_start();
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);
*/
php_info_print_table_end();
}
static zend_module_entry php_caudium_module = {
STANDARD_MODULE_HEADER,
"Caudium",
NULL,
NULL,
NULL,
NULL,
NULL,
php_info_caudium,
NULL,
STANDARD_MODULE_PROPERTIES
};
INLINE static void low_sapi_caudium_register_variables(zval *track_vars_array TSRMLS_DC)
{
int i;
struct keypair *k;
struct svalue *headers;
struct pike_string *sind;
struct svalue *ind;
struct svalue *val;
GET_THIS();
php_register_variable("PHP_SELF", SG(request_info).request_uri,
track_vars_array TSRMLS_CC);
php_register_variable("GATEWAY_INTERFACE", "CGI/1.1",
track_vars_array TSRMLS_CC);
php_register_variable("REQUEST_METHOD",
(char *) SG(request_info).request_method,
track_vars_array TSRMLS_CC);
php_register_variable("REQUEST_URI", SG(request_info).request_uri,
track_vars_array TSRMLS_CC);
php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated,
track_vars_array TSRMLS_CC);
sind = make_shared_string("env");
headers = low_mapping_string_lookup(REQUEST_DATA, sind);
free_string(sind);
if(headers && headers->type == PIKE_T_MAPPING) {
MY_MAPPING_LOOP(headers->u.mapping, i, k) {
ind = &k->ind;
val = &k->val;
if(ind && ind->type == PIKE_T_STRING &&
val && val->type == PIKE_T_STRING) {
php_register_variable(ind->u.string->str, val->u.string->str,
track_vars_array TSRMLS_CC );
}
}
}
}
static void sapi_caudium_register_variables(zval *track_vars_array TSRMLS_DC)
{
THREAD_SAFE_RUN(low_sapi_caudium_register_variables(track_vars_array TSRMLS_CC), "register_variables");
}
static int php_caudium_startup(sapi_module_struct *sapi_module)
{
if (php_module_startup(sapi_module, &php_caudium_module, 1)==FAILURE) {
return FAILURE;
}
return SUCCESS;
}
/* this structure is static (as in "it does not change") */
static sapi_module_struct caudium_sapi_module = {
"caudium",
"Caudium",
php_caudium_startup, /* startup */
php_module_shutdown_wrapper, /* shutdown */
NULL, /* activate */
NULL, /* deactivate */
php_caudium_sapi_ub_write, /* unbuffered write */
NULL, /* flush */
NULL, /* get uid */
NULL, /* getenv */
php_error, /* error handler */
php_caudium_sapi_header_handler, /* header handler */
php_caudium_sapi_send_headers, /* send headers handler */
NULL, /* send header handler */
php_caudium_sapi_read_post, /* read POST data */
php_caudium_sapi_read_cookies, /* read cookies */
sapi_caudium_register_variables, /* register server variables */
NULL, /* Log message */
NULL, /* Get request time */
NULL, /* Child terminate */
STANDARD_SAPI_MODULE_PROPERTIES
};
/*
* php_caudium_module_main() is called by the per-request handler and
* "executes" the script
*/
static void php_caudium_module_main(php_caudium_request *ureq)
{
int res;
zend_file_handle file_handle;
#ifndef USE_PIKE_LEVEL_THREADS
struct thread_state *state;
extern struct program *thread_id_prog;
#endif
TSRMLS_FETCH();
GET_THIS();
THIS->filename = ureq->filename;
THIS->done_cb = ureq->done_cb;
THIS->my_fd_obj = ureq->my_fd_obj;
THIS->my_fd = ureq->my_fd;
THIS->request_data = ureq->request_data;
free(ureq);
#ifndef USE_PIKE_LEVEL_THREADS
mt_lock_interpreter();
init_interpreter();
#if PIKE_MAJOR_VERSION == 7 && PIKE_MINOR_VERSION < 1
thread_id = low_clone(thread_id_prog);
state = OBJ2THREAD(thread_id);
Pike_stack_top=((char *)&state)+ (thread_stack_size-16384) * STACK_DIRECTION;
recoveries = NULL;
call_c_initializers(thread_id);
OBJ2THREAD(thread_id)->id=th_self();
num_threads++;
thread_table_insert(thread_id);
state->status=THREAD_RUNNING;
#else
Pike_interpreter.thread_id = low_clone(thread_id_prog);
state = OBJ2THREAD(Pike_interpreter.thread_id);
Pike_interpreter.stack_top=((char *)&state)+ (thread_stack_size-16384) * STACK_DIRECTION;
Pike_interpreter.recoveries = NULL;
call_c_initializers(Pike_interpreter.thread_id);
state->id=th_self();
/* SWAP_OUT_THREAD(OBJ2THREAD(Pike_interpreter.thread_id)); */
num_threads++;
thread_table_insert(Pike_interpreter.thread_id);
state->status=THREAD_RUNNING;
#endif
state->swapped = 0;
#endif
SG(request_info).query_string = lookup_string_header("QUERY_STRING", 0);
SG(server_context) = (void *)1; /* avoid server_context == NULL */
/* path_translated is apparently the absolute path to the file, not
the translated PATH_INFO
*/
SG(request_info).path_translated =
lookup_string_header("SCRIPT_FILENAME", 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("HTTP_CONTENT_LENGTH", 0);
SG(request_info).content_type = lookup_string_header("HTTP_CONTENT_TYPE", NULL);
SG(sapi_headers).http_response_code = 200;
if (!strcmp(SG(request_info).request_method, "HEAD")) {
SG(request_info).headers_only = 1;
} else {
SG(request_info).headers_only = 0;
}
/* Let PHP5 handle the deconding of the AUTH */
php_handle_auth_data(lookup_string_header("HTTP_AUTHORIZATION", NULL), TSRMLS_C);
/* Swap out this thread and release the interpreter lock to allow
* Pike threads to run. We wait since the above would otherwise require
* a lot of unlock/lock.
*/
#ifndef USE_PIKE_LEVEL_THREADS
SWAP_OUT_THREAD(state);
mt_unlock_interpreter();
#else
THREADS_ALLOW();
#endif
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.filename = THIS->filename->str;
file_handle.opened_path = NULL;
file_handle.free_filename = 0;
THIS->written = 0;
res = php_request_startup(TSRMLS_C);
if(res == FAILURE) {
THREAD_SAFE_RUN({
apply_svalue(&THIS->done_cb, 0);
pop_stack();
free_struct(TSRMLS_C);
}, "Negative run response");
} else {
php_execute_script(&file_handle TSRMLS_CC);
php_request_shutdown(NULL);
THREAD_SAFE_RUN({
push_int(THIS->written);
apply_svalue(&THIS->done_cb, 1);
pop_stack();
free_struct(TSRMLS_C);
}, "positive run response");
}
#ifndef USE_PIKE_LEVEL_THREADS
mt_lock_interpreter();
SWAP_IN_THREAD(state);
#if PIKE_MAJOR_VERSION == 7 && PIKE_MINOR_VERSION < 1
state->status=THREAD_EXITED;
co_signal(& state->status_change);
thread_table_delete(thread_id);
free_object(thread_id);
thread_id=NULL;
#else
state->status=THREAD_EXITED;
co_signal(& state->status_change);
thread_table_delete(Pike_interpreter.thread_id);
free_object(Pike_interpreter.thread_id);
Pike_interpreter.thread_id=NULL;
#endif
cleanup_interpret();
num_threads--;
mt_unlock_interpreter();
#else
THREADS_DISALLOW();
#endif
}
/*
* The php_caudium_request_handler() is called per request and handles
* everything for one request.
*/
void f_php_caudium_request_handler(INT32 args)
{
struct object *my_fd_obj;
struct mapping *request_data;
struct svalue *done_callback;
struct pike_string *script;
struct svalue *raw_fd;
struct pike_string *ind;
php_caudium_request *_request;
THIS = malloc(sizeof(php_caudium_request));
if(THIS == NULL)
Pike_error("Out of memory.");
get_all_args("PHP5.Interpreter->run", args, "%S%m%O%*", &script,
&request_data, &my_fd_obj, &done_callback);
if(done_callback->type != PIKE_T_FUNCTION)
Pike_error("PHP5.Interpreter->run: Bad argument 4, expected function.\n");
add_ref(request_data);
add_ref(my_fd_obj);
add_ref(script);
THIS->request_data = request_data;
THIS->my_fd_obj = my_fd_obj;
THIS->filename = script;
assign_svalue_no_free(&THIS->done_cb, done_callback);
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)
THIS->my_fd = 0; /* Don't send directly to this FD... */
else
THIS->my_fd = fd;
} else
THIS->my_fd = 0;
#ifdef USE_PIKE_LEVEL_THREADS
php_caudium_module_main(THIS);
#else
th_farm((void (*)(void *))php_caudium_module_main, THIS);
#endif
pop_n_elems(args);
}
static void free_struct(TSRMLS_D)
{
GET_THIS();
if(THIS->request_data) free_mapping(THIS->request_data);
if(THIS->my_fd_obj) free_object(THIS->my_fd_obj);
free_svalue(&THIS->done_cb);
if(THIS->filename) free_string(THIS->filename);
MEMSET(THIS, 0, sizeof(php_caudium_request));
}
/*
* pike_module_init() is called by Pike once at startup
*
* This functions allocates basic structures
*/
void pike_module_init( void )
{
if (!caudium_php_initialized) {
caudium_php_initialized = 1;
tsrm_startup(1, 1, 0, NULL);
ts_allocate_id(&caudium_globals_id, sizeof(php_caudium_request), NULL, NULL);
sapi_startup(&caudium_sapi_module);
sapi_module.startup(&caudium_sapi_module);
}
start_new_program(); /* Text */
pike_add_function("run", f_php_caudium_request_handler,
"function(string, mapping, object, function:void)", 0);
end_class("Interpreter", 0);
}
/*
* pike_module_exit() performs the last steps before the
* server exists. Shutdowns basic services and frees memory
*/
void pike_module_exit(void)
{
caudium_php_initialized = 0;
sapi_module.shutdown(&caudium_sapi_module);
tsrm_shutdown();
}
#endif

1934
win32/install.txt.orig
File diff suppressed because it is too large
View File

Write Preview
Loading…
Cancel
Save