sapi/isapi/php5isapi.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
php_info_isapi
sapi_isapi_ub_write
sapi_isapi_header_handler
accumulate_header_length
concat_header
sapi_isapi_send_headers
php_isapi_startup
sapi_isapi_read_post
sapi_isapi_read_cookies
sapi_isapi_register_zeus_ssl_variables
sapi_isapi_register_zeus_variables
sapi_isapi_register_iis_variables
sapi_isapi_register_server_variables2
sapi_isapi_register_server_variables
GetFilterVersion
HttpFilterProc
init_request_info
php_isapi_report_exception
GetExtensionVersion
my_endthread
exceptionhandler
HttpExtensionProc
__declspec
   1 /*
   2    +----------------------------------------------------------------------+
   3    | PHP Version 5                                                        |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 1997-2016 The PHP Group                                |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15    | Authors: Zeev Suraski <zeev@zend.com>                                |
  16    |          Ben Mansell <ben@zeus.com> (Zeus Support)                   |
  17    +----------------------------------------------------------------------+
  18  */
  19 /* $Id$ */
  20 
  21 #include "php.h"
  22 #include <httpext.h>
  23 #include <httpfilt.h>
  24 #include <httpext.h>
  25 #include "php_main.h"
  26 #include "SAPI.h"
  27 #include "php_globals.h"
  28 #include "ext/standard/info.h"
  29 #include "php_variables.h"
  30 #include "php_ini.h"
  31 
  32 #ifdef PHP_WIN32
  33 # include <process.h>
  34 #else
  35 # define __try
  36 # define __except(val)
  37 # define __declspec(foo)
  38 #endif
  39 
  40 
  41 #ifdef WITH_ZEUS
  42 # include "httpext.h"
  43 # include <errno.h>
  44 # define GetLastError() errno
  45 #endif
  46 
  47 #ifdef PHP_WIN32
  48 #define PHP_ENABLE_SEH
  49 #endif
  50 
  51 /* 
  52 uncomment the following lines to turn off 
  53 exception trapping when running under a debugger 
  54 
  55 #ifdef _DEBUG
  56 #undef PHP_ENABLE_SEH
  57 #endif
  58 */
  59 
  60 #define MAX_STATUS_LENGTH sizeof("xxxx LONGEST POSSIBLE STATUS DESCRIPTION")
  61 #define ISAPI_SERVER_VAR_BUF_SIZE 1024
  62 #define ISAPI_POST_DATA_BUF 1024
  63 
  64 static zend_bool bFilterLoaded=0;
  65 static zend_bool bTerminateThreadsOnError=0;
  66 
  67 static char *isapi_special_server_variable_names[] = {
  68         "ALL_HTTP",
  69         "HTTPS",
  70 #ifndef WITH_ZEUS
  71         "SCRIPT_NAME",
  72 #endif
  73         NULL
  74 };
  75 
  76 #define NUM_SPECIAL_VARS                (sizeof(isapi_special_server_variable_names)/sizeof(char *))
  77 #define SPECIAL_VAR_ALL_HTTP    0
  78 #define SPECIAL_VAR_HTTPS               1
  79 #define SPECIAL_VAR_PHP_SELF    2
  80 
  81 static char *isapi_server_variable_names[] = {
  82         "AUTH_PASSWORD",
  83         "AUTH_TYPE",
  84         "AUTH_USER",
  85         "CONTENT_LENGTH",
  86         "CONTENT_TYPE",
  87         "PATH_TRANSLATED",
  88         "QUERY_STRING",
  89         "REMOTE_ADDR",
  90         "REMOTE_HOST",
  91         "REMOTE_USER",
  92         "REQUEST_METHOD",
  93         "SERVER_NAME",
  94         "SERVER_PORT",
  95         "SERVER_PROTOCOL",
  96         "SERVER_SOFTWARE",
  97 #ifndef WITH_ZEUS
  98         "APPL_MD_PATH",
  99         "APPL_PHYSICAL_PATH",
 100         "INSTANCE_ID",
 101         "INSTANCE_META_PATH",
 102         "LOGON_USER",
 103         "REQUEST_URI",
 104         "URL",
 105 #else
 106         "DOCUMENT_ROOT",
 107 #endif
 108         NULL
 109 };
 110 
 111 
 112 static char *isapi_secure_server_variable_names[] = {
 113         "CERT_COOKIE",
 114         "CERT_FLAGS",
 115         "CERT_ISSUER",
 116         "CERT_KEYSIZE",
 117         "CERT_SECRETKEYSIZE",
 118         "CERT_SERIALNUMBER",
 119         "CERT_SERVER_ISSUER",
 120         "CERT_SERVER_SUBJECT",
 121         "CERT_SUBJECT",
 122         "HTTPS_KEYSIZE",
 123         "HTTPS_SECRETKEYSIZE",
 124         "HTTPS_SERVER_ISSUER",
 125         "HTTPS_SERVER_SUBJECT",
 126         "SERVER_PORT_SECURE",
 127 #ifdef WITH_ZEUS
 128         "SSL_CLIENT_CN",
 129         "SSL_CLIENT_EMAIL",
 130         "SSL_CLIENT_OU",
 131         "SSL_CLIENT_O",
 132         "SSL_CLIENT_L",
 133         "SSL_CLIENT_ST",
 134         "SSL_CLIENT_C",
 135         "SSL_CLIENT_I_CN",
 136         "SSL_CLIENT_I_EMAIL",
 137         "SSL_CLIENT_I_OU",
 138         "SSL_CLIENT_I_O",
 139         "SSL_CLIENT_I_L",
 140         "SSL_CLIENT_I_ST",
 141         "SSL_CLIENT_I_C",       
 142 #endif
 143         NULL
 144 };
 145 
 146 
 147 static void php_info_isapi(ZEND_MODULE_INFO_FUNC_ARGS)
 148 {
 149         char **p;
 150         char variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 151         DWORD variable_len;
 152         char **all_variables[] = {
 153                 isapi_server_variable_names,
 154                 isapi_special_server_variable_names,
 155                 isapi_secure_server_variable_names,
 156                 NULL
 157         };
 158         char ***server_variable_names;
 159         LPEXTENSION_CONTROL_BLOCK lpECB;
 160 
 161         lpECB = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 162 
 163         php_info_print_table_start();
 164         php_info_print_table_header(2, "Server Variable", "Value");
 165         server_variable_names = all_variables;
 166         while (*server_variable_names) {
 167                 p = *server_variable_names;
 168                 while (*p) {
 169                         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 170                         if (lpECB->GetServerVariable(lpECB->ConnID, *p, variable_buf, &variable_len)
 171                                 && variable_buf[0]) {
 172                                 php_info_print_table_row(2, *p, variable_buf);
 173                         } else if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 174                                 char *tmp_variable_buf;
 175 
 176                                 tmp_variable_buf = (char *) emalloc(variable_len);
 177                                 if (lpECB->GetServerVariable(lpECB->ConnID, *p, tmp_variable_buf, &variable_len)
 178                                         && variable_buf[0]) {
 179                                         php_info_print_table_row(2, *p, tmp_variable_buf);
 180                                 }
 181                                 efree(tmp_variable_buf);
 182                         }
 183                         p++;
 184                 }
 185                 server_variable_names++;
 186         }
 187         php_info_print_table_end();
 188 }
 189 
 190 
 191 static zend_module_entry php_isapi_module = {
 192     STANDARD_MODULE_HEADER,
 193         "ISAPI",
 194         NULL,
 195         NULL,
 196         NULL,
 197         NULL,
 198         NULL,
 199         php_info_isapi,
 200     NULL,
 201         STANDARD_MODULE_PROPERTIES
 202 };
 203 
 204 
 205 static int sapi_isapi_ub_write(const char *str, uint str_length TSRMLS_DC)
 206 {
 207         DWORD num_bytes = str_length;
 208         LPEXTENSION_CONTROL_BLOCK ecb;
 209         
 210         ecb = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 211         if (ecb->WriteClient(ecb->ConnID, (char *) str, &num_bytes, HSE_IO_SYNC) == FALSE) {
 212                 php_handle_aborted_connection();
 213         }
 214         return num_bytes;
 215 }
 216 
 217 
 218 static int sapi_isapi_header_handler(sapi_header_struct *sapi_header, sapi_header_op_enum op, sapi_headers_struct *sapi_headers TSRMLS_DC)
 219 {
 220         return SAPI_HEADER_ADD;
 221 }
 222 
 223 
 224 
 225 static void accumulate_header_length(sapi_header_struct *sapi_header, uint *total_length TSRMLS_DC)
 226 {
 227         *total_length += sapi_header->header_len+2;
 228 }
 229 
 230 
 231 static void concat_header(sapi_header_struct *sapi_header, char **combined_headers_ptr TSRMLS_DC)
 232 {
 233         memcpy(*combined_headers_ptr, sapi_header->header, sapi_header->header_len);
 234         *combined_headers_ptr += sapi_header->header_len;
 235         **combined_headers_ptr = '\r';
 236         (*combined_headers_ptr)++;
 237         **combined_headers_ptr = '\n';
 238         (*combined_headers_ptr)++;
 239 }
 240 
 241 
 242 static int sapi_isapi_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC)
 243 {
 244         uint total_length = 2;          /* account for the trailing \r\n */
 245         char *combined_headers, *combined_headers_ptr;
 246         LPEXTENSION_CONTROL_BLOCK lpECB = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 247         HSE_SEND_HEADER_EX_INFO header_info;
 248         sapi_header_struct default_content_type;
 249         char *status_buf = NULL;
 250 
 251         /* Obtain headers length */
 252         if (SG(sapi_headers).send_default_content_type) {
 253                 sapi_get_default_content_type_header(&default_content_type TSRMLS_CC);
 254                 accumulate_header_length(&default_content_type, (void *) &total_length TSRMLS_CC);
 255         }
 256         zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) accumulate_header_length, (void *) &total_length TSRMLS_CC);
 257 
 258         /* Generate headers */
 259         combined_headers = (char *) emalloc(total_length+1);
 260         combined_headers_ptr = combined_headers;
 261         if (SG(sapi_headers).send_default_content_type) {
 262                 concat_header(&default_content_type, (void *) &combined_headers_ptr TSRMLS_CC);
 263                 sapi_free_header(&default_content_type); /* we no longer need it */
 264         }
 265         zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) concat_header, (void *) &combined_headers_ptr TSRMLS_CC);
 266         *combined_headers_ptr++ = '\r';
 267         *combined_headers_ptr++ = '\n';
 268         *combined_headers_ptr = 0;
 269 
 270         switch (SG(sapi_headers).http_response_code) {
 271                 case 200:
 272                         header_info.pszStatus = "200 OK";
 273                         break;
 274                 case 302:
 275                         header_info.pszStatus = "302 Moved Temporarily";
 276                         break;
 277                 case 401:
 278                         header_info.pszStatus = "401 Authorization Required";
 279                         break;
 280                 default: {
 281                         const char *sline = SG(sapi_headers).http_status_line;
 282                         int sline_len;
 283                         
 284                         /* httpd requires that r->status_line is set to the first digit of
 285                          * the status-code: */
 286                         if (sline && ((sline_len = strlen(sline)) > 12) && strncmp(sline, "HTTP/1.", 7) == 0 && sline[8] == ' ') {
 287                                 if ((sline_len - 9) > MAX_STATUS_LENGTH) {
 288                                         status_buf = estrndup(sline + 9, MAX_STATUS_LENGTH);
 289                                 } else {
 290                                         status_buf = estrndup(sline + 9, sline_len - 9);
 291                                 }
 292                         } else {
 293                                 status_buf = emalloc(MAX_STATUS_LENGTH + 1);
 294                                 snprintf(status_buf, MAX_STATUS_LENGTH, "%d Undescribed", SG(sapi_headers).http_response_code);
 295                         }
 296                         header_info.pszStatus = status_buf;
 297                         break;
 298                 }
 299         }
 300         header_info.cchStatus = strlen(header_info.pszStatus);
 301         header_info.pszHeader = combined_headers;
 302         header_info.cchHeader = total_length;
 303         header_info.fKeepConn = FALSE;
 304         lpECB->dwHttpStatusCode = SG(sapi_headers).http_response_code;
 305 
 306         lpECB->ServerSupportFunction(lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);
 307 
 308         efree(combined_headers);
 309         if (status_buf) {
 310                 efree(status_buf);
 311         }
 312         return SAPI_HEADER_SENT_SUCCESSFULLY;
 313 }
 314 
 315 
 316 static int php_isapi_startup(sapi_module_struct *sapi_module)
 317 {
 318         if (php_module_startup(sapi_module, &php_isapi_module, 1)==FAILURE) {
 319                 return FAILURE;
 320         } else {
 321                 bTerminateThreadsOnError = (zend_bool) INI_INT("isapi.terminate_threads_on_error");
 322                 return SUCCESS;
 323         }
 324 }
 325 
 326 
 327 static int sapi_isapi_read_post(char *buffer, uint count_bytes TSRMLS_DC)
 328 {
 329         LPEXTENSION_CONTROL_BLOCK lpECB = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 330         DWORD read_from_buf=0;
 331         DWORD read_from_input=0;
 332         DWORD total_read=0;
 333 
 334         if ((DWORD) SG(read_post_bytes) < lpECB->cbAvailable) {
 335                 read_from_buf = MIN(lpECB->cbAvailable-SG(read_post_bytes), count_bytes);
 336                 memcpy(buffer, lpECB->lpbData+SG(read_post_bytes), read_from_buf);
 337                 total_read += read_from_buf;
 338         }
 339         if (read_from_buf<count_bytes
 340                 && (SG(read_post_bytes)+read_from_buf) < lpECB->cbTotalBytes) {
 341                 DWORD cbRead=0, cbSize;
 342 
 343                 read_from_input = MIN(count_bytes-read_from_buf, lpECB->cbTotalBytes-SG(read_post_bytes)-read_from_buf);
 344                 while (cbRead < read_from_input) {
 345                         cbSize = read_from_input - cbRead;
 346                         if (!lpECB->ReadClient(lpECB->ConnID, buffer+read_from_buf+cbRead, &cbSize) || cbSize==0) {
 347                                 break;
 348                         }
 349                         cbRead += cbSize;
 350                 }
 351                 total_read += cbRead;
 352         }
 353         return total_read;
 354 }
 355 
 356 
 357 static char *sapi_isapi_read_cookies(TSRMLS_D)
 358 {
 359         LPEXTENSION_CONTROL_BLOCK lpECB = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 360         char variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 361         DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 362 
 363         if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_COOKIE", variable_buf, &variable_len)) {
 364                 return estrndup(variable_buf, variable_len);
 365         } else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
 366                 char *tmp_variable_buf = (char *) emalloc(variable_len+1);
 367 
 368                 if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_COOKIE", tmp_variable_buf, &variable_len)) {
 369                         tmp_variable_buf[variable_len] = 0;
 370                         return tmp_variable_buf;
 371                 } else {
 372                         efree(tmp_variable_buf);
 373                 }
 374         }
 375         return STR_EMPTY_ALLOC();
 376 }
 377 
 378 
 379 #ifdef WITH_ZEUS
 380 
 381 static void sapi_isapi_register_zeus_ssl_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array TSRMLS_DC)
 382 {
 383         char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 384         DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 385         char static_cons_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 386         /*
 387          * We need to construct the /C=.../ST=...
 388          * DN's for SSL_CLIENT_DN and SSL_CLIENT_I_DN
 389          */
 390         strcpy( static_cons_buf, "/C=" );
 391         if( lpECB->GetServerVariable( lpECB->ConnID, "SSL_CLIENT_C", static_variable_buf, &variable_len ) && static_variable_buf[0] ) {
 392                 strlcat( static_cons_buf, static_variable_buf,  ISAPI_SERVER_VAR_BUF_SIZE);
 393         }
 394         strlcat( static_cons_buf, "/ST=",  ISAPI_SERVER_VAR_BUF_SIZE);
 395         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 396         if( lpECB->GetServerVariable( lpECB->ConnID, "SSL_CLIENT_ST", static_variable_buf, &variable_len ) && static_variable_buf[0] ) {
 397                 strlcat( static_cons_buf, static_variable_buf, ISAPI_SERVER_VAR_BUF_SIZE );
 398         }
 399         php_register_variable( "SSL_CLIENT_DN", static_cons_buf, track_vars_array TSRMLS_CC );
 400         
 401         strcpy( static_cons_buf, "/C=" );
 402         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 403         if( lpECB->GetServerVariable( lpECB->ConnID, "SSL_CLIENT_I_C", static_variable_buf, &variable_len ) && static_variable_buf[0] ) {
 404                 strlcat( static_cons_buf, static_variable_buf, ISAPI_SERVER_VAR_BUF_SIZE );
 405         }
 406         strlcat( static_cons_buf, "/ST=", ISAPI_SERVER_VAR_BUF_SIZE);
 407         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 408         if( lpECB->GetServerVariable( lpECB->ConnID, "SSL_CLIENT_I_ST", static_variable_buf, &variable_len ) && static_variable_buf[0] ) {
 409                 strlcat( static_cons_buf, static_variable_buf, ISAPI_SERVER_VAR_BUF_SIZE );
 410         }
 411         php_register_variable( "SSL_CLIENT_I_DN", static_cons_buf, track_vars_array TSRMLS_CC );        
 412 }
 413 
 414 static void sapi_isapi_register_zeus_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array TSRMLS_DC)
 415 {
 416         char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 417         DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 418         DWORD scriptname_len = ISAPI_SERVER_VAR_BUF_SIZE;
 419         DWORD pathinfo_len = 0;
 420         char *strtok_buf = NULL;
 421 
 422         /* Get SCRIPT_NAME, we use this to work out which bit of the URL
 423          * belongs in PHP's version of PATH_INFO
 424          */
 425         lpECB->GetServerVariable(lpECB->ConnID, "SCRIPT_NAME", static_variable_buf, &scriptname_len);
 426 
 427         /* Adjust Zeus' version of PATH_INFO, set PHP_SELF,
 428          * and generate REQUEST_URI
 429          */
 430         if ( lpECB->GetServerVariable(lpECB->ConnID, "PATH_INFO", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
 431 
 432                 /* PHP_SELF is just PATH_INFO */
 433                 php_register_variable( "PHP_SELF", static_variable_buf, track_vars_array TSRMLS_CC );
 434 
 435                 /* Chop off filename to get just the 'real' PATH_INFO' */
 436                 pathinfo_len = variable_len - scriptname_len;
 437                 php_register_variable( "PATH_INFO", static_variable_buf + scriptname_len - 1, track_vars_array TSRMLS_CC );
 438                 /* append query string to give url... extra byte for '?' */
 439                 if ( strlen(lpECB->lpszQueryString) + variable_len + 1 < ISAPI_SERVER_VAR_BUF_SIZE ) {
 440                         /* append query string only if it is present... */
 441                         if ( strlen(lpECB->lpszQueryString) ) {
 442                                 static_variable_buf[ variable_len - 1 ] = '?';
 443                                 strcpy( static_variable_buf + variable_len, lpECB->lpszQueryString );
 444                         }
 445                         php_register_variable( "URL", static_variable_buf, track_vars_array TSRMLS_CC );
 446                         php_register_variable( "REQUEST_URI", static_variable_buf, track_vars_array TSRMLS_CC );
 447                 }
 448         }
 449 
 450         /* Get and adjust PATH_TRANSLATED to what PHP wants */
 451         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 452         if ( lpECB->GetServerVariable(lpECB->ConnID, "PATH_TRANSLATED", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
 453                 static_variable_buf[ variable_len - pathinfo_len - 1 ] = '\0';
 454                 php_register_variable( "PATH_TRANSLATED", static_variable_buf, track_vars_array TSRMLS_CC );
 455         }
 456 
 457         /* Bring in the AUTHENTICATION stuff as needed */
 458         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 459         if ( lpECB->GetServerVariable(lpECB->ConnID, "AUTH_USER", static_variable_buf, &variable_len) && static_variable_buf[0] )  {
 460                 php_register_variable( "PHP_AUTH_USER", static_variable_buf, track_vars_array TSRMLS_CC );
 461         }
 462         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 463         if ( lpECB->GetServerVariable(lpECB->ConnID, "AUTH_PASSWORD", static_variable_buf, &variable_len) && static_variable_buf[0] )  {
 464                 php_register_variable( "PHP_AUTH_PW", static_variable_buf, track_vars_array TSRMLS_CC );
 465         }
 466         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 467         if ( lpECB->GetServerVariable(lpECB->ConnID, "AUTH_TYPE", static_variable_buf, &variable_len) && static_variable_buf[0] )  {
 468                 php_register_variable( "AUTH_TYPE", static_variable_buf, track_vars_array TSRMLS_CC );
 469         }
 470         
 471         /* And now, for the SSL variables (if applicable) */
 472         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 473         if ( lpECB->GetServerVariable(lpECB->ConnID, "CERT_COOKIE", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
 474                 sapi_isapi_register_zeus_ssl_variables( lpECB, track_vars_array TSRMLS_CC );
 475         }
 476         /* Copy some of the variables we need to meet Apache specs */
 477         variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 478         if ( lpECB->GetServerVariable(lpECB->ConnID, "SERVER_SOFTWARE", static_variable_buf, &variable_len) && static_variable_buf[0] )  {
 479                 php_register_variable( "SERVER_SIGNATURE", static_variable_buf, track_vars_array TSRMLS_CC );
 480         }
 481 }
 482 #else
 483 
 484 static void sapi_isapi_register_iis_variables(LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array TSRMLS_DC)
 485 {
 486         char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 487         char path_info_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 488         DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 489         DWORD scriptname_len = ISAPI_SERVER_VAR_BUF_SIZE;
 490         DWORD pathinfo_len = 0;
 491         HSE_URL_MAPEX_INFO humi;
 492 
 493         /* Get SCRIPT_NAME, we use this to work out which bit of the URL
 494          * belongs in PHP's version of PATH_INFO.  SCRIPT_NAME also becomes PHP_SELF.
 495          */
 496         lpECB->GetServerVariable(lpECB->ConnID, "SCRIPT_NAME", static_variable_buf, &scriptname_len);
 497         php_register_variable("SCRIPT_FILENAME", SG(request_info).path_translated, track_vars_array TSRMLS_CC);
 498 
 499         /* Adjust IIS' version of PATH_INFO, set PHP_SELF,
 500          * and generate REQUEST_URI
 501          * Get and adjust PATH_TRANSLATED to what PHP wants
 502          */
 503         if ( lpECB->GetServerVariable(lpECB->ConnID, "PATH_INFO", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
 504 
 505                 /* Chop off filename to get just the 'real' PATH_INFO' */
 506                 php_register_variable( "ORIG_PATH_INFO", static_variable_buf, track_vars_array TSRMLS_CC );
 507                 pathinfo_len = variable_len - scriptname_len;
 508                 strncpy(path_info_buf, static_variable_buf + scriptname_len - 1, sizeof(path_info_buf)-1);
 509                 php_register_variable( "PATH_INFO", path_info_buf, track_vars_array TSRMLS_CC );
 510                 /* append query string to give url... extra byte for '?' */
 511                 if ( strlen(lpECB->lpszQueryString) + variable_len + 1 < ISAPI_SERVER_VAR_BUF_SIZE ) {
 512                         /* append query string only if it is present... */
 513                         if ( strlen(lpECB->lpszQueryString) ) {
 514                                 static_variable_buf[ variable_len - 1 ] = '?';
 515                                 strcpy( static_variable_buf + variable_len, lpECB->lpszQueryString );
 516                         }
 517                         php_register_variable( "URL", static_variable_buf, track_vars_array TSRMLS_CC );
 518                         php_register_variable( "REQUEST_URI", static_variable_buf, track_vars_array TSRMLS_CC );
 519                 }
 520                 variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 521                 if ( lpECB->GetServerVariable(lpECB->ConnID, "PATH_TRANSLATED", static_variable_buf, &variable_len) && static_variable_buf[0] ) {
 522                         php_register_variable( "ORIG_PATH_TRANSLATED", static_variable_buf, track_vars_array TSRMLS_CC );
 523                 }
 524                 if (lpECB->ServerSupportFunction(lpECB->ConnID, HSE_REQ_MAP_URL_TO_PATH_EX, path_info_buf, &pathinfo_len, (LPDWORD) &humi)) {
 525                         /* Remove trailing \  */
 526                         if (humi.lpszPath[variable_len-2] == '\\') {
 527                                 humi.lpszPath[variable_len-2] = 0;
 528                         }
 529                         php_register_variable("PATH_TRANSLATED", humi.lpszPath, track_vars_array TSRMLS_CC);
 530                 }
 531         }
 532 
 533         static_variable_buf[0] = '/';
 534         static_variable_buf[1] = 0;
 535         variable_len = 2;
 536         if (lpECB->ServerSupportFunction(lpECB->ConnID, HSE_REQ_MAP_URL_TO_PATH_EX, static_variable_buf, &variable_len, (LPDWORD) &humi)) {
 537                 /* Remove trailing \  */
 538                 if (humi.lpszPath[variable_len-2] == '\\') {
 539                         humi.lpszPath[variable_len-2] = 0;
 540                 }
 541                 php_register_variable("DOCUMENT_ROOT", humi.lpszPath, track_vars_array TSRMLS_CC);
 542         }
 543 
 544         if (!SG(request_info).auth_user || !SG(request_info).auth_password || 
 545                 !SG(request_info).auth_user[0] || !SG(request_info).auth_password[0]) {
 546                 variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 547                 if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_AUTHORIZATION", static_variable_buf, &variable_len)
 548                         && static_variable_buf[0]) {
 549                         php_handle_auth_data(static_variable_buf TSRMLS_CC);
 550                 }
 551         }
 552 
 553         if (SG(request_info).auth_user)  {
 554                 php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, track_vars_array TSRMLS_CC );
 555         }
 556         if (SG(request_info).auth_password) {
 557                 php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, track_vars_array TSRMLS_CC );
 558         }
 559 }
 560 #endif
 561 
 562 static void sapi_isapi_register_server_variables2(char **server_variables, LPEXTENSION_CONTROL_BLOCK lpECB, zval *track_vars_array, char **recorded_values TSRMLS_DC)
 563 {
 564         char **p=server_variables;
 565         DWORD variable_len;
 566         char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 567         char *variable_buf;
 568 
 569         while (*p) {
 570                 variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 571                 if (lpECB->GetServerVariable(lpECB->ConnID, *p, static_variable_buf, &variable_len)
 572                         && static_variable_buf[0]) {
 573                         php_register_variable(*p, static_variable_buf, track_vars_array TSRMLS_CC);
 574                         if (recorded_values) {
 575                                 recorded_values[p-server_variables] = estrndup(static_variable_buf, variable_len);
 576                         }
 577                 } else if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 578                         variable_buf = (char *) emalloc(variable_len+1);
 579                         if (lpECB->GetServerVariable(lpECB->ConnID, *p, variable_buf, &variable_len)
 580                                 && variable_buf[0]) {
 581                                 php_register_variable(*p, variable_buf, track_vars_array TSRMLS_CC);
 582                         }
 583                         if (recorded_values) {
 584                                 recorded_values[p-server_variables] = variable_buf;
 585                         } else {
 586                                 efree(variable_buf);
 587                         }
 588                 } else { /* for compatibility with Apache SAPIs */
 589                         php_register_variable(*p, "", track_vars_array TSRMLS_CC);
 590                 }
 591                 p++;
 592         }
 593 }
 594 
 595 
 596 static void sapi_isapi_register_server_variables(zval *track_vars_array TSRMLS_DC)
 597 {
 598         DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 599         char *variable;
 600         char *strtok_buf = NULL;
 601         char *isapi_special_server_variables[NUM_SPECIAL_VARS];
 602         LPEXTENSION_CONTROL_BLOCK lpECB;
 603 
 604         lpECB = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 605 
 606         /* Register the special ISAPI variables */
 607         memset(isapi_special_server_variables, 0, sizeof(isapi_special_server_variables));
 608         sapi_isapi_register_server_variables2(isapi_special_server_variable_names, lpECB, track_vars_array, isapi_special_server_variables TSRMLS_CC);
 609         if (SG(request_info).cookie_data) {
 610                 php_register_variable("HTTP_COOKIE", SG(request_info).cookie_data, track_vars_array TSRMLS_CC);
 611         }
 612 
 613         /* Register the standard ISAPI variables */
 614         sapi_isapi_register_server_variables2(isapi_server_variable_names, lpECB, track_vars_array, NULL TSRMLS_CC);
 615 
 616         if (isapi_special_server_variables[SPECIAL_VAR_HTTPS]
 617                 && (atoi(isapi_special_server_variables[SPECIAL_VAR_HTTPS])
 618                 || !strcasecmp(isapi_special_server_variables[SPECIAL_VAR_HTTPS], "on"))
 619         ) {
 620                 /* Register SSL ISAPI variables */
 621                 sapi_isapi_register_server_variables2(isapi_secure_server_variable_names, lpECB, track_vars_array, NULL TSRMLS_CC);
 622         }
 623 
 624         if (isapi_special_server_variables[SPECIAL_VAR_HTTPS]) {
 625                 efree(isapi_special_server_variables[SPECIAL_VAR_HTTPS]);
 626         }
 627 
 628 
 629 #ifdef WITH_ZEUS
 630         sapi_isapi_register_zeus_variables(lpECB, track_vars_array TSRMLS_CC);
 631 #else
 632         sapi_isapi_register_iis_variables(lpECB, track_vars_array TSRMLS_CC);
 633 #endif
 634 
 635         /* PHP_SELF support */
 636         if (isapi_special_server_variables[SPECIAL_VAR_PHP_SELF]) {
 637                 php_register_variable("PHP_SELF", isapi_special_server_variables[SPECIAL_VAR_PHP_SELF], track_vars_array TSRMLS_CC);
 638                 efree(isapi_special_server_variables[SPECIAL_VAR_PHP_SELF]);
 639         }
 640 
 641         if (isapi_special_server_variables[SPECIAL_VAR_ALL_HTTP]) {
 642                 /* Register the internal bits of ALL_HTTP */
 643                 variable = php_strtok_r(isapi_special_server_variables[SPECIAL_VAR_ALL_HTTP], "\r\n", &strtok_buf);
 644                 while (variable) {
 645                         char *colon = strchr(variable, ':');
 646 
 647                         if (colon) {
 648                                 char *value = colon+1;
 649 
 650                                 while (*value==' ') {
 651                                         value++;
 652                                 }
 653                                 *colon = 0;
 654                                 php_register_variable(variable, value, track_vars_array TSRMLS_CC);
 655                                 *colon = ':';
 656                         }
 657                         variable = php_strtok_r(NULL, "\r\n", &strtok_buf);
 658                 }
 659                 efree(isapi_special_server_variables[SPECIAL_VAR_ALL_HTTP]);
 660         }
 661 }
 662 
 663 
 664 static sapi_module_struct isapi_sapi_module = {
 665         "isapi",                                                /* name */
 666         "ISAPI",                                                /* pretty name */
 667                                                                         
 668         php_isapi_startup,                              /* startup */
 669         php_module_shutdown_wrapper,    /* shutdown */
 670 
 671         NULL,                                                   /* activate */
 672         NULL,                                                   /* deactivate */
 673 
 674         sapi_isapi_ub_write,                    /* unbuffered write */
 675         NULL,                                                   /* flush */
 676         NULL,                                                   /* get uid */
 677         NULL,                                                   /* getenv */
 678 
 679         php_error,                                              /* error handler */
 680 
 681         sapi_isapi_header_handler,              /* header handler */
 682         sapi_isapi_send_headers,                /* send headers handler */
 683         NULL,                                                   /* send header handler */
 684 
 685         sapi_isapi_read_post,                   /* read POST data */
 686         sapi_isapi_read_cookies,                /* read Cookies */
 687 
 688         sapi_isapi_register_server_variables,   /* register server variables */
 689         NULL,                                                   /* Log message */
 690         NULL,                                                   /* Get request time */
 691         NULL,                                                   /* Child terminate */
 692 
 693         STANDARD_SAPI_MODULE_PROPERTIES
 694 };
 695 
 696 
 697 BOOL WINAPI GetFilterVersion(PHTTP_FILTER_VERSION pFilterVersion)
 698 {
 699         bFilterLoaded = 1;
 700         pFilterVersion->dwFilterVersion = HTTP_FILTER_REVISION;
 701         strcpy(pFilterVersion->lpszFilterDesc, isapi_sapi_module.pretty_name);
 702         pFilterVersion->dwFlags= (SF_NOTIFY_AUTHENTICATION | SF_NOTIFY_PREPROC_HEADERS);
 703         return TRUE;
 704 }
 705 
 706 
 707 DWORD WINAPI HttpFilterProc(PHTTP_FILTER_CONTEXT pfc, DWORD notificationType, LPVOID pvNotification)
 708 {
 709         TSRMLS_FETCH();
 710 
 711         switch (notificationType) {
 712                 case SF_NOTIFY_PREPROC_HEADERS:
 713                         SG(request_info).auth_user = NULL;
 714                         SG(request_info).auth_password = NULL;
 715                         SG(request_info).auth_digest = NULL;
 716                         break;
 717                 case SF_NOTIFY_AUTHENTICATION: {
 718                                 char *auth_user = ((HTTP_FILTER_AUTHENT *) pvNotification)->pszUser;
 719                                 char *auth_password = ((HTTP_FILTER_AUTHENT *) pvNotification)->pszPassword;
 720 
 721                                 if (auth_user && auth_user[0]) {
 722                                         SG(request_info).auth_user = estrdup(auth_user);
 723                                 }       
 724                                 if (auth_password && auth_password[0]) {
 725                                         SG(request_info).auth_password = estrdup(auth_password);
 726                                 }
 727                                 return SF_STATUS_REQ_HANDLED_NOTIFICATION;
 728                         }
 729                         break;
 730         }
 731         return SF_STATUS_REQ_NEXT_NOTIFICATION;
 732 }
 733 
 734 
 735 static void init_request_info(LPEXTENSION_CONTROL_BLOCK lpECB TSRMLS_DC)
 736 {
 737         DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE;
 738         char static_variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];
 739 #ifndef WITH_ZEUS
 740         HSE_URL_MAPEX_INFO humi;
 741 #endif
 742 
 743         SG(request_info).request_method = lpECB->lpszMethod;
 744         SG(request_info).query_string = lpECB->lpszQueryString;
 745         SG(request_info).request_uri = lpECB->lpszPathInfo;
 746         SG(request_info).content_type = lpECB->lpszContentType;
 747         SG(request_info).content_length = lpECB->cbTotalBytes;
 748         SG(sapi_headers).http_response_code = 200;  /* I think dwHttpStatusCode is invalid at this stage -RL */
 749         if (!bFilterLoaded) { /* we don't have valid ISAPI Filter information */
 750                 SG(request_info).auth_user = SG(request_info).auth_password = SG(request_info).auth_digest = NULL;
 751         }
 752 
 753 #ifdef WITH_ZEUS
 754         /* PATH_TRANSLATED can contain extra PATH_INFO stuff after the
 755          * file being loaded, so we must use SCRIPT_FILENAME instead
 756          */
 757         if(lpECB->GetServerVariable(lpECB->ConnID, "SCRIPT_FILENAME", static_variable_buf, &variable_len)) {
 758                 SG(request_info).path_translated = estrdup(static_variable_buf);
 759         } else 
 760 #else
 761         /* happily, IIS gives us SCRIPT_NAME which is correct (without PATH_INFO stuff)
 762            so we can just map that to the physical path and we have our filename */
 763 
 764         lpECB->GetServerVariable(lpECB->ConnID, "SCRIPT_NAME", static_variable_buf, &variable_len);
 765         if (lpECB->ServerSupportFunction(lpECB->ConnID, HSE_REQ_MAP_URL_TO_PATH_EX, static_variable_buf, &variable_len, (LPDWORD) &humi)) {
 766                 SG(request_info).path_translated = estrdup(humi.lpszPath);
 767         } else 
 768 #endif
 769                 /* if mapping fails, default to what the server tells us */
 770                 SG(request_info).path_translated = estrdup(lpECB->lpszPathTranslated);
 771 
 772         /* some server configurations allow '..' to slip through in the
 773            translated path.   We'll just refuse to handle such a path. */
 774         if (strstr(SG(request_info).path_translated,"..")) {
 775                 SG(sapi_headers).http_response_code = 404;
 776                 efree(SG(request_info).path_translated);
 777                 SG(request_info).path_translated = NULL;
 778         }
 779 }
 780 
 781 
 782 static void php_isapi_report_exception(char *message, int message_len TSRMLS_DC)
 783 {
 784         if (!SG(headers_sent)) {
 785                 HSE_SEND_HEADER_EX_INFO header_info;
 786                 LPEXTENSION_CONTROL_BLOCK lpECB = (LPEXTENSION_CONTROL_BLOCK) SG(server_context);
 787 
 788                 header_info.pszStatus = "500 Internal Server Error";
 789                 header_info.cchStatus = strlen(header_info.pszStatus);
 790                 header_info.pszHeader = "Content-Type: text/html\r\n\r\n";
 791                 header_info.cchHeader = strlen(header_info.pszHeader);
 792 
 793                 lpECB->dwHttpStatusCode = 500;
 794                 lpECB->ServerSupportFunction(lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);
 795                 SG(headers_sent)=1;
 796         }
 797         sapi_isapi_ub_write(message, message_len TSRMLS_CC);
 798 }
 799 
 800 
 801 BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO *pVer)
 802 {
 803         pVer->dwExtensionVersion = HSE_VERSION;
 804 #ifdef WITH_ZEUS
 805         strncpy( pVer->lpszExtensionDesc, isapi_sapi_module.name, HSE_MAX_EXT_DLL_NAME_LEN);
 806 #else
 807         lstrcpyn(pVer->lpszExtensionDesc, isapi_sapi_module.name, HSE_MAX_EXT_DLL_NAME_LEN);
 808 #endif
 809         return TRUE;
 810 }
 811 
 812 
 813 static void my_endthread()
 814 {
 815 #ifdef PHP_WIN32
 816         if (bTerminateThreadsOnError) {
 817                 _endthread();
 818         }
 819 #endif
 820 }
 821 
 822 #ifdef PHP_WIN32
 823 /* ep is accessible only in the context of the __except expression,
 824  * so we have to call this function to obtain it.
 825  */
 826 BOOL exceptionhandler(LPEXCEPTION_POINTERS *e, LPEXCEPTION_POINTERS ep)
 827 {
 828         *e=ep;
 829         return TRUE;
 830 }
 831 #endif
 832 
 833 DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK lpECB)
 834 {
 835         zend_file_handle file_handle;
 836         zend_bool stack_overflown=0;
 837         int retval = FAILURE;
 838 #ifdef PHP_ENABLE_SEH
 839         LPEXCEPTION_POINTERS e;
 840 #endif
 841         TSRMLS_FETCH();
 842 
 843         zend_first_try {
 844 #ifdef PHP_ENABLE_SEH
 845                 __try {
 846 #endif
 847                         init_request_info(lpECB TSRMLS_CC);
 848                         SG(server_context) = lpECB;
 849 
 850                         php_request_startup(TSRMLS_C);
 851 
 852                         file_handle.filename = SG(request_info).path_translated;
 853                         file_handle.free_filename = 0;
 854                         file_handle.type = ZEND_HANDLE_FILENAME;
 855                         file_handle.opened_path = NULL;
 856 
 857                         /* open the script here so we can 404 if it fails */
 858                         if (file_handle.filename)
 859                                 retval = php_fopen_primary_script(&file_handle TSRMLS_CC);
 860 
 861                         if (!file_handle.filename || retval == FAILURE) {
 862                                 SG(sapi_headers).http_response_code = 404;
 863                                 PUTS("No input file specified.\n");
 864                         } else {
 865                                 php_execute_script(&file_handle TSRMLS_CC);
 866                         }
 867 
 868                         if (SG(request_info).cookie_data) {
 869                                 efree(SG(request_info).cookie_data);
 870                         }
 871                         if (SG(request_info).path_translated)
 872                                 efree(SG(request_info).path_translated);
 873 #ifdef PHP_ENABLE_SEH
 874                 } __except(exceptionhandler(&e, GetExceptionInformation())) {
 875                         char buf[1024];
 876                         if (_exception_code()==EXCEPTION_STACK_OVERFLOW) {
 877                                 LPBYTE lpPage;
 878                                 static SYSTEM_INFO si;
 879                                 static MEMORY_BASIC_INFORMATION mi;
 880                                 static DWORD dwOldProtect;
 881 
 882                                 GetSystemInfo(&si);
 883 
 884                                 /* Get page ESP is pointing to */
 885                                 _asm mov lpPage, esp;
 886 
 887                                 /* Get stack allocation base */
 888                                 VirtualQuery(lpPage, &mi, sizeof(mi));
 889 
 890                                 /* Go to the page below the current page */
 891                                 lpPage = (LPBYTE) (mi.BaseAddress) - si.dwPageSize;
 892 
 893                                 /* Free pages below current page */
 894                                 if (!VirtualFree(mi.AllocationBase, (LPBYTE)lpPage - (LPBYTE) mi.AllocationBase, MEM_DECOMMIT)) {
 895                                         _endthread();
 896                                 }
 897 
 898                                 /* Restore the guard page */
 899                                 if (!VirtualProtect(lpPage, si.dwPageSize, PAGE_GUARD | PAGE_READWRITE, &dwOldProtect)) {
 900                                         _endthread();
 901                                 }
 902 
 903                                 CG(unclean_shutdown)=1;
 904                                 _snprintf(buf, sizeof(buf)-1,"PHP has encountered a Stack overflow");
 905                                 php_isapi_report_exception(buf, strlen(buf) TSRMLS_CC);
 906                         } else if (_exception_code()==EXCEPTION_ACCESS_VIOLATION) {
 907                                 _snprintf(buf, sizeof(buf)-1,"PHP has encountered an Access Violation at %p", e->ExceptionRecord->ExceptionAddress);
 908                                 php_isapi_report_exception(buf, strlen(buf) TSRMLS_CC);
 909                                 my_endthread();
 910                         } else {
 911                                 _snprintf(buf, sizeof(buf)-1,"PHP has encountered an Unhandled Exception Code %d at %p", e->ExceptionRecord->ExceptionCode , e->ExceptionRecord->ExceptionAddress);
 912                                 php_isapi_report_exception(buf, strlen(buf) TSRMLS_CC);
 913                                 my_endthread();
 914                         }
 915                 }
 916 #endif
 917 #ifdef PHP_ENABLE_SEH
 918                 __try {
 919                         php_request_shutdown(NULL);
 920                 } __except(EXCEPTION_EXECUTE_HANDLER) {
 921                         my_endthread();
 922                 }
 923 #else
 924                 php_request_shutdown(NULL);
 925 #endif
 926         } zend_catch {
 927                 zend_try {
 928                         php_request_shutdown(NULL);
 929                 } zend_end_try();
 930                 return HSE_STATUS_ERROR;
 931         } zend_end_try();
 932 
 933         return HSE_STATUS_SUCCESS;
 934 }
 935 
 936 
 937 
 938 __declspec(dllexport) BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 939 {
 940         switch (fdwReason) {
 941                 case DLL_PROCESS_ATTACH:
 942 #ifdef WITH_ZEUS
 943                         tsrm_startup(128, 1, TSRM_ERROR_LEVEL_CORE, "TSRM.log");
 944 #else
 945                         tsrm_startup(128, 1, TSRM_ERROR_LEVEL_CORE, "C:\\TSRM.log");
 946 #endif
 947                         sapi_startup(&isapi_sapi_module);
 948                         if (isapi_sapi_module.startup) {
 949                                 isapi_sapi_module.startup(&sapi_module);
 950                         }
 951                         break;
 952                 case DLL_THREAD_ATTACH:
 953                         break;
 954                 case DLL_THREAD_DETACH:
 955                         ts_free_thread();
 956                         break;
 957                 case DLL_PROCESS_DETACH:
 958                         if (isapi_sapi_module.shutdown) {
 959                                 isapi_sapi_module.shutdown(&sapi_module);
 960                         }
 961                         sapi_shutdown();
 962                         tsrm_shutdown();
 963                         break;
 964         }
 965         return TRUE;
 966 }
 967 
 968 /*
 969  * Local variables:
 970  * tab-width: 4
 971  * c-basic-offset: 4
 972  * End:
 973  */
/* [<][>][^][v][top][bottom][index][help] */
root/sapi/isapi/php5isapi.c

DEFINITIONS
