/* {{{ php_register_server_variables
*/
static inline void php_register_server_variables(void)
{
zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
array_init(&PG(http_globals)[TRACK_VARS_SERVER]);
/* Server variables */
if (sapi_module.register_server_variables) {
sapi_module.register_server_variables(&PG(http_globals)[TRACK_VARS_SERVER]);
}
/* PHP Authentication support */
if (SG(request_info).auth_user) {
php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, &PG(http_globals)[TRACK_VARS_SERVER]);
}
if (SG(request_info).auth_password) {
php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, &PG(http_globals)[TRACK_VARS_SERVER]);
}
if (SG(request_info).auth_digest) {
php_register_variable("PHP_AUTH_DIGEST", SG(request_info).auth_digest, &PG(http_globals)[TRACK_VARS_SERVER]);
}
/* store request init time */
{
zval request_time_float, request_time_long;
ZVAL_DOUBLE(&request_time_float, sapi_get_request_time());
php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, &PG(http_globals)[TRACK_VARS_SERVER]);
ZVAL_LONG(&request_time_long, zend_dval_to_lval(Z_DVAL(request_time_float)));
php_register_variable_ex("REQUEST_TIME", &request_time_long, &PG(http_globals)[TRACK_VARS_SERVER]);
}
}
static void sapi_cli_register_variables(zval *track_vars_array) /* {{{ */
{
size_t len;
char *docroot = "";
/* In CGI mode, we consider the environment to be a part of the server
* variables
*/
php_import_environment_variables(track_vars_array);
/* Build the special-case PHP_SELF variable for the CLI version */
len = strlen(php_self);
if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, len, &len)) {
php_register_variable("PHP_SELF", php_self, track_vars_array);
}
if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_NAME", &php_self, len, &len)) {
php_register_variable("SCRIPT_NAME", php_self, track_vars_array);
}
/* filenames are empty for stdin */
len = strlen(script_filename);
if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_FILENAME", &script_filename, len, &len)) {
php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array);
}
if (sapi_module.input_filter(PARSE_SERVER, "PATH_TRANSLATED", &script_filename, len, &len)) {
php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array);
}
/* just make it available */
len = 0U;
if (sapi_module.input_filter(PARSE_SERVER, "DOCUMENT_ROOT", &docroot, len, &len)) {
php_register_variable("DOCUMENT_ROOT", docroot, track_vars_array);
}
}
void _php_import_environment_variables(zval *array_ptr)
{
char buf[128];
char **env, *p, *t = buf;
size_t alloc_size = sizeof(buf);
unsigned long nlen; /* ptrdiff_t is not portable */
for (env = environ; env != NULL && *env != NULL; env++) {
p = strchr(*env, '=');
if (!p) { /* malformed entry? */
continue;
}
nlen = p - *env;
if (nlen >= alloc_size) {
alloc_size = nlen + 64;
t = (t == buf ? emalloc(alloc_size): erealloc(t, alloc_size));
}
memcpy(t, *env, nlen);
t[nlen] = '\0';
php_register_variable(t, p + 1, array_ptr);
}
if (t != buf && t != NULL) {
efree(t);
}
}
/* {{{ sapi_lsapi_register_variables
*/
static void sapi_lsapi_register_variables(zval *track_vars_array)
{
char * php_self = "";
if ( lsapi_mode ) {
if ( (SG(request_info).request_uri ) )
php_self = (SG(request_info).request_uri );
litespeed_php_import_environment_variables(track_vars_array);
LSAPI_ForeachHeader( add_variable, track_vars_array );
LSAPI_ForeachEnv( add_variable, track_vars_array );
add_variable("PHP_SELF", 8, php_self, strlen( php_self ), track_vars_array );
} else {
php_import_environment_variables(track_vars_array);
php_register_variable("PHP_SELF", php_self, track_vars_array);
php_register_variable("SCRIPT_NAME", php_self, track_vars_array);
php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array);
php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array);
php_register_variable("DOCUMENT_ROOT", "", track_vars_array);
}
}
/* {{{ apache_php_module_hook
*/
int apache_php_module_hook(request_rec *r, php_handler *handler, zval **ret)
{
zend_file_handle file_handle;
zval *req;
char *tmp;
#if PHP_SIGCHILD
signal(SIGCHLD, sigchld_handler);
#endif
if(AP(current_hook) == AP_RESPONSE) {
if (php_request_startup_for_hook() == FAILURE)
return FAILURE;
}
else {
if (php_request_startup_for_hook() == FAILURE)
return FAILURE;
}
req = php_apache_request_new(r);
php_register_variable_ex("request", req, PG(http_globals)[TRACK_VARS_SERVER]);
switch(handler->type) {
case AP_HANDLER_TYPE_FILE:
php_register_variable("PHP_SELF_HOOK", handler->name, PG(http_globals)[TRACK_VARS_SERVER]);
memset(&file_handle, 0, sizeof(file_handle));
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.filename = handler->name;
(void) php_execute_simple_script(&file_handle, ret);
break;
case AP_HANDLER_TYPE_METHOD:
if( (tmp = strstr(handler->name, "::")) != NULL && *(tmp+2) != '\0' ) {
zval *class;
zval *method;
*tmp = '\0';
ALLOC_ZVAL(class);
ZVAL_STRING(class, handler->name, 1);
ALLOC_ZVAL(method);
ZVAL_STRING(method, tmp +2, 1);
*tmp = ':';
call_user_function_ex(EG(function_table), &class, method, ret, 0, NULL, 0, NULL);
zval_dtor(class);
zval_dtor(method);
}
else {
static void
php_apache_sapi_register_variables(zval *track_vars_array)
{
php_struct *ctx = SG(server_context);
const apr_array_header_t *arr = apr_table_elts(ctx->r->subprocess_env);
char *key, *val;
unsigned int new_val_len;
APR_ARRAY_FOREACH_OPEN(arr, key, val)
if (!val) {
val = "";
}
if (sapi_module.input_filter(PARSE_SERVER, key, &val, strlen(val), &new_val_len)) {
php_register_variable_safe(key, val, new_val_len, track_vars_array);
}
APR_ARRAY_FOREACH_CLOSE()
php_register_variable("PHP_SELF", ctx->r->uri, track_vars_array);
if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &ctx->r->uri, strlen(ctx->r->uri), &new_val_len)) {
php_register_variable_safe("PHP_SELF", ctx->r->uri, new_val_len, track_vars_array);
}
}
EMBED_SAPI_API int php_embed_init(int argc, char **argv)
{
zend_llist global_vars;
#ifdef HAVE_SIGNAL_H
#if defined(SIGPIPE) && defined(SIG_IGN)
signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE in standalone mode so
that sockets created via fsockopen()
don't kill PHP if the remote site
closes it. in apache|apxs mode apache
does that for us! [email protected]
20000419 */
#endif
#endif
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
(void)ts_resource(0);
ZEND_TSRMLS_CACHE_UPDATE();
#endif
#ifdef ZEND_SIGNALS
zend_signal_startup();
#endif
sapi_startup(&php_embed_module);
#ifdef PHP_WIN32
_fmode = _O_BINARY; /*sets default for file streams to binary */
setmode(_fileno(stdin), O_BINARY); /* make the stdio mode be binary */
setmode(_fileno(stdout), O_BINARY); /* make the stdio mode be binary */
setmode(_fileno(stderr), O_BINARY); /* make the stdio mode be binary */
#endif
php_embed_module.ini_entries = malloc(sizeof(HARDCODED_INI));
memcpy(php_embed_module.ini_entries, HARDCODED_INI, sizeof(HARDCODED_INI));
php_embed_module.additional_functions = additional_functions;
if (argv) {
php_embed_module.executable_location = argv[0];
}
if (php_embed_module.startup(&php_embed_module)==FAILURE) {
return FAILURE;
}
zend_llist_init(&global_vars, sizeof(char *), NULL, 0);
/* Set some Embedded PHP defaults */
SG(options) |= SAPI_OPTION_NO_CHDIR;
SG(request_info).argc=argc;
SG(request_info).argv=argv;
if (php_request_startup()==FAILURE) {
php_module_shutdown();
return FAILURE;
}
SG(headers_sent) = 1;
SG(request_info).no_headers = 1;
php_register_variable("PHP_SELF", "-", NULL);
return SUCCESS;
}
static void sapi_capi_register_server_variables(zval * track_vars_array)
{
capi_request_context *rc = (capi_request_context *) SG(server_context);
size_t i;
char *value;
char buf[128];
/* PHP_SELF and REQUEST_URI */
value = lstFset_get(rc->t->vars, "uri");
if (value != NULL) {
php_register_variable("PHP_SELF", value, track_vars_array);
php_register_variable("REQUEST_URI", value, track_vars_array);
}
/* COUNTRY CODE */
value = lstFset_get(rc->t->vars, "ccode");
if(value!=NULL)
php_register_variable("COUNTRY_CODE", value, track_vars_array);
/* argv */
value = lstFset_get(rc->t->vars, "query");
if (value != NULL)
php_register_variable("argv", value, track_vars_array);
/* GATEWAY_INTERFACE */
php_register_variable("GATEWAY_INTERFACE", "CGI/1.1", track_vars_array);
/* SERVER_NAME and HTTP_HOST */
value = lstFset_get(rc->t->req_hdrs, "host");
if (value != NULL) {
php_register_variable("HTTP_HOST", value, track_vars_array);
/* TODO: This should probably scrub the port value if one is present. */
php_register_variable("SERVER_NAME", value, track_vars_array);
}
/* SERVER_SOFTWARE */
value = lstFset_get(rc->t->res_hdrs, "Server");
if (value != NULL)
php_register_variable("SERVER_SOFTWARE", value, track_vars_array);
/* SERVER_PROTOCOL */
value = lstFset_get(rc->t->vars, "protocol");
if (value != NULL)
php_register_variable("SERVER_PROTOCOL", value, track_vars_array);
/* REQUEST_METHOD */
value = lstFset_get(rc->t->vars, "method");
if (value != NULL)
php_register_variable("REQUEST_METHOD", value, track_vars_array);
/* QUERY_STRING */
value = lstFset_get(rc->t->vars, "query");
if (value != NULL)
php_register_variable("QUERY_STRING", value, track_vars_array);
/* DOCUMENT_ROOT */
value = lstFset_get(rc->t->vars, "docroot");
if (value != NULL)
php_register_variable("DOCUMENT_ROOT", value, track_vars_array);
/* HTTP_ACCEPT */
value = lstFset_get(rc->t->req_hdrs, "accept");
if (value != NULL)
php_register_variable("HTTP_ACCEPT", value, track_vars_array);
/* HTTP_ACCEPT_CHARSET */
value = lstFset_get(rc->t->req_hdrs, "accept-charset");
if (value != NULL)
php_register_variable("HTTP_ACCEPT_CHARSET", value, track_vars_array);
/* HTTP_ACCEPT_ENCODING */
value = lstFset_get(rc->t->req_hdrs, "accept-encoding");
if (value != NULL)
php_register_variable("HTTP_ACCEPT_ENCODING", value, track_vars_array);
/* HTTP_ACCEPT_LANGUAGE */
value = lstFset_get(rc->t->req_hdrs, "accept-language");
if (value != NULL)
php_register_variable("HTTP_ACCEPT_LANGUAGE", value, track_vars_array);
/* HTTP_CONNECTION */
value = lstFset_get(rc->t->req_hdrs, "connection");
if (value != NULL)
php_register_variable("HTTP_CONNECTION", value, track_vars_array);
/* HTTP_REFERER */
value = lstFset_get(rc->t->req_hdrs, "referer");
if (value != NULL)
php_register_variable("HTTP_REFERER", value, track_vars_array);
/* HTTP_USER_AGENT */
value = lstFset_get(rc->t->req_hdrs, "user-agent");
if (value != NULL)
php_register_variable("HTTP_USER_AGENT", value, track_vars_array);
/* REMOTE_ADDR */
utlFip_to_str(rc->t->cli_ipv4_addr, buf, sizeof(buf));
php_register_variable("REMOTE_ADDR", buf, track_vars_array);
/* REMOTE_PORT */
/* SCRIPT_FILENAME and PATH_TRANSLATED */
value = lstFset_get(rc->t->vars, "path");
if (value != NULL) {
php_register_variable("SCRIPT_FILENAME", value, track_vars_array);
php_register_variable("PATH_TRANSLATED", value, track_vars_array);
}
/* SERVER_ADMIN */
/* Not applicable */
/* SERVER_PORT */
}
static void sapi_milter_register_variables(zval *track_vars_array)
{
php_register_variable ("SERVER_SOFTWARE", "Sendmail Milter", track_vars_array);
}
static void runPhp(MaQueue *q)
{
MaConn *conn;
MaRequest *req;
MaResponse *resp;
MprHash *hp;
MaPhp *php;
FILE *fp;
char shebang[MPR_MAX_STRING];
zend_file_handle file_handle;
TSRMLS_FETCH();
conn = q->conn;
req = conn->request;
resp = conn->response;
php = q->queueData;
maPutForService(q, maCreateHeaderPacket(q), 0);
/*
* Set the request context
*/
zend_first_try {
php->var_array = 0;
SG(server_context) = conn;
if (req->user) {
SG(request_info).auth_user = estrdup(req->user);
}
if (req->password) {
SG(request_info).auth_password = estrdup(req->password);
}
if (req->authType && req->authDetails) {
SG(request_info).auth_digest = estrdup(mprAsprintf(req, -1, "%s %s", req->authType, req->authDetails));
}
SG(request_info).auth_password = req->password;
SG(request_info).content_type = req->mimeType;
SG(request_info).content_length = req->length;
SG(sapi_headers).http_response_code = MPR_HTTP_CODE_OK;
SG(request_info).path_translated = resp->filename;
SG(request_info).query_string = req->parsedUri->query;
SG(request_info).request_method = req->methodName;
SG(request_info).request_uri = req->url;
/*
* Workaround on MAC OS X where the SIGPROF is given to the wrong thread
*/
PG(max_input_time) = -1;
EG(timeout_seconds) = 0;
/* The readPostData callback may be invoked during startup */
php_request_startup(TSRMLS_C);
CG(zend_lineno) = 0;
} zend_catch {
mprError(q, "Can't start PHP request");
zend_try {
php_request_shutdown(0);
} zend_end_try();
maFailRequest(conn, MPR_HTTP_CODE_INTERNAL_SERVER_ERROR, "PHP initialization failed");
return;
} zend_end_try();
/*
* Define header variables
*/
zend_try {
hp = mprGetFirstHash(req->headers);
while (hp) {
if (hp->data) {
php_register_variable(hp->key, (char*) hp->data, php->var_array TSRMLS_CC);
mprLog(q, 6, "php: header var %s = %s", hp->key, hp->data);
}
hp = mprGetNextHash(req->headers, hp);
}
hp = mprGetFirstHash(req->formVars);
while (hp) {
if (hp->data) {
php_register_variable(hp->key, (char*) hp->data, php->var_array TSRMLS_CC);
mprLog(q, 6, "php: form var %s = %s", hp->key, hp->data);
}
hp = mprGetNextHash(req->formVars, hp);
}
} zend_end_try();
/*
* Execute the script file
*/
file_handle.filename = resp->filename;
file_handle.free_filename = 0;
file_handle.opened_path = 0;
#if LOAD_FROM_FILE
file_handle.type = ZEND_HANDLE_FILENAME;
#else
file_handle.type = ZEND_HANDLE_FP;
if ((fp = fopen(resp->filename, "r")) == NULL) {
maFailRequest(conn, MPR_HTTP_CODE_INTERNAL_SERVER_ERROR, "PHP can't open script");
return;
}
/*
Check for shebang and skip
*/
file_handle.handle.fp = fp;
shebang[0] = '\0';
if (fgets(shebang, sizeof(shebang), file_handle.handle.fp) != 0) {
if (shebang[0] != '#' || shebang[1] != '!') {
fseek(fp, 0L, SEEK_SET);
}
}
#endif
zend_try {
php_execute_script(&file_handle TSRMLS_CC);
if (!SG(headers_sent)) {
sapi_send_headers(TSRMLS_C);
}
} zend_catch {
php_request_shutdown(0);
maFailRequest(conn, MPR_HTTP_CODE_INTERNAL_SERVER_ERROR, "PHP script execution failed");
return;
} zend_end_try();
zend_try {
php_request_shutdown(0);
} zend_end_try();
maPutForService(q, maCreateEndPacket(q), 1);
}
int MaPhp4Handler::run(MaRequest *rq)
{
MaDataStream *dynBuf;
MprHashTable *env;
MprStringHashEntry *vp;
int flags, contentLength;
hitCount++;
flags= rq->getFlags();
dynBuf = rq->getDynBuf();
rq->insertDataStream(dynBuf);
rq->setResponseCode(200);
rq->setHeaderFlags(MPR_HTTP_DONT_CACHE);
rq->setPullPost();
//
// Initialize PHP
//
TSRMLS_FETCH();
zend_first_try {
phpInitialized = 0;
func_data = rq;
var_array = 0;
SG(server_context) = rq;
SG(request_info).path_translated = rq->getFileName();
SG(request_info).request_method = rq->getMethod();
SG(request_info).request_uri = rq->getUri();
SG(request_info).query_string = rq->getQueryString();
SG(request_info).content_type = rq->getRequestContentMimeType();
SG(request_info).content_length = rq->getContentLength();
SG(sapi_headers).http_response_code = 200;
SG(request_info).auth_user = rq->getUser();
SG(request_info).auth_password = rq->getPassword();
php_request_startup(TSRMLS_C);
CG(zend_lineno) = 0;
} zend_catch {
mprLog(1, log, "PHP startup failed\n");
zend_try {
php_request_shutdown(0);
} zend_end_try();
rq->requestError(MPR_HTTP_INTERNAL_SERVER_ERROR,
"PHP initialization failed");
return MPR_HTTP_HANDLER_FINISHED_PROCESSING;
} zend_end_try();
phpInitialized = 1;
//
// Copy the environment variables to the PHP script engine
//
env = rq->getEnv();
vp = (MprStringHashEntry*) env->getFirst();
while (vp) {
php_register_variable(vp->getKey(), vp->getValue(),
var_array TSRMLS_CC);
vp = (MprStringHashEntry*) env->getNext(vp);
}
//
// Execute the PHP script
//
if (execScript(rq) < 0) {
zend_try {
php_request_shutdown(0);
} zend_end_try();
rq->requestError(MPR_HTTP_INTERNAL_SERVER_ERROR,
"PHP script execution failed");
return MPR_HTTP_HANDLER_FINISHED_PROCESSING;
}
