Annotation of embedaddon/php/sapi/isapi/php5isapi.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 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: php5isapi.c 321634 2012-01-01 13:15:04Z felipe $ */
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: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php5isapi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / sapi / isapi