ITypeComp *TypeComp;
int i;
int interfaces;
- ELS_FETCH();
+ TSRMLS_FETCH();
if(NULL == TypeLib)
{
/* Before registering the contsnt, let's see if we can find it */
{
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
}
j++;
}
*/
PHP_MINFO_FUNCTION(ctype)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
SLS_FETCH();
php_info_print_table_start();
php_curl *ch = (php_curl *) ctx;
php_curl_write *t = ch->handlers->write;
size_t length = size * nmemb;
- ELS_FETCH();
+ TSRMLS_FETCH();
switch (t->method) {
case PHP_CURL_STDOUT:
zval *argv[2];
zval *retval;
int error;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(argv[0]);
MAKE_STD_ZVAL(argv[1]);
php_curl *ch = (php_curl *) ctx;
php_curl_read *t = ch->handlers->read;
int length = -1;
- ELS_FETCH();
+ TSRMLS_FETCH();
switch (t->method) {
case PHP_CURL_DIRECT:
php_curl_write *t = ch->handlers->write_header;
int error;
int length;
- ELS_FETCH();
+ TSRMLS_FETCH();
switch (t->method) {
case PHP_CURL_STDOUT:
zval *retval;
int error;
int ret = 0;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(argv[0]);
MAKE_STD_ZVAL(argv[1]);
dbm_info *info;
int numitems, i;
int info_type;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (Z_TYPE_P(id) == IS_STRING) {
numitems = zend_hash_num_elements(&EG(regular_list));
#undef regcomp
#define regcomp(a,b,c) _php_regcomp(a,b,c)
-static void php_reg_init_globals(php_reg_globals *reg_globals)
+static void php_reg_init_globals(php_reg_globals *reg_globals TSRMLS_DC)
{
zend_hash_init(®_globals->ht_rc, 0, NULL, (void (*)(void *)) _free_reg_cache, 1);
}
PHP_MINIT_FUNCTION(regex)
{
#ifdef ZTS
- reg_globals_id = ts_allocate_id(sizeof(php_reg_globals), (ts_allocate_ctor) php_reg_init_globals, NULL);
+ ts_allocate_id(®_globals_id, sizeof(php_reg_globals), (ts_allocate_ctor) php_reg_init_globals, NULL);
#else
- php_reg_init_globals(®_globals);
+ php_reg_init_globals(®_globals TSRMLS_CC);
#endif
return SUCCESS;
FDFErc err;
ASInt32 nBytes;
zval *array_ptr = (zval *) arg;
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
fp=php_open_temporary_file(NULL,"fdfdata.",&filename);
for(p=value;*p;p++) if(*p=='\r') *p='\n';
if(lastfieldname) efree(lastfieldname);
lastfieldname = estrdup(name);
- php_register_variable(name, value, array_ptr ELS_CC PLS_CC);
+ php_register_variable(name, value, array_ptr TSRMLS_CC PLS_CC);
}
}
}
int laststart=0;
char emptystring[BUFFERLEN];
int i;
- ELS_FETCH();
+ TSRMLS_FETCH();
emptystring[0] = '\0';
}
#ifdef ZTS
-static void alloc_java_globals_ctor(php_java_globals *java_globals) {
+static void alloc_java_globals_ctor(php_java_globals *java_globals TSRMLS_DC) {
memset(java_globals, 0, sizeof(php_java_globals));
}
#endif
}
#ifdef ZTS
- java_globals_id = ts_allocate_id(sizeof(php_java_globals),
+ ts_allocate_id(&java_globals_id, sizeof(php_java_globals),
(ts_allocate_ctor)alloc_java_globals_ctor, NULL);
#endif
{
zval * retval;
zval * arg;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(retval);
retval->type = IS_BOOL;
mbfl_encoding_detector *identd;
mbfl_buffer_converter *convd;
MBSTRLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
mbfl_string_init(&string);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
}
if (ret != NULL) {
- php_register_variable_safe(val_list[n], ret->val, ret->len, array_ptr ELS_CC PLS_CC);
+ php_register_variable_safe(val_list[n], ret->val, ret->len, array_ptr TSRMLS_CC PLS_CC);
efree(ret->val);
} else {
- php_register_variable_safe(val_list[n], val_list[n+1], len_list[n+1], array_ptr ELS_CC PLS_CC);
+ php_register_variable_safe(val_list[n], val_list[n+1], len_list[n+1], array_ptr TSRMLS_CC PLS_CC);
}
n+=2;
}
}
/* http input processing */
-void mbstr_treat_data(int arg, char *str, zval* destArray ELS_DC PLS_DC SLS_DC)
+void mbstr_treat_data(int arg, char *str, zval* destArray TSRMLS_DC PLS_DC SLS_DC)
{
char *res = NULL, *var, *val, *separator=NULL;
const char *c_var;
}
n++;
/* add variable to symbol table */
- php_register_variable_safe(var, val, val_len, track_vars_array ELS_CC PLS_CC);
+ php_register_variable_safe(var, val, val_len, track_vars_array TSRMLS_CC PLS_CC);
mbfl_string_clear(&resvar);
mbfl_string_clear(&resval);
}
snprintf(buf, 127, "MHASH_%s", name);
zend_register_long_constant(buf, strlen(buf) + 1,
i, CONST_PERSISTENT,
- module_number ELS_CC);
+ module_number TSRMLS_CC);
free(name);
}
}
{
mssql_link *mssql_ptr = (mssql_link *)rsrc->ptr;
MSSQLLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
mssql_ptr->valid = 0;
zend_hash_apply(&EG(regular_list),(int (*)(void *))_clean_invalid_results);
/* }}} */
/* {{{ startup, shutdown and info functions */
-static void php_oci_init_globals(OCILS_D)
+static void php_oci_init_globals(OCILS_D TSRMLS_DC)
{
OCI(shutdown) = 0;
#endif
#ifdef ZTS
- oci_globals_id = ts_allocate_id(sizeof(php_oci_globals), (ts_allocate_ctor) php_oci_init_globals, NULL);
+ ts_allocate_id(&oci_globals_id, sizeof(php_oci_globals), (ts_allocate_ctor) php_oci_init_globals, NULL);
#else
- php_oci_init_globals(OCILS_C);
+ php_oci_init_globals(OCILS_C TSRMLS_CC);
#endif
le_stmt = zend_register_list_destructors_ex(_oci_stmt_list_dtor, NULL, "oci8 statement", module_number);
char *dbname;
int oldopen;
OCILS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
oldopen = server->is_open;
server->is_open = 2;
PHP_INI_END()
#ifdef ZTS
-static void php_odbc_init_globals(php_odbc_globals *odbc_globals)
+static void php_odbc_init_globals(php_odbc_globals *odbc_globals TSRMLS_DC)
{
ODBCG(num_persistent) = 0;
}
#endif
#ifdef ZTS
- odbc_globals_id = ts_allocate_id(sizeof(php_odbc_globals), php_odbc_init_globals, NULL);
+ ts_allocate_id(&odbc_globals_id, sizeof(php_odbc_globals), php_odbc_init_globals, NULL);
odbc_globals = ts_resource(odbc_globals_id);
#else
ODBCG(num_persistent) = 0;
/* {{{ php_ora_init_globals
*/
-static void php_ora_init_globals(ORALS_D)
+static void php_ora_init_globals(ORALS_D TSRMLS_DC)
{
if (cfg_get_long("oracle.allow_persistent",
&ORA(allow_persistent))
{
#ifdef ZTS
- ora_globals_id = ts_allocate_id(sizeof(php_ora_globals), (ts_allocate_ctor) php_ora_init_globals, NULL);
+ ts_allocate_id(&ora_globals_id, sizeof(php_ora_globals), (ts_allocate_ctor) php_ora_init_globals, NULL);
#else
- php_ora_init_globals(ORALS_C);
+ php_ora_init_globals(ORALS_C TSRMLS_CC);
#endif
le_cursor = zend_register_list_destructors_ex(php_close_ora_cursor, NULL, "oracle cursor", module_number);
pval **pdata;
int i, len, plen;
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_hash_internal_pointer_reset(cursor->params);
}
-static void php_pcre_shutdown_globals(php_pcre_globals *pcre_globals)
+static void php_pcre_shutdown_globals(php_pcre_globals *pcre_globals TSRMLS_DC)
{
zend_hash_destroy(&PCRE_G(pcre_cache));
}
static PHP_MINIT_FUNCTION(pcre)
{
#ifdef ZTS
- pcre_globals_id = ts_allocate_id(
- sizeof(php_pcre_globals),
- (ts_allocate_ctor) php_pcre_init_globals,
- (ts_allocate_dtor) php_pcre_shutdown_globals);
+ ts_allocate_id(
+ &pcre_globals_id,
+ sizeof(php_pcre_globals),
+ (ts_allocate_ctor) php_pcre_init_globals,
+ (ts_allocate_dtor) php_pcre_shutdown_globals);
#else
zend_hash_init(&PCRE_G(pcre_cache), 0, NULL, php_free_pcre_cache, 1);
#endif
zval *subpats; /* Captured subpatterns */
int result_len; /* Return value length */
int i;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(subpats);
array_init(subpats);
char *compiled_string_description;
smart_str code = {0};
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
eval_str_end = eval_str + eval_str_len;
walk = segment = eval_str;
compiled_string_description = zend_make_compiled_string_description("regexp code");
/* Run the code */
- if (zend_eval_string(code.c, &retval, compiled_string_description CLS_CC ELS_CC) == FAILURE) {
+ if (zend_eval_string(code.c, &retval, compiled_string_description CLS_CC TSRMLS_CC) == FAILURE) {
efree(compiled_string_description);
zend_error(E_ERROR, "Failed evaluating code:\n%s\n", code);
/* zend_error() does not return in this case */
/* {{{ php_pgsql_init_globals
*/
-static void php_pgsql_init_globals(PGLS_D)
+static void php_pgsql_init_globals(PGLS_D TSRMLS_DC)
{
PGG(num_persistent) = 0;
PGG(ignore_notices) = 0;
PHP_MINIT_FUNCTION(pgsql)
{
#ifdef ZTS
- pgsql_globals_id = ts_allocate_id(sizeof(php_pgsql_globals), (ts_allocate_ctor) php_pgsql_init_globals, NULL);
+ ts_allocate_id(&pgsql_globals_id, sizeof(php_pgsql_globals), (ts_allocate_ctor) php_pgsql_init_globals, NULL);
#else
- php_pgsql_init_globals(PGLS_C);
+ php_pgsql_init_globals(PGLS_C TSRMLS_CC);
#endif
REGISTER_INI_ENTRIES();
*/
PHP_RSHUTDOWN_FUNCTION(pgsql)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_hash_apply(&EG(persistent_list), (apply_func_t) _rollback_transactions);
return SUCCESS;
}
ITypeComp *TypeComp;
int i;
int interfaces;
- ELS_FETCH();
+ TSRMLS_FETCH();
if(NULL == TypeLib)
{
/* Before registering the contsnt, let's see if we can find it */
{
- zend_register_constant(&c ELS_CC);
+ zend_register_constant(&c TSRMLS_CC);
}
j++;
}
}
#ifdef ZTS
-static void alloc_java_globals_ctor(php_java_globals *java_globals) {
+static void alloc_java_globals_ctor(php_java_globals *java_globals TSRMLS_DC) {
memset(java_globals, 0, sizeof(php_java_globals));
}
#endif
}
#ifdef ZTS
- java_globals_id = ts_allocate_id(sizeof(php_java_globals),
+ ts_allocate_id(&java_globals_id, sizeof(php_java_globals),
(ts_allocate_ctor)alloc_java_globals_ctor, NULL);
#endif
ZEND_GET_MODULE(sablot)
#endif
-static void php_sablot_init_globals(SABLOTLS_D)
+static void php_sablot_init_globals(SABLOTLS_D TSRMLS_DC)
{
SABLOTG(processor) = NULL;
SABLOTG(errors) = NULL;
PHP_MINIT_FUNCTION(sablot)
{
#ifdef ZTS
- sablot_globals_id = ts_allocate_id(sizeof(php_sablot_globals), (ts_allocate_ctor)php_sablot_init_globals, NULL);
+ ts_allocate_id(&sablot_globals_id, sizeof(php_sablot_globals), (ts_allocate_ctor)php_sablot_init_globals, NULL);
#else
- php_sablot_init_globals(SABLOTLS_C);
+ php_sablot_init_globals(SABLOTLS_C TSRMLS_CC);
#endif
le_sablot = zend_register_list_destructors_ex(_php_sablot_free_processor, NULL, "Sablotron XSLT", module_number);
{
zval *retval;
int i;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(retval);
if (call_user_function(EG(function_table), NULL, handlerName, retval, argc, args) == FAILURE) {
if (errorHandler) {
zval *retval;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(retval);
static int _php_sablot_sh_getAll(void *userData, SablotHandle p, const char *scheme, const char *rest, char **buffer, int *byteCount)
{
php_sablot *handle = (php_sablot *) userData;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (handle->getAllHandler) {
zval *retval,
{
int i;
zval *retval = NULL;
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(retval);
if (call_user_function(EG(function_table), NULL, func, retval,
#endif
void php_set_session_var(char *name, size_t namelen, zval *state_val,HashTable *var_hash PSLS_DC);
-int php_get_session_var(char *name, size_t namelen, zval ***state_var PLS_DC PSLS_DC ELS_DC);
+int php_get_session_var(char *name, size_t namelen, zval ***state_var PLS_DC PSLS_DC TSRMLS_DC);
int php_session_register_module(ps_module *);
ulong key_length; \
ulong num_key; \
zval **struc; \
- ELS_FETCH(); \
+ TSRMLS_FETCH(); \
PLS_FETCH()
#define PS_ENCODE_LOOP(code) \
zend_hash_get_current_key_ex(&PS(vars), &key, &key_length, &num_key, 0, NULL) == HASH_KEY_IS_STRING; \
zend_hash_move_forward(&PS(vars))) { \
key_length--; \
- if (php_get_session_var(key, key_length, &struc PLS_CC PSLS_CC ELS_CC) == SUCCESS) { \
+ if (php_get_session_var(key, key_length, &struc PLS_CC PSLS_CC TSRMLS_CC) == SUCCESS) { \
code; \
} \
}
void php_set_session_var(char *name, size_t namelen, zval *state_val,HashTable *var_hash PSLS_DC)
{
PLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (PG(register_globals)) {
zval **old_symbol;
}
}
-int php_get_session_var(char *name, size_t namelen, zval ***state_var PLS_DC PSLS_DC ELS_DC)
+int php_get_session_var(char *name, size_t namelen, zval ***state_var PLS_DC PSLS_DC TSRMLS_DC)
{
HashTable *ht = &EG(symbol_table);
{
zval **old_vars = NULL;
PSLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (zend_hash_find(&EG(symbol_table), "HTTP_SESSION_VARS", sizeof("HTTP_SESSION_VARS"), (void **)&old_vars) == SUCCESS && Z_TYPE_PP(old_vars) == IS_ARRAY) {
PS(http_session_vars) = *old_vars;
int module_number = PS(module_number);
int nrand;
int lensess;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (PS(session_status) != php_session_none)
return;
#ifdef ZTS
php_ps_globals *ps_globals;
- ps_globals_id = ts_allocate_id(sizeof(php_ps_globals), NULL, NULL);
+ ts_allocate_id(&ps_globals_id, sizeof(php_ps_globals), NULL, NULL);
ps_globals = ts_resource(ps_globals_id);
#endif
PHP_MINIT_FUNCTION(array)
{
#ifdef ZTS
- array_globals_id = ts_allocate_id(sizeof(php_array_globals), NULL, NULL);
+ ts_allocate_id(&array_globals_id, sizeof(php_array_globals), NULL, NULL);
#endif
REGISTER_LONG_CONSTANT("EXTR_OVERWRITE", EXTR_OVERWRITE, CONST_CS | CONST_PERSISTENT);
Bucket *s;
pval **args[2];
pval *retval_ptr;
- ELS_FETCH();
+ TSRMLS_FETCH();
BLS_FETCH();
f = *((Bucket **) a);
pval *args[2];
pval retval;
int status;
- ELS_FETCH();
+ TSRMLS_FETCH();
BLS_FETCH();
args[0] = &key1;
ulong num_key;
HashPosition pos;
BLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
/* Allocate space for key */
MAKE_STD_ZVAL(key);
STD_PHP_INI_ENTRY("assert.quiet_eval", "0", PHP_INI_ALL, OnUpdateInt, quiet_eval, php_assert_globals, assert_globals)
PHP_INI_END()
-static void php_assert_init_globals(ASSERTLS_D)
+static void php_assert_init_globals(ASSERTLS_D TSRMLS_DC)
{
ASSERT(callback) = NULL;
}
{
#ifdef ZTS
- assert_globals_id = ts_allocate_id(sizeof(php_assert_globals), (ts_allocate_ctor) php_assert_init_globals, NULL);
+ ts_allocate_id(&assert_globals_id, sizeof(php_assert_globals), (ts_allocate_ctor) php_assert_init_globals, NULL);
#else
- php_assert_init_globals(ASSERTLS_C);
+ php_assert_init_globals(ASSERTLS_C TSRMLS_CC);
#endif
REGISTER_INI_ENTRIES();
}
compiled_string_description = zend_make_compiled_string_description("assert code");
- if (zend_eval_string(myeval, &retval, compiled_string_description CLS_CC ELS_CC) == FAILURE) {
+ if (zend_eval_string(myeval, &retval, compiled_string_description CLS_CC TSRMLS_CC) == FAILURE) {
efree(compiled_string_description);
zend_error(E_ERROR, "Failure evaluating code:\n%s\n", myeval);
/* zend_error() does not return in this case. */
zval *args[4];
zval *retval;
int i;
- uint lineno = zend_get_executed_lineno(ELS_C);
- char *filename = zend_get_executed_filename(ELS_C);
+ uint lineno = zend_get_executed_lineno(TSRMLS_C);
+ char *filename = zend_get_executed_filename(TSRMLS_C);
MAKE_STD_ZVAL(args[0]);
MAKE_STD_ZVAL(args[1]);
void test_class_startup(void);
-static void basic_globals_ctor(BLS_D)
+static void basic_globals_ctor(BLS_D TSRMLS_DC)
{
BG(next) = NULL;
BG(left) = -1;
#endif
}
-static void basic_globals_dtor(BLS_D)
+static void basic_globals_dtor(BLS_D TSRMLS_DC)
{
zend_hash_destroy(&BG(sm_protected_env_vars));
if (BG(sm_allowed_env_vars)) {
PLS_FETCH();
#ifdef ZTS
- basic_globals_id = ts_allocate_id(sizeof(php_basic_globals), (ts_allocate_ctor) basic_globals_ctor, (ts_allocate_dtor) basic_globals_dtor);
+ ts_allocate_id(&basic_globals_id, sizeof(php_basic_globals), (ts_allocate_ctor) basic_globals_ctor, (ts_allocate_dtor) basic_globals_dtor);
#else
- basic_globals_ctor(BLS_C);
+ basic_globals_ctor(BLS_C TSRMLS_CC);
#endif
REGISTER_LONG_CONSTANT("CONNECTION_ABORTED", PHP_CONNECTION_ABORTED, CONST_CS | CONST_PERSISTENT);
{
PLS_FETCH();
BLS_FETCH();
+ TSRMLS_FETCH();
- basic_globals_dtor(BLS_C);
+ basic_globals_dtor(BLS_C TSRMLS_CC);
#ifdef ZTS
ts_free_id(basic_globals_id);
static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry)
{
zval retval;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (call_user_function(EG(function_table), NULL, shutdown_function_entry->arguments[0], &retval, shutdown_function_entry->arg_count-1, shutdown_function_entry->arguments+1)==SUCCESS) {
zval_dtor(&retval);
{
zval retval;
zval *function = tick_fe->arguments[0];
- ELS_FETCH();
+ TSRMLS_FETCH();
if (call_user_function(EG(function_table), NULL, function, &retval,
tick_fe->arg_count - 1, tick_fe->arguments + 1) == SUCCESS) {
void php_call_shutdown_functions(void)
{
BLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (BG(user_shutdown_function_names)) zend_try {
zend_hash_apply(BG(user_shutdown_function_names), (apply_func_t)user_shutdown_function_call);
dir_class_entry_ptr = zend_register_internal_class(&dir_class_entry);
#ifdef ZTS
- dir_globals_id = ts_allocate_id(sizeof(php_dir_globals), NULL, NULL);
+ ts_allocate_id(&dir_globals_id, sizeof(php_dir_globals), NULL, NULL);
#endif
tmpstr[0] = DEFAULT_SLASH;
tmpstr[1] = '\0';
int error_type;
char *extension_dir;
PLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (type==MODULE_PERSISTENT) {
module_entry->type = type;
module_entry->module_number = zend_next_free_module();
if (module_entry->module_startup_func) {
- if (module_entry->module_startup_func(type, module_entry->module_number ELS_CC)==FAILURE) {
+ if (module_entry->module_startup_func(type, module_entry->module_number TSRMLS_CC)==FAILURE) {
php_error(error_type, "%s: Unable to initialize module", module_entry->name);
DL_UNLOAD(handle);
RETURN_FALSE;
zend_register_module(module_entry);
if ((type == MODULE_TEMPORARY) && module_entry->request_startup_func) {
- if (module_entry->request_startup_func(type, module_entry->module_number ELS_CC)) {
+ if (module_entry->request_startup_func(type, module_entry->module_number TSRMLS_CC)) {
php_error(error_type, "%s: Unable to initialize module", module_entry->name);
DL_UNLOAD(handle);
RETURN_FALSE;
}
-static void file_globals_ctor(FLS_D)
+static void file_globals_ctor(FLS_D TSRMLS_DC)
{
zend_hash_init(&FG(ht_fsock_keys), 0, NULL, NULL, 1);
zend_hash_init(&FG(ht_fsock_socks), 0, NULL, (void (*)(void *))php_msock_destroy, 1);
}
-static void file_globals_dtor(FLS_D)
+static void file_globals_dtor(FLS_D TSRMLS_DC)
{
zend_hash_destroy(&FG(ht_fsock_socks));
zend_hash_destroy(&FG(ht_fsock_keys));
#endif
#ifdef ZTS
- file_globals_id = ts_allocate_id(sizeof(php_file_globals), (ts_allocate_ctor) file_globals_ctor, (ts_allocate_dtor) file_globals_dtor);
+ ts_allocate_id(&file_globals_id, sizeof(php_file_globals), (ts_allocate_ctor) file_globals_ctor, (ts_allocate_dtor) file_globals_dtor);
#else
- file_globals_ctor(FLS_C);
+ file_globals_ctor(FLS_C TSRMLS_CC);
#endif
REGISTER_LONG_CONSTANT("SEEK_SET", SEEK_SET, CONST_CS | CONST_PERSISTENT);
{
#ifndef ZTS
FLS_FETCH();
+ TSRMLS_FETCH();
- file_globals_dtor(FLS_C);
+ file_globals_dtor(FLS_C TSRMLS_CC);
#endif
return SUCCESS;
}
php_url_free(resource);
if (location[0] != '\0') {
zval **response_header_new, *entry, **entryp;
- ELS_FETCH();
+ TSRMLS_FETCH();
fp = php_fopen_url_wrap_http(location, mode, options, issock, socketd, opened_path);
if (zend_hash_find(EG(active_symbol_table), "http_response_header", sizeof("http_response_header"), (void **) &response_header_new) == SUCCESS) {
*issock = 1;
out:
{
- ELS_FETCH();
+ TSRMLS_FETCH();
ZEND_SET_SYMBOL(EG(active_symbol_table), "http_response_header", response_header);
}
return (fp);
/* {{{ php_print_gpcse_array
*/
-static void php_print_gpcse_array(char *name, uint name_length ELS_DC)
+static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC)
{
zval **data, **tmp, tmp2;
char *string_key;
int expose_php = INI_INT("expose_php");
time_t the_time;
struct tm *ta, tmbuf;
- ELS_FETCH();
+ TSRMLS_FETCH();
SLS_FETCH();
the_time = time(NULL);
PUTS("</a></h1>\n");
}
- zend_ini_sort_entries(ELS_C);
+ zend_ini_sort_entries(TSRMLS_C);
if (flag & PHP_INFO_CONFIGURATION) {
php_info_print_hr();
if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_PW", sizeof("PHP_AUTH_PW"), (void **) &data) != FAILURE) {
php_info_print_table_row(2, "PHP_AUTH_PW", (*data)->value.str.val);
}
- php_print_gpcse_array("HTTP_GET_VARS", sizeof("HTTP_GET_VARS")-1 ELS_CC);
- php_print_gpcse_array("HTTP_POST_VARS", sizeof("HTTP_POST_VARS")-1 ELS_CC);
- php_print_gpcse_array("HTTP_POST_FILES", sizeof("HTTP_POST_FILES")-1 ELS_CC);
- php_print_gpcse_array("HTTP_COOKIE_VARS", sizeof("HTTP_COOKIE_VARS")-1 ELS_CC);
- php_print_gpcse_array("HTTP_SERVER_VARS", sizeof("HTTP_SERVER_VARS")-1 ELS_CC);
- php_print_gpcse_array("HTTP_ENV_VARS", sizeof("HTTP_ENV_VARS")-1 ELS_CC);
+ php_print_gpcse_array("HTTP_GET_VARS", sizeof("HTTP_GET_VARS")-1 TSRMLS_CC);
+ php_print_gpcse_array("HTTP_POST_VARS", sizeof("HTTP_POST_VARS")-1 TSRMLS_CC);
+ php_print_gpcse_array("HTTP_POST_FILES", sizeof("HTTP_POST_FILES")-1 TSRMLS_CC);
+ php_print_gpcse_array("HTTP_COOKIE_VARS", sizeof("HTTP_COOKIE_VARS")-1 TSRMLS_CC);
+ php_print_gpcse_array("HTTP_SERVER_VARS", sizeof("HTTP_SERVER_VARS")-1 TSRMLS_CC);
+ php_print_gpcse_array("HTTP_ENV_VARS", sizeof("HTTP_ENV_VARS")-1 TSRMLS_CC);
php_info_print_table_end();
}
return z * 4.656613e-10;
}
-static void lcg_init_globals(LCGLS_D)
+static void lcg_init_globals(LCGLS_D TSRMLS_DC)
{
LCG(s1) = 1;
#ifdef ZTS
#ifdef ZTS
PHP_MINIT_FUNCTION(lcg)
{
- lcg_globals_id = ts_allocate_id(sizeof(php_lcg_globals), (ts_allocate_ctor) lcg_init_globals, NULL);
+ ts_allocate_id(&lcg_globals_id, sizeof(php_lcg_globals), (ts_allocate_ctor) lcg_init_globals, NULL);
return SUCCESS;
}
#else
#undef regcomp
#define regcomp(a,b,c) _php_regcomp(a,b,c)
-static void php_reg_init_globals(php_reg_globals *reg_globals)
+static void php_reg_init_globals(php_reg_globals *reg_globals TSRMLS_DC)
{
zend_hash_init(®_globals->ht_rc, 0, NULL, (void (*)(void *)) _free_reg_cache, 1);
}
PHP_MINIT_FUNCTION(regex)
{
#ifdef ZTS
- reg_globals_id = ts_allocate_id(sizeof(php_reg_globals), (ts_allocate_ctor) php_reg_init_globals, NULL);
+ ts_allocate_id(®_globals_id, sizeof(php_reg_globals), (ts_allocate_ctor) php_reg_init_globals, NULL);
#else
- php_reg_init_globals(®_globals);
+ php_reg_init_globals(®_globals TSRMLS_CC);
#endif
return SUCCESS;
old_rg = PG(register_globals);
if(argCount == 1) {
PG(register_globals) = 1;
- php_treat_data(PARSE_STRING, res, NULL ELS_CC PLS_CC SLS_CC);
+ php_treat_data(PARSE_STRING, res, NULL TSRMLS_CC PLS_CC SLS_CC);
} else {
PG(register_globals) = 0;
/* Clear out the array that was passed in. */
zval_dtor(*arrayArg);
array_init(*arrayArg);
- php_treat_data(PARSE_STRING, res, *arrayArg ELS_CC PLS_CC SLS_CC);
+ php_treat_data(PARSE_STRING, res, *arrayArg TSRMLS_CC PLS_CC SLS_CC);
}
PG(register_globals) = old_rg;
}
*/
static void start_syslog(BLS_D)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
/* error levels */
SET_VAR_LONG("LOG_EMERG", LOG_EMERG); /* system unusable */
php_printf("%sint(%ld)\n", COMMON, Z_LVAL_PP(struc));
break;
case IS_DOUBLE: {
- ELS_FETCH();
+ TSRMLS_FETCH();
php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc));
}
return;
case IS_DOUBLE: {
- ELS_FETCH();
+ TSRMLS_FETCH();
slen = sprintf(s, "d:%.*G;",(int) EG(precision), Z_DVAL_PP(struc));
STR_CAT(buf, s, slen);
}
HashTable *myht;
zval **rval_ref;
- ELS_FETCH();
+ TSRMLS_FETCH();
BLS_FETCH();
if (var_hash && **p != 'R') { /* references aren't counted by serializer! */
static void _close_sybase_link(zend_rsrc_list_entry *rsrc)
{
sybase_link *sybase_ptr = (sybase_link *)rsrc->ptr;
- ELS_FETCH();
+ TSRMLS_FETCH();
sybase_ptr->valid = 0;
{
sybase_link *sybase_ptr = (sybase_link *)rsrc->ptr;
CS_INT con_status;
- ELS_FETCH();
+ TSRMLS_FETCH();
SybCtLS_FETCH();
sybase_ptr->valid = 0;
{
zval **val;
HashTable *target_hash;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (Z_TYPE_P(name_var) == IS_STRING)
{
zend_class_entry *ce;
zval *obj;
zval *tmp;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (stack->top == 0)
return;
#ifdef ZTS
-static void php_xml_init_globals(php_xml_globals *xml_globals)
+static void php_xml_init_globals(php_xml_globals *xml_globals TSRMLS_DC)
{
XML(default_encoding) = "ISO-8859-1";
}
le_xml_parser = zend_register_list_destructors_ex(xml_parser_dtor, NULL, "xml", module_number);
#ifdef ZTS
- xml_globals_id = ts_allocate_id(sizeof(php_xml_globals), (ts_allocate_ctor) php_xml_init_globals, NULL);
+ ts_allocate_id(&xml_globals_id, sizeof(php_xml_globals), (ts_allocate_ctor) php_xml_init_globals, NULL);
#else
XML(default_encoding) = "ISO-8859-1";
#endif
static zval *
xml_call_handler(xml_parser *parser, zval *handler, int argc, zval **argv)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
if (parser && handler) {
zval *retval;
zval ***argv; /* Argument container, maps around for call_user_function_ex() */
int error; /* Error container */
int idx; /* Idx, when looping through and free'ing the arguments */
- ELS_FETCH(); /* For TS mode, fetch the executor globals */
+ TSRMLS_FETCH(); /* For TS mode, fetch the executor globals */
/* Allocate and initialize return value from the function */
MAKE_STD_ZVAL(*retval);
PHP_MINIT_FUNCTION(yp)
{
#ifdef ZTS
- yp_globals_id = ts_allocate_id(sizeof(php_yp_globals), NULL, NULL);
+ ts_allocate_id(&yp_globals_id, sizeof(php_yp_globals), NULL, NULL);
#endif
REGISTER_LONG_CONSTANT("YPERR_BADARGS", YPERR_BADARGS, CONST_CS | CONST_PERSISTENT);
#ifdef ZTS
/* {{{ php_zlib_init_globals
*/
-static void php_zlib_init_globals(ZLIBLS_D)
+static void php_zlib_init_globals(ZLIBLS_D TSRMLS_DC)
{
ZLIBG(gzgetss_state) = 0;
}
PLS_FETCH();
#ifdef ZTS
- zlib_globals_id = ts_allocate_id(sizeof(php_zlib_globals), (ts_allocate_ctor) php_zlib_init_globals, NULL);
+ ts_allocate_id(&zlib_globals_id, sizeof(php_zlib_globals), (ts_allocate_ctor) php_zlib_init_globals, NULL);
#else
- ZLIBG(gzgetss_state)=0;
+ ZLIBG(gzgetss_state)=0;
#endif
le_zp = zend_register_list_destructors_ex(phpi_destructor_gzclose, NULL, "zlib", module_number);
int php_enable_output_compression(int buffer_size)
{
zval **a_encoding, **data;
- ELS_FETCH();
+ TSRMLS_FETCH();
ZLIBLS_FETCH();
if (zend_hash_find(&EG(symbol_table), "HTTP_SERVER_VARS", sizeof("HTTP_SERVER_VARS"), (void **) &data)==FAILURE
sapi_globals_struct sapi_globals;
#endif
-static void sapi_globals_ctor(sapi_globals_struct *sapi_globals)
+static void sapi_globals_ctor(sapi_globals_struct *sapi_globals TSRMLS_DC)
{
memset(sapi_globals,0,sizeof(*sapi_globals));
}
zend_hash_init_ex(&known_post_content_types, 5, NULL, NULL, 1, 0);
#ifdef ZTS
- sapi_globals_id = ts_allocate_id(sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, NULL);
+ ts_allocate_id(&sapi_globals_id, sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, NULL);
#else
- sapi_globals_ctor(&sapi_globals);
+ sapi_globals_ctor(&sapi_globals TSRMLS_CC);
#endif
#ifdef VIRTUAL_DIR
int (*read_post)(char *buffer, uint count_bytes SLS_DC);
char *(*read_cookies)(SLS_D);
- void (*register_server_variables)(zval *track_vars_array ELS_DC SLS_DC PLS_DC);
+ void (*register_server_variables)(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC);
void (*log_message)(char *message);
char *php_ini_path_override;
int safe_mode_include_dir_length;
int exec_fname_length;
PLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
if (opened_path) {
*opened_path = NULL;
* as a fall back case
*/
if (zend_is_executing()) {
- exec_fname = zend_get_executed_filename(ELS_C);
+ exec_fname = zend_get_executed_filename(TSRMLS_C);
exec_fname_length = strlen(exec_fname);
path_length = strlen(path);
PHPAPI int core_globals_id;
#endif
-static void php_build_argv(char *s, zval *track_vars_array ELS_DC PLS_DC);
+static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC PLS_DC);
#define SAFE_FILENAME(f) ((f)?(f):"-")
*/
static PHP_INI_MH(OnSetPrecision)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
EG(precision) = atoi(new_value);
return SUCCESS;
*/
static PHP_INI_MH(OnUpdateErrorReporting)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
if (!new_value) {
EG(error_reporting) = E_ALL & ~E_NOTICE;
*/
static PHP_INI_MH(OnUpdateTimeout)
{
- ELS_FETCH();
+ TSRMLS_FETCH();
EG(timeout_seconds) = atoi(new_value);
if (stage==PHP_INI_STAGE_STARTUP) {
{
char buffer[1024];
int buffer_len;
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
buffer_len = vsnprintf(buffer, sizeof(buffer)-1, format, args);
break;
case ZMSG_MEMORY_LEAK_DETECTED:
case ZMSG_MEMORY_LEAK_REPEATED: {
- ELS_FETCH();
+ TSRMLS_FETCH();
if (EG(error_reporting)&E_WARNING) {
#if ZEND_DEBUG
/* }}} */
#endif
-static int php_hash_environment(ELS_D SLS_DC PLS_DC);
+static int php_hash_environment(TSRMLS_D SLS_DC PLS_DC);
/* {{{ php_request_startup
*/
-int php_request_startup(CLS_D ELS_DC PLS_DC SLS_DC)
+int php_request_startup(CLS_D TSRMLS_DC PLS_DC SLS_DC)
{
int retval = SUCCESS;
PG(header_is_being_sent) = 0;
PG(connection_status) = PHP_CONNECTION_NORMAL;
- zend_activate(CLS_C ELS_CC);
+ zend_activate(CLS_C TSRMLS_CC);
sapi_activate(SLS_C);
zend_set_timeout(EG(timeout_seconds));
/* We turn this off in php_execute_script() */
/* PG(during_request_startup) = 0; */
- php_hash_environment(ELS_C SLS_CC PLS_CC);
+ php_hash_environment(TSRMLS_C SLS_CC PLS_CC);
zend_activate_modules();
PG(modules_activated)=1;
} zend_catch {
void php_request_shutdown(void *dummy)
{
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
SLS_FETCH();
PLS_FETCH();
+ return;
+
zend_try {
php_end_ob_buffers((zend_bool)(SG(request_info).headers_only?0:1));
} zend_end_try();
zend_deactivate_modules();
}
- zend_deactivate(CLS_C ELS_CC);
+ zend_deactivate(CLS_C TSRMLS_CC);
zend_try {
sapi_deactivate(SLS_C);
#ifdef ZTS
/* {{{ core_globals_ctor
*/
-static void core_globals_ctor(php_core_globals *core_globals)
+static void core_globals_ctor(php_core_globals *core_globals TSRMLS_DC)
{
memset(core_globals,0,sizeof(*core_globals));
}
char *php_os;
#ifdef ZTS
zend_executor_globals *executor_globals;
+ void ***tsrm_ls;
php_core_globals *core_globals;
sapi_globals_struct *sapi_globals = ts_resource(sapi_globals_id);
#endif
#ifdef ZTS
executor_globals = ts_resource(executor_globals_id);
- core_globals_id = ts_allocate_id(sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, NULL);
+ tsrm_ls = ts_resource(0);
+ ts_allocate_id(&core_globals_id, sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, NULL);
core_globals = ts_resource(core_globals_id);
#endif
EG(bailout_set) = 0;
int module_number=0; /* for UNREGISTER_INI_ENTRIES() */
PLS_FETCH();
+ return;
if (!module_initialized) {
return;
}
php_shutdown_info_logos();
UNREGISTER_INI_ENTRIES();
#ifndef ZTS
- zend_ini_shutdown(ELS_C);
+ zend_ini_shutdown(TSRMLS_C);
#endif
shutdown_memory_manager(0, 1);
module_initialized = 0;
/* {{{ php_register_server_variables
*/
-static inline void php_register_server_variables(ELS_D SLS_DC PLS_DC)
+static inline void php_register_server_variables(TSRMLS_D SLS_DC PLS_DC)
{
zval *array_ptr=NULL;
/* Server variables */
if (sapi_module.register_server_variables) {
- sapi_module.register_server_variables(array_ptr ELS_CC SLS_CC PLS_CC);
+ sapi_module.register_server_variables(array_ptr TSRMLS_CC SLS_CC PLS_CC);
}
/* argv/argc support */
if (PG(register_argc_argv)) {
- php_build_argv(SG(request_info).query_string, array_ptr ELS_CC PLS_CC);
+ php_build_argv(SG(request_info).query_string, array_ptr TSRMLS_CC PLS_CC);
}
/* PHP Authentication support */
if (SG(request_info).auth_user) {
- php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, array_ptr ELS_CC PLS_CC);
+ php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, array_ptr TSRMLS_CC PLS_CC);
}
if (SG(request_info).auth_password) {
- php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, array_ptr ELS_CC PLS_CC);
+ php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, array_ptr TSRMLS_CC PLS_CC);
}
}
/* }}} */
/* {{{ php_hash_environment
*/
-static int php_hash_environment(ELS_D SLS_DC PLS_DC)
+static int php_hash_environment(TSRMLS_D SLS_DC PLS_DC)
{
char *p;
unsigned char _gpc_flags[3] = {0,0,0};
ALLOC_ZVAL(PG(http_globals)[TRACK_VARS_ENV]);
array_init(PG(http_globals)[TRACK_VARS_ENV]);
INIT_PZVAL(PG(http_globals)[TRACK_VARS_ENV]);
- php_import_environment_variables(PG(http_globals)[TRACK_VARS_ENV] ELS_CC PLS_CC);
+ php_import_environment_variables(PG(http_globals)[TRACK_VARS_ENV] TSRMLS_CC PLS_CC);
}
while(p && *p) {
case 'p':
case 'P':
if (!_gpc_flags[0] && !SG(headers_sent) && SG(request_info).request_method && !strcasecmp(SG(request_info).request_method, "POST")) {
- php_treat_data(PARSE_POST, NULL, NULL ELS_CC PLS_CC SLS_CC); /* POST Data */
+ php_treat_data(PARSE_POST, NULL, NULL TSRMLS_CC PLS_CC SLS_CC); /* POST Data */
_gpc_flags[0]=1;
}
break;
case 'c':
case 'C':
if (!_gpc_flags[1]) {
- php_treat_data(PARSE_COOKIE, NULL, NULL ELS_CC PLS_CC SLS_CC); /* Cookie Data */
+ php_treat_data(PARSE_COOKIE, NULL, NULL TSRMLS_CC PLS_CC SLS_CC); /* Cookie Data */
_gpc_flags[1]=1;
}
break;
case 'g':
case 'G':
if (!_gpc_flags[2]) {
- php_treat_data(PARSE_GET, NULL, NULL ELS_CC PLS_CC SLS_CC); /* GET Data */
+ php_treat_data(PARSE_GET, NULL, NULL TSRMLS_CC PLS_CC SLS_CC); /* GET Data */
_gpc_flags[2]=1;
}
break;
ALLOC_ZVAL(PG(http_globals)[TRACK_VARS_ENV]);
array_init(PG(http_globals)[TRACK_VARS_ENV]);
INIT_PZVAL(PG(http_globals)[TRACK_VARS_ENV]);
- php_import_environment_variables(PG(http_globals)[TRACK_VARS_ENV] ELS_CC PLS_CC);
+ php_import_environment_variables(PG(http_globals)[TRACK_VARS_ENV] TSRMLS_CC PLS_CC);
} else {
php_error(E_WARNING, "Unsupported 'e' element (environment) used in gpc_order - use variables_order instead");
}
break;
case 's':
case 'S':
- php_register_server_variables(ELS_C SLS_CC PLS_CC);
+ php_register_server_variables(TSRMLS_C SLS_CC PLS_CC);
break;
}
}
if (!have_variables_order) {
- php_register_server_variables(ELS_C SLS_CC PLS_CC);
+ php_register_server_variables(TSRMLS_C SLS_CC PLS_CC);
}
for (i=0; i<6; i++) {
/* {{{ php_build_argv
*/
-static void php_build_argv(char *s, zval *track_vars_array ELS_DC PLS_DC)
+static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC PLS_DC)
{
pval *arr, *argc, *tmp;
int count = 0;
/* {{{ php_execute_script
*/
-PHPAPI int php_execute_script(zend_file_handle *primary_file CLS_DC ELS_DC PLS_DC)
+PHPAPI int php_execute_script(zend_file_handle *primary_file CLS_DC TSRMLS_DC PLS_DC)
{
zend_file_handle *prepend_file_p, *append_file_p;
zend_file_handle prepend_file, append_file;
} else {
append_file_p = NULL;
}
- zend_execute_scripts(ZEND_REQUIRE CLS_CC ELS_CC, 3, prepend_file_p, primary_file, append_file_p);
+ zend_execute_scripts(ZEND_REQUIRE CLS_CC TSRMLS_CC, 3, prepend_file_p, primary_file, append_file_p);
} zend_end_try();
if (old_cwd[0] != '\0') {
/* {{{ php_lint_script
*/
-PHPAPI int php_lint_script(zend_file_handle *file CLS_DC ELS_DC PLS_DC)
+PHPAPI int php_lint_script(zend_file_handle *file CLS_DC TSRMLS_DC PLS_DC)
{
zend_op_array *op_array;
}
-static void php_output_init_globals(OLS_D)
+static void php_output_init_globals(OLS_D TSRMLS_DC)
{
OG(php_body_write) = php_default_output_func;
OG(php_header_write) = php_default_output_func;
PHPAPI void php_output_startup(void)
{
#ifdef ZTS
- output_globals_id = ts_allocate_id(sizeof(php_output_globals), (ts_allocate_ctor) php_output_init_globals, NULL);
+ ts_allocate_id(&output_globals_id, sizeof(php_output_globals), (ts_allocate_ctor) php_output_init_globals, NULL);
#else
- php_output_init_globals(OLS_C);
+ php_output_init_globals(OLS_C TSRMLS_CC);
#endif
}
void php_output_register_constants()
{
- ELS_FETCH();
+ TSRMLS_FETCH();
REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_START", PHP_OUTPUT_HANDLER_START, CONST_CS | CONST_PERSISTENT);
REGISTER_MAIN_LONG_CONSTANT("PHP_OUTPUT_HANDLER_CONT", PHP_OUTPUT_HANDLER_CONT, CONST_CS | CONST_PERSISTENT);
OG(output_start_filename) = zend_get_compiled_filename(CLS_C);
OG(output_start_lineno) = zend_get_compiled_lineno(CLS_C);
} else if (zend_is_executing()) {
- ELS_FETCH();
+ TSRMLS_FETCH();
- OG(output_start_filename) = zend_get_executed_filename(ELS_C);
- OG(output_start_lineno) = zend_get_executed_lineno(ELS_C);
+ OG(output_start_filename) = zend_get_executed_filename(TSRMLS_C);
+ OG(output_start_lineno) = zend_get_executed_lineno(TSRMLS_C);
}
OG(php_body_write) = php_ub_body_write_no_header;
SAPI_POST_READER_FUNC(php_default_post_reader)
{
char *data;
- ELS_FETCH();
+ TSRMLS_FETCH();
if(!SG(request_info).post_data) sapi_read_standard_form_data(SLS_C);
data = estrndup(SG(request_info).post_data,SG(request_info).post_data_length);
PHPAPI void display_ini_entries(zend_module_entry *module)
{
int module_number;
- ELS_FETCH();
+ TSRMLS_FETCH();
if (module) {
module_number = module->module_number;
#include "php_globals.h"
#include "SAPI.h"
-PHPAPI int php_request_startup(CLS_D ELS_DC PLS_DC SLS_DC);
+PHPAPI int php_request_startup(CLS_D TSRMLS_DC PLS_DC SLS_DC);
PHPAPI void php_request_shutdown(void *dummy);
PHPAPI void php_request_shutdown_for_exec(void *dummy);
PHPAPI int php_module_startup(sapi_module_struct *sf);
PHPAPI int php_startup_extensions(zend_module_entry **ptr, int count);
-PHPAPI int php_execute_script(zend_file_handle *primary_file CLS_DC ELS_DC PLS_DC);
+PHPAPI int php_execute_script(zend_file_handle *primary_file CLS_DC TSRMLS_DC PLS_DC);
PHPAPI int php_handle_special_queries(SLS_D PLS_DC);
-PHPAPI int php_lint_script(zend_file_handle *file CLS_DC ELS_DC PLS_DC);
+PHPAPI int php_lint_script(zend_file_handle *file CLS_DC TSRMLS_DC PLS_DC);
PHPAPI void php_handle_aborted_connection(void);
PHPAPI int php_handle_auth_data(const char *auth SLS_DC);
#include "zend_globals.h"
-PHPAPI void php_register_variable(char *var, char *strval, zval *track_vars_array ELS_DC PLS_DC) {
- php_register_variable_safe(var, strval, strlen(strval), track_vars_array ELS_CC PLS_CC);
+PHPAPI void php_register_variable(char *var, char *strval, zval *track_vars_array TSRMLS_DC PLS_DC)
+{
+ php_register_variable_safe(var, strval, strlen(strval), track_vars_array TSRMLS_CC PLS_CC);
}
/* binary-safe version */
-PHPAPI void php_register_variable_safe(char *var, char *strval, int str_len, zval *track_vars_array ELS_DC PLS_DC)
+PHPAPI void php_register_variable_safe(char *var, char *strval, int str_len, zval *track_vars_array TSRMLS_DC PLS_DC)
{
zval new_entry;
}
new_entry.type = IS_STRING;
- php_register_variable_ex(var, &new_entry, track_vars_array ELS_CC PLS_CC);
+ php_register_variable_ex(var, &new_entry, track_vars_array TSRMLS_CC PLS_CC);
}
-PHPAPI void php_register_variable_ex(char *var, zval *val, pval *track_vars_array ELS_DC PLS_DC)
+PHPAPI void php_register_variable_ex(char *var, zval *val, pval *track_vars_array TSRMLS_DC PLS_DC)
{
char *p = NULL;
char *ip; /* index pointer */
char *var, *val;
char *strtok_buf = NULL;
zval *array_ptr = (zval *) arg;
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
var = php_strtok_r(SG(request_info).post_data, "&", &strtok_buf);
*val++ = '\0';
php_url_decode(var, strlen(var));
val_len = php_url_decode(val, strlen(val));
- php_register_variable_safe(var, val, val_len, array_ptr ELS_CC PLS_CC);
+ php_register_variable_safe(var, val, val_len, array_ptr TSRMLS_CC PLS_CC);
}
var = php_strtok_r(NULL, "&", &strtok_buf);
}
}
-void php_treat_data(int arg, char *str, zval* destArray ELS_DC PLS_DC SLS_DC)
+void php_treat_data(int arg, char *str, zval* destArray TSRMLS_DC PLS_DC SLS_DC)
{
char *res = NULL, *var, *val, *separator=NULL;
const char *c_var;
*val++ = '\0';
php_url_decode(var, strlen(var));
val_len = php_url_decode(val, strlen(val));
- php_register_variable_safe(var, val, val_len, array_ptr ELS_CC PLS_CC);
+ php_register_variable_safe(var, val, val_len, array_ptr TSRMLS_CC PLS_CC);
}
var = php_strtok_r(NULL, separator, &strtok_buf);
}
}
-void php_import_environment_variables(zval *array_ptr ELS_DC PLS_DC)
+void php_import_environment_variables(zval *array_ptr TSRMLS_DC PLS_DC)
{
char **env, *p, *t;
continue;
}
t = estrndup(*env, p - *env);
- php_register_variable(t, p+1, array_ptr ELS_CC PLS_CC);
+ php_register_variable(t, p+1, array_ptr TSRMLS_CC PLS_CC);
efree(t);
}
}
#define PARSE_COOKIE 2
#define PARSE_STRING 3
-void php_treat_data(int arg, char *str, zval* destArray ELS_DC PLS_DC SLS_DC);
-PHPAPI void php_import_environment_variables(zval *array_ptr ELS_DC PLS_DC);
-PHPAPI void php_register_variable(char *var, char *val, pval *track_vars_array ELS_DC PLS_DC);
+void php_treat_data(int arg, char *str, zval* destArray TSRMLS_DC PLS_DC SLS_DC);
+PHPAPI void php_import_environment_variables(zval *array_ptr TSRMLS_DC PLS_DC);
+PHPAPI void php_register_variable(char *var, char *val, pval *track_vars_array TSRMLS_DC PLS_DC);
/* binary-safe version */
-PHPAPI void php_register_variable_safe(char *var, char *val, int val_len, pval *track_vars_array ELS_DC PLS_DC);
-PHPAPI void php_register_variable_ex(char *var, zval *val, pval *track_vars_array ELS_DC PLS_DC);
+PHPAPI void php_register_variable_safe(char *var, char *val, int val_len, pval *track_vars_array TSRMLS_DC PLS_DC);
+PHPAPI void php_register_variable_ex(char *var, zval *val, pval *track_vars_array TSRMLS_DC PLS_DC);
#endif /* PHP_VARIABLES_H */
}
-static void safe_php_register_variable(char *var, char *strval, zval *track_vars_array, zend_bool override_protection ELS_DC PLS_DC)
+static void safe_php_register_variable(char *var, char *strval, zval *track_vars_array, zend_bool override_protection TSRMLS_DC PLS_DC)
{
if (override_protection || !is_protected_variable(var PLS_CC)) {
- php_register_variable(var, strval, track_vars_array ELS_CC PLS_CC);
+ php_register_variable(var, strval, track_vars_array TSRMLS_CC PLS_CC);
}
}
-static void safe_php_register_variable_ex(char *var, zval *val, pval *track_vars_array, zend_bool override_protection ELS_DC PLS_DC)
+static void safe_php_register_variable_ex(char *var, zval *val, pval *track_vars_array, zend_bool override_protection TSRMLS_DC PLS_DC)
{
if (override_protection || !is_protected_variable(var PLS_CC)) {
- php_register_variable_ex(var, val, track_vars_array ELS_CC PLS_CC);
+ php_register_variable_ex(var, val, track_vars_array TSRMLS_CC PLS_CC);
}
}
-static void register_http_post_files_variable(char *strvar, char *val, zval *http_post_files, zend_bool override_protection ELS_DC PLS_DC)
+static void register_http_post_files_variable(char *strvar, char *val, zval *http_post_files, zend_bool override_protection TSRMLS_DC PLS_DC)
{
int register_globals = PG(register_globals);
PG(register_globals) = 0;
- safe_php_register_variable(strvar, val, http_post_files, override_protection ELS_CC PLS_CC);
+ safe_php_register_variable(strvar, val, http_post_files, override_protection TSRMLS_CC PLS_CC);
PG(register_globals) = register_globals;
}
-static void register_http_post_files_variable_ex(char *var, zval *val, zval *http_post_files, zend_bool override_protection ELS_DC PLS_DC)
+static void register_http_post_files_variable_ex(char *var, zval *val, zval *http_post_files, zend_bool override_protection TSRMLS_DC PLS_DC)
{
int register_globals = PG(register_globals);
PG(register_globals) = 0;
- safe_php_register_variable_ex(var, val, http_post_files, override_protection ELS_CC PLS_CC);
+ safe_php_register_variable_ex(var, val, http_post_files, override_protection TSRMLS_CC PLS_CC);
PG(register_globals) = register_globals;
}
zval *http_post_files=NULL;
zend_bool upload_successful;
zend_bool magic_quotes_gpc;
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_hash_init(&PG(rfc1867_protected_variables), 5, NULL, NULL, 0);
}
s = strrchr(filenamebuf, '\\');
if (s && s > filenamebuf) {
- safe_php_register_variable(lbuf, s+1, NULL, 0 ELS_CC PLS_CC);
+ safe_php_register_variable(lbuf, s+1, NULL, 0 TSRMLS_CC PLS_CC);
} else {
- safe_php_register_variable(lbuf, filenamebuf, NULL, 0 ELS_CC PLS_CC);
+ safe_php_register_variable(lbuf, filenamebuf, NULL, 0 TSRMLS_CC PLS_CC);
}
/* Add $foo[name] */
sprintf(lbuf, "%s[name]", namebuf);
}
if (s && s > filenamebuf) {
- register_http_post_files_variable(lbuf, s+1, http_post_files, 0 ELS_CC PLS_CC);
+ register_http_post_files_variable(lbuf, s+1, http_post_files, 0 TSRMLS_CC PLS_CC);
} else {
- register_http_post_files_variable(lbuf, filenamebuf, http_post_files, 0 ELS_CC PLS_CC);
+ register_http_post_files_variable(lbuf, filenamebuf, http_post_files, 0 TSRMLS_CC PLS_CC);
}
state = 3;
} else {
sprintf(lbuf, "%s_type", namebuf);
}
- safe_php_register_variable(lbuf, s, NULL, 0 ELS_CC PLS_CC);
+ safe_php_register_variable(lbuf, s, NULL, 0 TSRMLS_CC PLS_CC);
/* Add $foo[type] */
if (is_arr_upload) {
} else {
sprintf(lbuf, "%s[type]", namebuf);
}
- register_http_post_files_variable(lbuf, s, http_post_files, 0 ELS_CC PLS_CC);
+ register_http_post_files_variable(lbuf, s, http_post_files, 0 TSRMLS_CC PLS_CC);
if(*s != '\0') {
*(loc2 - 1) = '\n';
}
/* Check to make sure we are not overwriting special file
* upload variables */
- safe_php_register_variable(namebuf, ptr, array_ptr, 0 ELS_CC PLS_CC);
+ safe_php_register_variable(namebuf, ptr, array_ptr, 0 TSRMLS_CC PLS_CC);
/* And a little kludge to pick out special MAX_FILE_SIZE */
itype = php_check_ident_type(namebuf);
magic_quotes_gpc = PG(magic_quotes_gpc);
PG(magic_quotes_gpc) = 0;
- safe_php_register_variable(namebuf, temp_filename, NULL, 1 ELS_CC PLS_CC);
+ safe_php_register_variable(namebuf, temp_filename, NULL, 1 TSRMLS_CC PLS_CC);
/* Add $foo[tmp_name] */
if(is_arr_upload) {
sprintf(lbuf, "%s[tmp_name][%s]", abuf, arr_index);
sprintf(lbuf, "%s[tmp_name]", namebuf);
}
add_protected_variable(lbuf PLS_CC);
- register_http_post_files_variable(lbuf, temp_filename, http_post_files, 1 ELS_CC PLS_CC);
+ register_http_post_files_variable(lbuf, temp_filename, http_post_files, 1 TSRMLS_CC PLS_CC);
PG(magic_quotes_gpc) = magic_quotes_gpc;
{
} else {
sprintf(lbuf, "%s_size", namebuf);
}
- safe_php_register_variable_ex(lbuf, &file_size, NULL, 0 ELS_CC PLS_CC);
+ safe_php_register_variable_ex(lbuf, &file_size, NULL, 0 TSRMLS_CC PLS_CC);
/* Add $foo[size] */
if(is_arr_upload) {
} else {
sprintf(lbuf, "%s[size]", namebuf);
}
- register_http_post_files_variable_ex(lbuf, &file_size, http_post_files, 0 ELS_CC PLS_CC);
+ register_http_post_files_variable_ex(lbuf, &file_size, http_post_files, 0 TSRMLS_CC PLS_CC);
}
state = 0;
rem -= (loc - ptr);
*/
#define ADD_STRINGX(name,buf) \
- php_register_variable(name, buf, track_vars_array ELS_CC PLS_CC)
+ php_register_variable(name, buf, track_vars_array TSRMLS_CC PLS_CC)
#define ADD_STRING(name) \
ADD_STRINGX(name, buf)
static void
-php_ns_sapi_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+php_ns_sapi_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
int i;
char buf[NS_BUF_SIZE + 1];
{
zend_file_handle file_handle;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.opened_path = NULL;
php_ns_config(global_context, 0);
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == FAILURE) {
return NS_ERROR;
}
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
return NS_OK;
sapi_module.startup(&aolserver_sapi_module);
/* TSRM is used to allocate a per-thread structure */
- ns_globals_id = ts_allocate_id(sizeof(ns_globals_struct), NULL, NULL);
+ ts_allocate_id(&ns_globals_id, sizeof(ns_globals_struct), NULL, NULL);
/* the context contains data valid for all threads */
ctx = malloc(sizeof *ctx);
/* {{{ Prototypes
*/
-int apache_php_module_main(request_rec *r, int display_source_mode CLS_DC ELS_DC PLS_DC SLS_DC);
+int apache_php_module_main(request_rec *r, int display_source_mode CLS_DC TSRMLS_DC PLS_DC SLS_DC);
void php_save_umask(void);
void php_restore_umask(void);
int sapi_apache_read_post(char *buffer, uint count_bytes SLS_DC);
/* {{{ sapi_apache_register_server_variables
*/
-static void sapi_apache_register_server_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_apache_register_server_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
register int i;
array_header *arr = table_elts(((request_rec *) SG(server_context))->subprocess_env);
} else {
val = empty_string;
}
- php_register_variable(elts[i].key, val, track_vars_array ELS_CC PLS_CC);
+ php_register_variable(elts[i].key, val, track_vars_array TSRMLS_CC PLS_CC);
}
/* If PATH_TRANSLATED doesn't exist, copy it from SCRIPT_FILENAME */
if (symbol_table
&& !zend_hash_exists(symbol_table, "PATH_TRANSLATED", sizeof("PATH_TRANSLATED"))
&& zend_hash_find(symbol_table, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME"), (void **) &path_translated)==SUCCESS) {
- php_register_variable("PATH_TRANSLATED", Z_STRVAL_PP(path_translated), track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PATH_TRANSLATED", Z_STRVAL_PP(path_translated), track_vars_array TSRMLS_CC PLS_CC);
}
- php_register_variable("PHP_SELF", ((request_rec *) SG(server_context))->uri, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PHP_SELF", ((request_rec *) SG(server_context))->uri, track_vars_array TSRMLS_CC PLS_CC);
}
/* }}} */
int retval;
HashTable *per_dir_conf;
SLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
CLS_FETCH();
PLS_FETCH();
APLS_FETCH();
fh.opened_path = NULL;
fh.free_filename = 0;
fh.type = ZEND_HANDLE_FILENAME;
- zend_execute_scripts(ZEND_INCLUDE CLS_CC ELS_CC, 1, &fh);
+ zend_execute_scripts(ZEND_INCLUDE CLS_CC TSRMLS_CC, 1, &fh);
return OK;
}
r->content_type = php_apache_get_default_mimetype(r SLS_CC);
r->allowed |= (1 << METHODS) - 1;
zend_try {
- zend_ini_deactivate(ELS_C);
+ zend_ini_deactivate(TSRMLS_C);
} zend_end_try();
return DECLINED;
}
#if MODULE_MAGIC_NUMBER > 19961007
if ((retval = setup_client_block(r, REQUEST_CHUNKED_ERROR))) {
zend_try {
- zend_ini_deactivate(ELS_C);
+ zend_ini_deactivate(TSRMLS_C);
} zend_end_try();
return retval;
}
#if MODULE_MAGIC_NUMBER < 19970912
if ((retval = set_last_modified(r, r->finfo.st_mtime))) {
zend_try {
- zend_ini_deactivate(ELS_C);
+ zend_ini_deactivate(TSRMLS_C);
} zend_end_try();
return retval;
}
add_cgi_vars(r);
init_request_info(SLS_C);
- apache_php_module_main(r, display_source_mode CLS_CC ELS_CC PLS_CC SLS_CC);
+ apache_php_module_main(r, display_source_mode CLS_CC TSRMLS_CC PLS_CC SLS_CC);
/* Done, restore umask, turn off timeout, close file and return */
php_restore_umask();
-static void php_apache_globals_ctor(php_apache_info_struct *apache_globals)
+static void php_apache_globals_ctor(php_apache_info_struct *apache_globals TSRMLS_DC)
{
apache_globals->in_request = 0;
}
static PHP_MINIT_FUNCTION(apache)
{
#ifdef ZTS
- php_apache_info_id = ts_allocate_id(sizeof(php_apache_info_struct), php_apache_globals_ctor, NULL);
+ ts_allocate_id(&php_apache_info_id, sizeof(php_apache_info_struct), php_apache_globals_ctor, NULL);
#else
- php_apache_globals_ctor(&php_apache_info);
+ php_apache_globals_ctor(&php_apache_info TSRMLS_CC);
#endif
REGISTER_INI_ENTRIES();
return SUCCESS;
/* {{{ apache_php_module_main
*/
-int apache_php_module_main(request_rec *r, int display_source_mode CLS_DC ELS_DC PLS_DC SLS_DC)
+int apache_php_module_main(request_rec *r, int display_source_mode CLS_DC TSRMLS_DC PLS_DC SLS_DC)
{
zend_file_handle file_handle;
APLS_FETCH();
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == FAILURE) {
return FAILURE;
}
/* sending a file handle to another dll is not working
file_handle.opened_path = NULL;
file_handle.free_filename = 0;
- (void) php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ (void) php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
}
AP(in_request) = 0;
}
static void
-php_apache_sapi_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+php_apache_sapi_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
php_struct *ctx = SG(server_context);
apr_array_header_t *arr = apr_table_elts(ctx->f->r->subprocess_env);
APR_ARRAY_FOREACH_OPEN(arr, key, val)
if (!val) val = empty_string;
- php_register_variable(key, val, track_vars_array ELS_CC PLS_CC);
+ php_register_variable(key, val, track_vars_array TSRMLS_CC PLS_CC);
APR_ARRAY_FOREACH_CLOSE()
- php_register_variable("PHP_SELF", ctx->f->r->uri, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PHP_SELF", ctx->f->r->uri, track_vars_array TSRMLS_CC PLS_CC);
}
static void
char *content_type;
const char *auth;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
PG(during_request_startup) = 0;
auth = apr_table_get(f->r->headers_in, "Authorization");
php_handle_auth_data(auth SLS_CC);
- php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC);
+ php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC);
}
static void php_apache_request_dtor(ap_filter_t *f SLS_DC)
zend_file_handle zfd;
apr_bucket *eos;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
/* We want to execute only one script per request.
zfd.free_filename = 0;
zfd.opened_path = NULL;
- php_execute_script(&zfd CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&zfd CLS_CC TSRMLS_CC PLS_CC);
} else {
#define NO_DATA "The PHP Filter did not receive suitable input data"
};
-INLINE static void low_sapi_caudium_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+INLINE static void low_sapi_caudium_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
char *tmp;
php_register_variable("PHP_SELF", SG(request_info).request_uri,
- track_vars_array ELS_CC PLS_CC);
+ track_vars_array TSRMLS_CC PLS_CC);
php_register_variable("GATEWAY_INTERFACE", "CGI/1.1",
- track_vars_array ELS_CC PLS_CC);
+ track_vars_array TSRMLS_CC PLS_CC);
php_register_variable("REQUEST_METHOD",
(char *) SG(request_info).request_method,
- track_vars_array ELS_CC PLS_CC);
+ track_vars_array TSRMLS_CC PLS_CC);
php_register_variable("REQUEST_URI", SG(request_info).request_uri,
- track_vars_array ELS_CC PLS_CC);
+ track_vars_array TSRMLS_CC PLS_CC);
php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated,
- track_vars_array ELS_CC PLS_CC);
+ track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("SERVER_NAME", NULL)) != NULL)
- php_register_variable("SERVER_NAME", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("SERVER_NAME", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("SERVER_PORT", NULL)) != NULL)
- php_register_variable("SERVER_PORT", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("SERVER_PORT", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("SERVER_PROTOCOL", NULL)) != NULL)
- php_register_variable("SERVER_PROTOCOL", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("SERVER_PROTOCOL", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("SCRIPT_NAME", NULL)) != NULL)
- php_register_variable("SCRIPT_NAME", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("SCRIPT_NAME", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("SCRIPT_FILENAME", NULL)) != NULL)
- php_register_variable("SCRIPT_FILENAME", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("SCRIPT_FILENAME", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("REMOTE_ADDR", NULL)) != NULL)
- php_register_variable("REMOTE_ADDR", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("REMOTE_ADDR", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("REMOTE_PORT", NULL)) != NULL)
- php_register_variable("REMOTE_PORT", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("REMOTE_PORT", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("DOCUMENT_ROOT", NULL)) != NULL)
- php_register_variable("DOCUMENT_ROOT", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("DOCUMENT_ROOT", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("HTTP_CONNECTION", NULL)) != NULL)
- php_register_variable("HTTP_CONNECTION", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("HTTP_CONNECTION", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("HTTP_USER_AGENT", NULL)) != NULL)
- php_register_variable("HTTP_USER_AGENT", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("HTTP_USER_AGENT", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("DOCUMENT_ROOT", NULL)) != NULL)
- php_register_variable("DOCUMENT_ROOT", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("DOCUMENT_ROOT", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("QUERY_STRING", "")) != NULL)
- php_register_variable("QUERY_STRING", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("QUERY_STRING", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("REMOTE_USER", NULL)) != NULL)
- php_register_variable("REMOTE_USER", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("REMOTE_USER", tmp, track_vars_array TSRMLS_CC PLS_CC);
if( (tmp = lookup_string_header("REMOTE_PASSWORD", NULL)) != NULL)
- php_register_variable("REMOTE_PASSWORD", tmp, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("REMOTE_PASSWORD", tmp, track_vars_array TSRMLS_CC PLS_CC);
}
-static void sapi_caudium_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_caudium_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
- THREAD_SAFE_RUN(low_sapi_caudium_register_variables(track_vars_array ELS_CC SLS_CC PLS_CC), "register_variables");
+ THREAD_SAFE_RUN(low_sapi_caudium_register_variables(track_vars_array TSRMLS_CC SLS_CC PLS_CC), "register_variables");
}
/* this structure is static (as in "it does not change") */
* with a number of variables. HTTP_* variables are created for
* the HTTP header data, so that a script can access these.
*/
-static void php_caudium_hash_environment(CLS_D ELS_DC PLS_DC SLS_DC)
+static void php_caudium_hash_environment(CLS_D TSRMLS_DC PLS_DC SLS_DC)
{
int i;
char buf[512];
SLS_FETCH();
CLS_FETCH();
PLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
GET_THIS();
THIS->filename = ureq->filename;
THIS->done_cb = ureq->done_cb;
file_handle.free_filename = 0;
THIS->written = 0;
- res = php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC);
+ res = php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC);
if(res == FAILURE) {
THREAD_SAFE_RUN({
free_struct(SLS_C);
}, "Negative run response");
} else {
- THREAD_SAFE_RUN(php_caudium_hash_environment(CLS_C ELS_CC PLS_CC SLS_CC),
+ THREAD_SAFE_RUN(php_caudium_hash_environment(CLS_C TSRMLS_CC PLS_CC SLS_CC),
"environment hashing");
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
THREAD_SAFE_RUN({
push_int(THIS->written);
if (!caudium_php_initialized) {
caudium_php_initialized = 1;
tsrm_startup(1, 1, 0, NULL);
- caudium_globals_id = ts_allocate_id(sizeof(php_caudium_request), NULL, NULL);
+ ts_allocate_id(&caudium_globals_id, sizeof(php_caudium_request), NULL, NULL);
sapi_startup(&caudium_sapi_module);
sapi_module.startup(&caudium_sapi_module);
zend_startup_module(&php_caudium_module);
}
-static void sapi_cgi_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_cgi_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
/* In CGI mode, we consider the environment to be a part of the server
* variables
*/
- php_import_environment_variables(track_vars_array ELS_CC PLS_CC);
+ php_import_environment_variables(track_vars_array TSRMLS_CC PLS_CC);
/* Build the special-case PHP_SELF variable for the CGI version */
- php_register_variable("PHP_SELF", (SG(request_info).request_uri ? SG(request_info).request_uri:""), track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PHP_SELF", (SG(request_info).request_uri ? SG(request_info).request_uri:""), track_vars_array TSRMLS_CC PLS_CC);
}
static void php_register_command_line_global_vars(char **arg)
{
char *var, *val;
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
var = *arg;
printf("No value specified for variable '%s'\n", var);
} else {
*val++ = '\0';
- php_register_variable(var, val, NULL ELS_CC PLS_CC);
+ php_register_variable(var, val, NULL TSRMLS_CC PLS_CC);
}
efree(*arg);
}
zend_executor_globals *executor_globals;
php_core_globals *core_globals;
sapi_globals_struct *sapi_globals;
+ void ***tsrm_ls;
#endif
executor_globals = ts_resource(executor_globals_id);
core_globals = ts_resource(core_globals_id);
sapi_globals = ts_resource(sapi_globals_id);
+ tsrm_ls = ts_resource(0);
#endif
zend_try {
break;
case 'i': /* php info & quit */
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC)==FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC)==FAILURE) {
php_module_shutdown();
return FAILURE;
}
case 'v': /* show php version & quit */
no_headers = 1;
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC)==FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC)==FAILURE) {
php_module_shutdown();
return FAILURE;
}
SG(request_info).path_translated = script_file;
}
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC)==FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC)==FAILURE) {
php_module_shutdown();
return FAILURE;
}
switch (behavior) {
case PHP_MODE_STANDARD:
- exit_status = php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ exit_status = php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
break;
case PHP_MODE_LINT:
PG(during_request_startup) = 0;
- exit_status = php_lint_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ exit_status = php_lint_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
if (exit_status==SUCCESS) {
zend_printf("No syntax errors detected in %s\n", file_handle.filename);
} else {
}
-static void sapi_fastcgi_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_fastcgi_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
char *self = getenv("REQUEST_URI");
char *ptr = strchr( self, '?' );
/* strip query string off this */
if ( ptr ) *ptr = 0;
- php_register_variable( "PHP_SELF", getenv("REQUEST_URI"), track_vars_array ELS_CC PLS_CC);
+ php_register_variable( "PHP_SELF", getenv("REQUEST_URI"), track_vars_array TSRMLS_CC PLS_CC);
if ( ptr ) *ptr = '?';
}
{
zend_file_handle file_handle;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.free_filename = 0;
file_handle.opened_path = NULL;
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == SUCCESS) {
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == SUCCESS) {
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
}
}
#ifdef WITH_ZEUS
-static void sapi_isapi_register_zeus_ssl_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array ELS_DC PLS_DC)
+static void sapi_isapi_register_zeus_ssl_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array TSRMLS_DC PLS_DC)
{
char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if( lpECB->GetServerVariable( lpECB->ConnID, "SSL_CLIENT_ST", static_variable_buf, &variable_len ) && static_variable_buf[0] ) {
strcat( static_cons_buf, static_variable_buf );
}
- php_register_variable( "SSL_CLIENT_DN", static_cons_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "SSL_CLIENT_DN", static_cons_buf, track_vars_array TSRMLS_CC PLS_CC );
strcpy( static_cons_buf, "/C=" );
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if( lpECB->GetServerVariable( lpECB->ConnID, "SSL_CLIENT_I_ST", static_variable_buf, &variable_len ) && static_variable_buf[0] ) {
strcat( static_cons_buf, static_variable_buf );
}
- php_register_variable( "SSL_CLIENT_I_DN", static_cons_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "SSL_CLIENT_I_DN", static_cons_buf, track_vars_array TSRMLS_CC PLS_CC );
}
-static void sapi_isapi_register_zeus_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array ELS_DC PLS_DC)
+static void sapi_isapi_register_zeus_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array TSRMLS_DC PLS_DC)
{
char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "PATH_INFO", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
/* PHP_SELF is just PATH_INFO */
- php_register_variable( "PHP_SELF", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "PHP_SELF", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
/* Chop off filename to get just the 'real' PATH_INFO' */
pathinfo_len = variable_len - scriptname_len;
- php_register_variable( "PATH_INFO", static_variable_buf + scriptname_len - 1, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "PATH_INFO", static_variable_buf + scriptname_len - 1, track_vars_array TSRMLS_CC PLS_CC );
/* append query string to give url... extra byte for '?' */
if ( strlen(lpECB->lpszQueryString) + variable_len + 1 < ISAPI_SERVER_VAR_BUF_SIZE ) {
/* append query string only if it is present... */
static_variable_buf[ variable_len - 1 ] = '?';
strcpy( static_variable_buf + variable_len, lpECB->lpszQueryString );
}
- php_register_variable( "URL", static_variable_buf, track_vars_array ELS_CC PLS_CC );
- php_register_variable( "REQUEST_URI", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "URL", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
+ php_register_variable( "REQUEST_URI", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
}
}
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "PATH_TRANSLATED", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
static_variable_buf[ variable_len - pathinfo_len - 1 ] = '\0';
- php_register_variable( "PATH_TRANSLATED", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "PATH_TRANSLATED", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
}
/* Bring in the AUTHENTICATION stuff as needed */
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "AUTH_USER", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
- php_register_variable( "PHP_AUTH_USER", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "PHP_AUTH_USER", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
}
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "AUTH_PASSWORD", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
- php_register_variable( "PHP_AUTH_PW", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "PHP_AUTH_PW", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
}
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "AUTH_TYPE", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
- php_register_variable( "PHP_AUTH_TYPE", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "PHP_AUTH_TYPE", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
}
/* And now, for the SSL variables (if applicable) */
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "CERT_COOKIE", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
- sapi_isapi_register_zeus_ssl_variables( lpECB, track_vars_array ELS_CC PLS_CC );
+ sapi_isapi_register_zeus_ssl_variables( lpECB, track_vars_array TSRMLS_CC PLS_CC );
}
/* Copy some of the variables we need to meet Apache specs */
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if ( lpECB->GetServerVariable(lpECB->ConnID, "SERVER_SOFTWARE", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
- php_register_variable( "SERVER_SIGNATURE", static_variable_buf, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( "SERVER_SIGNATURE", static_variable_buf, track_vars_array TSRMLS_CC PLS_CC );
}
}
#endif
-static void sapi_isapi_register_server_variables2(char **server_variables, LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array, char **recorded_values ELS_DC PLS_DC)
+static void sapi_isapi_register_server_variables2(char **server_variables, LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array, char **recorded_values TSRMLS_DC PLS_DC)
{
char **p=server_variables;
DWORD variable_len;
variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
if (lpECB->GetServerVariable(lpECB->ConnID, *p, static_variable_buf, &variable_len)
&& static_variable_buf[0]) {
- php_register_variable(*p, static_variable_buf, track_vars_array ELS_CC PLS_CC);
+ php_register_variable(*p, static_variable_buf, track_vars_array TSRMLS_CC PLS_CC);
if (recorded_values) {
recorded_values[p-server_variables] = estrndup(static_variable_buf, variable_len);
}
variable_buf = (char *) emalloc(variable_len);
if (lpECB->GetServerVariable(lpECB->ConnID, *p, variable_buf, &variable_len)
&& variable_buf[0]) {
- php_register_variable(*p, variable_buf, track_vars_array ELS_CC PLS_CC);
+ php_register_variable(*p, variable_buf, track_vars_array TSRMLS_CC PLS_CC);
}
if (recorded_values) {
recorded_values[p-server_variables] = variable_buf;
}
-static void sapi_isapi_register_server_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_isapi_register_server_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
char *variable;
/* Register the special ISAPI variables */
memset(isapi_special_server_variables, 0, sizeof(isapi_special_server_variables));
- sapi_isapi_register_server_variables2(isapi_special_server_variable_names, lpECB, track_vars_array, isapi_special_server_variables ELS_CC PLS_CC);
+ sapi_isapi_register_server_variables2(isapi_special_server_variable_names, lpECB, track_vars_array, isapi_special_server_variables TSRMLS_CC PLS_CC);
if (SG(request_info).cookie_data) {
- php_register_variable("HTTP_COOKIE", SG(request_info).cookie_data, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("HTTP_COOKIE", SG(request_info).cookie_data, track_vars_array TSRMLS_CC PLS_CC);
}
/* Register the standard ISAPI variables */
- sapi_isapi_register_server_variables2(isapi_server_variable_names, lpECB, track_vars_array, NULL ELS_CC PLS_CC);
+ sapi_isapi_register_server_variables2(isapi_server_variable_names, lpECB, track_vars_array, NULL TSRMLS_CC PLS_CC);
if (isapi_special_server_variables[SPECIAL_VAR_HTTPS]
&& atoi(isapi_special_server_variables[SPECIAL_VAR_HTTPS])) {
/* Register SSL ISAPI variables */
- sapi_isapi_register_server_variables2(isapi_secure_server_variable_names, lpECB, track_vars_array, NULL ELS_CC PLS_CC);
+ sapi_isapi_register_server_variables2(isapi_secure_server_variable_names, lpECB, track_vars_array, NULL TSRMLS_CC PLS_CC);
}
if (isapi_special_server_variables[SPECIAL_VAR_HTTPS]) {
#ifdef WITH_ZEUS
- sapi_isapi_register_zeus_variables(lpECB, track_vars_array ELS_CC PLS_CC);
+ sapi_isapi_register_zeus_variables(lpECB, track_vars_array TSRMLS_CC PLS_CC);
#endif
/* PHP_SELF support */
if (isapi_special_server_variables[SPECIAL_VAR_PHP_SELF]) {
- php_register_variable("PHP_SELF", isapi_special_server_variables[SPECIAL_VAR_PHP_SELF], track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PHP_SELF", isapi_special_server_variables[SPECIAL_VAR_PHP_SELF], track_vars_array TSRMLS_CC PLS_CC);
efree(isapi_special_server_variables[SPECIAL_VAR_PHP_SELF]);
}
value++;
}
*colon = 0;
- php_register_variable(variable, value, track_vars_array ELS_CC PLS_CC);
+ php_register_variable(variable, value, track_vars_array TSRMLS_CC PLS_CC);
*colon = ':';
}
variable = php_strtok_r(NULL, "\r\n", &strtok_buf);
if (humi.lpszPath[path_len-2] == '\\') {
humi.lpszPath[path_len-2] = 0;
}
- php_register_variable("DOCUMENT_ROOT", humi.lpszPath, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("DOCUMENT_ROOT", humi.lpszPath, track_vars_array TSRMLS_CC PLS_CC);
}
}
#endif
zend_bool stack_overflown=0;
SLS_FETCH();
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
#ifdef PHP_ENABLE_SEH
LPEXCEPTION_POINTERS e;
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.opened_path = NULL;
- php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC);
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
if (SG(request_info).cookie_data) {
efree(SG(request_info).cookie_data);
}
}
static void
-sapi_nsapi_register_server_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+sapi_nsapi_register_server_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
nsapi_request_context *rc = (nsapi_request_context *)SG(server_context);
size_t i;
for (i = 0; i < nsapi_reqpb_size; i++) {
value = pblock_findval(nsapi_reqpb[i].nsapi_eq, rc->rq->reqpb);
if (value) {
- php_register_variable( (char *)nsapi_reqpb[i].env_var, value, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( (char *)nsapi_reqpb[i].env_var, value, track_vars_array TSRMLS_CC PLS_CC );
}
}
for (i = 0; i < nsapi_headers_size; i++) {
value = pblock_findval(nsapi_headers[i].nsapi_eq, rc->rq->headers);
if (value) {
- php_register_variable( (char *)nsapi_headers[i].env_var, value, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( (char *)nsapi_headers[i].env_var, value, track_vars_array TSRMLS_CC PLS_CC );
}
}
for (i = 0; i < nsapi_vars_size; i++) {
value = pblock_findval(nsapi_vars[i].nsapi_eq, rc->rq->vars);
if (value) {
- php_register_variable( (char *)nsapi_vars[i].env_var, value, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( (char *)nsapi_vars[i].env_var, value, track_vars_array TSRMLS_CC PLS_CC );
}
}
for (i = 0; i < nsapi_client_size; i++) {
value = pblock_findval(nsapi_client[i].nsapi_eq, rc->sn->client);
if (value) {
- php_register_variable( (char *)nsapi_client[i].env_var, value, track_vars_array ELS_CC PLS_CC );
+ php_register_variable( (char *)nsapi_client[i].env_var, value, track_vars_array TSRMLS_CC PLS_CC );
}
}
value = session_dns(rc->sn);
if (value) {
- php_register_variable("REMOTE_HOST", value, track_vars_array ELS_CC PLS_CC );
+ php_register_variable("REMOTE_HOST", value, track_vars_array TSRMLS_CC PLS_CC );
}
sprintf(buf, "%d", conf_getglobals()->Vport);
- php_register_variable("SERVER_PORT", buf, track_vars_array ELS_CC PLS_CC );
- php_register_variable("SERVER_NAME", util_hostname(), track_vars_array ELS_CC PLS_CC );
- php_register_variable("SERVER_URL", http_uri2url("", ""), track_vars_array ELS_CC PLS_CC );
- php_register_variable("HTTPS", (security_active ? "ON" : "OFF"), track_vars_array ELS_CC PLS_CC );
-/* php_register_variable("SERVER_SOFTWARE", MAGNUS_VERSION_STRING, track_vars_array ELS_CC PLS_CC ); */
+ php_register_variable("SERVER_PORT", buf, track_vars_array TSRMLS_CC PLS_CC );
+ php_register_variable("SERVER_NAME", util_hostname(), track_vars_array TSRMLS_CC PLS_CC );
+ php_register_variable("SERVER_URL", http_uri2url("", ""), track_vars_array TSRMLS_CC PLS_CC );
+ php_register_variable("HTTPS", (security_active ? "ON" : "OFF"), track_vars_array TSRMLS_CC PLS_CC );
+/* php_register_variable("SERVER_SOFTWARE", MAGNUS_VERSION_STRING, track_vars_array TSRMLS_CC PLS_CC ); */
/*
* Special PHP_SELF variable.
*/
value = pblock_findval("uri", rc->rq->reqpb);
if ( value != NULL ) {
- php_register_variable("PHP_SELF", value, track_vars_array ELS_CC PLS_CC );
+ php_register_variable("PHP_SELF", value, track_vars_array TSRMLS_CC PLS_CC );
}
}
zend_file_handle file_handle;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == FAILURE) {
return FAILURE;
}
"Parsing [%s]", SG(request_info).path_translated);
#endif
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
#if defined(NSAPI_DEBUG)
struct httpinfo *hip = PHG(cip)->hip;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == FAILURE) {
return -1;
}
file_handle.free_filename = 0;
/*
- php_phttpd_hash_environment(PHLS_C CLS_CC ELS_CC PLS_CC SLS_CC);
+ php_phttpd_hash_environment(PHLS_C CLS_CC TSRMLS_CC PLS_CC SLS_CC);
*/
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
return SG(sapi_headers).http_response_code;
sapi_startup(&phttpd_sapi_module);
phttpd_sapi_module.startup(&phttpd_sapi_module);
- ph_globals_id = ts_allocate_id(sizeof(phttpd_globals_struct), NULL, NULL);
+ ts_allocate_id(&ph_globals_id, sizeof(phttpd_globals_struct), NULL, NULL);
return 0;
}
SG(sapi_headers).http_response_code = 200;
}
-static void hash_pi3web_variables(ELS_D SLS_DC)
+static void hash_pi3web_variables(TSRMLS_D SLS_DC)
{
char static_variable_buf[PI3WEB_SERVER_VAR_BUF_SIZE];
char *variable_buf;
int iRet = PIAPI_COMPLETED;
SLS_FETCH();
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
zend_try {
CG(extended_info) = 0;
init_request_info(sapi_globals, lpCB);
- php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC);
+ php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC);
- hash_pi3web_variables(ELS_C SLS_CC);
+ hash_pi3web_variables(TSRMLS_C SLS_CC);
switch ( lpCB->dwBehavior ) {
case PHP_MODE_STANDARD:
- iRet = ( php_execute_script( &file_handle CLS_CC ELS_CC PLS_CC ) == SUCCESS ) ?
+ iRet = ( php_execute_script( &file_handle CLS_CC TSRMLS_CC PLS_CC ) == SUCCESS ) ?
PIAPI_COMPLETED : PIAPI_ERROR;
break;
case PHP_MODE_HIGHLIGHT: {
efree(header_line);
break;
case PHP_MODE_LINT:
- iRet = (php_lint_script(&file_handle CLS_CC ELS_CC PLS_CC) == SUCCESS) ?
+ iRet = (php_lint_script(&file_handle CLS_CC TSRMLS_CC PLS_CC) == SUCCESS) ?
PIAPI_COMPLETED : PIAPI_ERROR;
break;
default:
&pval, sizeof(zval *), NULL)
static void
-php_roxen_hash_environment(CLS_D ELS_DC PLS_DC SLS_DC)
+php_roxen_hash_environment(CLS_D TSRMLS_DC PLS_DC SLS_DC)
{
int i;
char buf[512];
#ifdef ZTS
CLS_FETCH();
PLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
#ifdef ROXEN_USE_ZTS
GET_THIS();
#endif
file_handle.opened_path = NULL;
THREADS_ALLOW();
- res = php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC);
+ res = php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC);
THREADS_DISALLOW();
if(res == FAILURE) {
return 0;
}
- php_roxen_hash_environment(CLS_C ELS_CC PLS_CC SLS_CC);
+ php_roxen_hash_environment(CLS_C TSRMLS_CC PLS_CC SLS_CC);
THREADS_ALLOW();
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
THREADS_DISALLOW();
return 1;
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
#ifdef ROXEN_USE_ZTS
- roxen_globals_id = ts_allocate_id(sizeof(php_roxen_request), NULL, NULL);
+ ts_allocate_id(&roxen_globals_id, sizeof(php_roxen_request), NULL, NULL);
#endif
#endif
sapi_startup(&roxen_sapi_module);
pval *pzval;
jlong addr = 0;
const char *nameAsUTF = (*jenv)->GetStringUTFChars(jenv, name, 0);
- ELS_FETCH();
+ TSRMLS_FETCH();
MAKE_STD_ZVAL(pzval);
addr = (jlong)(long) pzval;
SLS_FETCH();
PLS_FETCH();
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
zend_try {
SG(server_context) = emalloc(sizeof(servlet_request));
SG(sapi_headers).http_response_code = 200;
SG(request_info).content_length = contentLength;
SG(request_info).auth_password = NULL;
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC)==FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC)==FAILURE) {
ThrowServletException(jenv,"request startup failure");
return;
}
zend_highlight(&syntax_highlighter_ini);
}
} else {
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_header(); /* Make sure headers have been sent */
}
#define BUF_SIZE 512
#define ADD_STRING(name) \
- php_register_variable(name, buf, track_vars_array ELS_CC PLS_CC)
+ php_register_variable(name, buf, track_vars_array TSRMLS_CC PLS_CC)
-static void sapi_thttpd_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_thttpd_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
char buf[BUF_SIZE + 1];
char *p;
TLS_FETCH();
- php_register_variable("PHP_SELF", SG(request_info).request_uri, track_vars_array ELS_CC PLS_CC);
- php_register_variable("SERVER_SOFTWARE", SERVER_SOFTWARE, track_vars_array ELS_CC PLS_CC);
- php_register_variable("GATEWAY_INTERFACE", "CGI/1.1", track_vars_array ELS_CC PLS_CC);
- php_register_variable("REQUEST_METHOD", (char *) SG(request_info).request_method, track_vars_array ELS_CC PLS_CC);
- php_register_variable("REQUEST_URI", SG(request_info).request_uri, track_vars_array ELS_CC PLS_CC);
- php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PHP_SELF", SG(request_info).request_uri, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("SERVER_SOFTWARE", SERVER_SOFTWARE, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("GATEWAY_INTERFACE", "CGI/1.1", track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("REQUEST_METHOD", (char *) SG(request_info).request_method, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("REQUEST_URI", SG(request_info).request_uri, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated, track_vars_array TSRMLS_CC PLS_CC);
p = inet_ntoa(TG(hc)->client_addr.sa_in.sin_addr);
/* string representation of IPs are never larger than 512 bytes */
#define CONDADD(name, field) \
if (TG(hc)->field[0]) { \
- php_register_variable(#name, TG(hc)->field, track_vars_array ELS_CC PLS_CC); \
+ php_register_variable(#name, TG(hc)->field, track_vars_array TSRMLS_CC PLS_CC); \
}
CONDADD(HTTP_REFERER, referer);
}
if (TG(hc)->authorization[0])
- php_register_variable("AUTH_TYPE", "Basic", track_vars_array ELS_CC PLS_CC);
+ php_register_variable("AUTH_TYPE", "Basic", track_vars_array TSRMLS_CC PLS_CC);
}
static sapi_module_struct thttpd_sapi_module = {
{
zend_file_handle file_handle;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.free_filename = 0;
file_handle.opened_path = NULL;
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == FAILURE) {
return;
}
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
}
{
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
- thttpd_globals_id = ts_allocate_id(sizeof(php_thttpd_globals), NULL, NULL);
+ ts_allocate_id(&thttpd_globals_id, sizeof(php_thttpd_globals), NULL, NULL);
qr_lock = tsrm_mutex_alloc();
thttpd_register_on_close(remove_dead_conn);
#endif
#define BUF_SIZE 512
#define ADD_STRING(name) \
- php_register_variable(name, buf, track_vars_array ELS_CC PLS_CC)
+ php_register_variable(name, buf, track_vars_array TSRMLS_CC PLS_CC)
-static void sapi_tux_register_variables(zval *track_vars_array ELS_DC SLS_DC PLS_DC)
+static void sapi_tux_register_variables(zval *track_vars_array TSRMLS_DC SLS_DC PLS_DC)
{
char buf[BUF_SIZE + 1];
char *p;
sprintf(buf, "Server: %s", TUXAPI_version);
sapi_add_header_ex(buf, strlen(buf), 1, 0);
- php_register_variable("PHP_SELF", SG(request_info).request_uri, track_vars_array ELS_CC PLS_CC);
- php_register_variable("SERVER_SOFTWARE", TUXAPI_version, track_vars_array ELS_CC PLS_CC);
- php_register_variable("GATEWAY_INTERFACE", "CGI/1.1", track_vars_array ELS_CC PLS_CC);
- php_register_variable("REQUEST_METHOD", (char *) SG(request_info).request_method, track_vars_array ELS_CC PLS_CC);
- php_register_variable("DOCUMENT_ROOT", TUXAPI_docroot, track_vars_array ELS_CC PLS_CC);
- php_register_variable("SERVER_NAME", TUXAPI_servername, track_vars_array ELS_CC PLS_CC);
- php_register_variable("REQUEST_URI", SG(request_info).request_uri, track_vars_array ELS_CC PLS_CC);
- php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated, track_vars_array ELS_CC PLS_CC);
+ php_register_variable("PHP_SELF", SG(request_info).request_uri, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("SERVER_SOFTWARE", TUXAPI_version, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("GATEWAY_INTERFACE", "CGI/1.1", track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("REQUEST_METHOD", (char *) SG(request_info).request_method, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("DOCUMENT_ROOT", TUXAPI_docroot, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("SERVER_NAME", TUXAPI_servername, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("REQUEST_URI", SG(request_info).request_uri, track_vars_array TSRMLS_CC PLS_CC);
+ php_register_variable("PATH_TRANSLATED", SG(request_info).path_translated, track_vars_array TSRMLS_CC PLS_CC);
p = inet_ntoa(TG(req)->client_host);
/* string representation of IPs are never larger than 512 bytes */
#define CONDADD(name, field) \
if (TG(req)->field[0]) { \
- php_register_variable(#name, TG(req)->field, track_vars_array ELS_CC PLS_C); \
+ php_register_variable(#name, TG(req)->field, track_vars_array TSRMLS_CC PLS_C); \
}
CONDADD(HTTP_REFERER, referer);
#if 0
if (TG(hc)->authorization[0])
- php_register_variable("AUTH_TYPE", "Basic", track_vars_array ELS_CC PLS_C);
+ php_register_variable("AUTH_TYPE", "Basic", track_vars_array TSRMLS_CC PLS_C);
#endif
}
{
zend_file_handle file_handle;
CLS_FETCH();
- ELS_FETCH();
+ TSRMLS_FETCH();
PLS_FETCH();
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.free_filename = 0;
file_handle.opened_path = NULL;
- if (php_request_startup(CLS_C ELS_CC PLS_CC SLS_CC) == FAILURE) {
+ if (php_request_startup(CLS_C TSRMLS_CC PLS_CC SLS_CC) == FAILURE) {
return;
}
- php_execute_script(&file_handle CLS_CC ELS_CC PLS_CC);
+ php_execute_script(&file_handle CLS_CC TSRMLS_CC PLS_CC);
php_request_shutdown(NULL);
}
projects / php / commitdiff