parser3/src/targets/isapi/parser3isapi.C - diff

Return to parser3isapi.C CVS log

Up to [parser3project] / parser3 / src / targets / isapi

Diff for /parser3/src/targets/isapi/parser3isapi.C between versions 1.82.2.2 and 1.82.2.6.2.6

version 1.82.2.2, 2003/01/31 16:05:59	version 1.82.2.6.2.6, 2003/04/08 13:58:30
Line 22 static const char* IDENT_PARSER3ISAPI_C=	Line 22 static const char* IDENT_PARSER3ISAPI_C=

#include <windows.h>	#include <windows.h>
#include <process.h>	#include <process.h>
#include <new.h>

#include <httpext.h>	#include <httpext.h>

Line 67 struct SAPI_func_context {	Line 66 struct SAPI_func_context {
#endif	#endif

// goes to 'cs-uri-query' log file field. webmaster: switch it ON[default OFF].	// goes to 'cs-uri-query' log file field. webmaster: switch it ON[default OFF].
void SAPI::log(Pool& pool, const char* fmt, ...) {	void SAPI::logconst char* fmt, ...) {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());

va_list args;	va_list args;
Line 84 void SAPI::log(Pool& pool, const char* f	Line 83 void SAPI::log(Pool& pool, const char* f
}	}

/// @todo event log	/// @todo event log
void SAPI::die(const char* fmt, ...) {	static void die_or_abort(const char* fmt, va_list args, bool write_core) {
if(FILE *log=fopen("c:\\die.log", "at")) {	if(FILE *log=fopen("c:\\parser3die.log", "at")) {
va_list args;
va_start(args,fmt);
vfprintf(log, fmt, args);	vfprintf(log, fmt, args);
fclose(log);	fclose(log);
}	}
// exit & try to produce core dump	// exit & try to produce core dump
abort();	abort();
}	}
	void SAPI::die(const char* fmt, ...) {
	va_list args;
	va_start(args, fmt);
	die_or_abort(fmt, args, false/write core?/);
	va_end(args);
	}

const char* SAPI::get_env(Pool& pool, const char* name) {	void SAPI::abort(const char* fmt, ...) {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	va_list args;
	va_start(args, fmt);
	die_or_abort(fmt, args, true/write core?/);
	va_end(args);
	}

char variable_buf=(char )pool.malloc(MAX_STRING);	const char* SAPI::get_envconst char* name) {
	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());
	char *variable_buf=new(PointerFreeGC) char[MAX_STRING];
DWORD variable_len = MAX_STRING-1;	DWORD variable_len = MAX_STRING-1;

if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name),	if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name),
Line 108 const char* SAPI::get_env(Pool& pool, co	Line 117 const char* SAPI::get_env(Pool& pool, co
return variable_buf;	return variable_buf;
}	}
} else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {	} else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
variable_buf=(char *)pool.malloc(variable_len+1);	variable_buf=new(PointerFreeGC) char[variable_len+1];

if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name),	if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name),
variable_buf, &variable_len)) {	variable_buf, &variable_len)) {
Line 132 static int grep_char(const char* s, char	Line 141 static int grep_char(const char* s, char
}	}
return result;	return result;
}	}
static const char* mk_env_pair(Pool& pool, const char* key, const char* value) {	static const char* mk_env_pairconst char* key, const char* value) {
char result=(char )pool.malloc(strlen(key)+1/=/+strlen(value)+1/0/);	char result=new(PointerFreeGC) char[strlen(key)+1/=/+strlen(value)+1/0*/];
strcpy(result, key); strcat(result, "="); strcat(result, value);	strcpy(result, key); strcat(result, "="); strcat(result, value);
return result;	return result;
}	}
const char* const *SAPI::environment(Pool& pool) {	const char* const *SAPI::environment(SAPI_Info& info, ) {
// we know this buf is writable	// we know this buf is writable
char all_http_vars=const_cast<char >(SAPI::get_env(pool, "ALL_HTTP"));	const char* all_http_vars=SAPI::get_env("ALL_HTTP");
const int http_var_count=grep_char(all_http_vars, '\n')+1/\n for theoretical(never saw) this \0/;	const int http_var_count=grep_char(all_http_vars, '\n')+1/\n for theoretical(never saw) this \0/;

const char* *result=	const char* result=new const char[IIS51var_count+http_var_count+1/0/];
(const char* )pool.malloc(sizeof(char )(IIS51var_count+http_var_count+1/0*/));
const char* *cur=result;	const char* *cur=result;

// IIS5.1 vars	// IIS5.1 vars
for(int i=0; i<IIS51var_count; i++) {	for(int i=0; i<IIS51var_count; i++) {
const char* key=IIS51vars[i];	const char* key=IIS51vars[i];
if(const char* value=SAPI::get_env(pool, key))	if(const char* value=SAPI::get_env(key))
*cur++=mk_env_pair(pool, key, value);	*cur++=mk_env_pair(key, value);
}	}

// HTTP_* vars	// HTTP_* vars
if(char *s=all_http_vars) {	if(char *s=all_http_vars) {
while(char *key=lsplit(&s, '\n'))	while(char *key=lsplit(&s, '\n'))
if(char *value=lsplit(key, ':'))	if(char *value=lsplit(key, ':'))
*cur++=mk_env_pair(pool, key, value);	*cur++=mk_env_pair(key, value);
}	}

// mark EOE	// mark EOE
Line 166 const char* const *SAPI::environment(Poo	Line 174 const char* const *SAPI::environment(Poo
return result;	return result;
}	}

size_t SAPI::read_post(Pool& pool, char *buf, size_t max_bytes) {	size_t SAPI::read_postchar *buf, size_t max_bytes) {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());

DWORD read_from_buf=0;	DWORD read_from_buf=0;
Line 196 size_t SAPI::read_post(Pool& pool, char	Line 204 size_t SAPI::read_post(Pool& pool, char
return total_read;	return total_read;
}	}

void SAPI::add_header_attribute(Pool& pool,	void SAPI::add_header_attribute
const char* dont_store_key, const char* dont_store_value) {	const char* dont_store_key, const char* dont_store_value) {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());

Line 215 todo: copy dont_store_ to nonvilotile	Line 223 todo: copy dont_store_ to nonvilotile
}	}

/// @todo intelligent cache-control	/// @todo intelligent cache-control
void SAPI::send_header(Pool& pool) {	void SAPI::send_header() {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());

HSE_SEND_HEADER_EX_INFO header_info;	HSE_SEND_HEADER_EX_INFO header_info;
Line 240 void SAPI::send_header(Pool& pool) {	Line 248 void SAPI::send_header(Pool& pool) {
header_info.cchStatus=strlen(header_info.pszStatus);	header_info.cchStatus=strlen(header_info.pszStatus);
*ctx.header << "\r\n"; // ISAPI v<5 did quite well without it	*ctx.header << "\r\n"; // ISAPI v<5 did quite well without it
header_info.pszHeader=ctx.header->cstr();	header_info.pszHeader=ctx.header->cstr();
header_info.cchHeader=ctx.header->size();	header_info.cchHeader=ctx.header->length();
header_info.fKeepConn=true;	header_info.fKeepConn=true;

ctx.lpECB->dwHttpStatusCode=ctx.http_response_code;	ctx.lpECB->dwHttpStatusCode=ctx.http_response_code;
Line 249 void SAPI::send_header(Pool& pool) {	Line 257 void SAPI::send_header(Pool& pool) {
HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);	HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);
}	}

void SAPI::send_body(Pool& pool, const void *buf, size_t size) {	void SAPI::send_bodyconst void *buf, size_t size) {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());

DWORD num_bytes=size;	DWORD num_bytes=size;
Line 257 void SAPI::send_body(Pool& pool, const v	Line 265 void SAPI::send_body(Pool& pool, const v
const_cast<void *>(buf), &num_bytes, HSE_IO_SYNC);	const_cast<void *>(buf), &num_bytes, HSE_IO_SYNC);
}	}

//

int failed_new(size_t size) {
SAPI::die("out of memory in 'new', failed to allocated %u bytes", size);
return 0; // not reached
}

#ifdef _DEBUG
static Pool_storage *global_pool_storagep;
#endif
static bool parser_init() {	static bool parser_init() {
static bool globals_inited=false;	static bool globals_inited=false;
if(globals_inited)	if(globals_inited)
return true;	return true;
globals_inited=true;	globals_inited=true;

_set_new_handler(failed_new);

static Pool_storage pool_storage;
#ifdef _DEBUG
global_pool_storagep=&pool_storage;
#endif
static Pool pool(&pool_storage); // global pool	static Pool pool(&pool_storage); // global pool
try {	try {
// init socks	// init socks
init_socks(pool);	pa_init_socks();
// init global classes	// init global classes
init_methoded_array(pool);	init_methoded_array();
// init global variables	// init global variables
pa_globals_init(pool);	pa_globals_init();

// successful finish	// successful finish
return true;	return true;
Line 318 BOOL WINAPI GetExtensionVersion(HSE_VERS	Line 311 BOOL WINAPI GetExtensionVersion(HSE_VERS
PARSER_VERSION from outside	PARSER_VERSION from outside
*/	*/

void real_parser_handler(Pool& pool, LPEXTENSION_CONTROL_BLOCK lpECB, bool header_only) {	void real_parser_handlerLPEXTENSION_CONTROL_BLOCK lpECB, bool header_only) {
static_cast<SAPI_func_context *>(pool.get_context())->header=new(pool) String(pool);	static_cast<SAPI_func_context *>(pool.get_context())->header=new String;

// Request info	// Request info
Request::Info request_info;	Request::Info request_info;

size_t path_translated_buf_size=strlen(lpECB->lpszPathTranslated)+1;	size_t path_translated_buf_size=strlen(lpECB->lpszPathTranslated)+1;
char filespec_to_process=(char )pool.malloc(path_translated_buf_size);	char *filespec_to_process=pool.copy(lpECB->lpszPathTranslated, path_translated_buf_size);
memcpy(filespec_to_process, lpECB->lpszPathTranslated, path_translated_buf_size);
#ifdef WIN32	#ifdef WIN32
back_slashes_to_slashes(filespec_to_process);	back_slashes_to_slashes(filespec_to_process);
#endif	#endif

if(const char* path_info=SAPI::get_env(pool, "PATH_INFO")) {	if(const char* path_info=SAPI::get_env("PATH_INFO")) {
// IIS	// IIS
size_t len=strlen(filespec_to_process)-strlen(path_info);	size_t len=strlen(filespec_to_process)-strlen(path_info);
char buf=(char )pool.malloc(len+1);	char *buf=new(PointerFreeGC) char[len+1];
strncpy(buf, filespec_to_process, len); buf[len]=0;	strncpy(buf, filespec_to_process, len); buf[len]=0;
request_info.document_root=buf;	request_info.document_root=buf;
} else	} else
Line 346 void real_parser_handler(Pool& pool, LPE	Line 338 void real_parser_handler(Pool& pool, LPE
request_info.method=lpECB->lpszMethod;	request_info.method=lpECB->lpszMethod;
request_info.query_string=lpECB->lpszQueryString;	request_info.query_string=lpECB->lpszQueryString;
if(lpECB->lpszQueryString && *lpECB->lpszQueryString) {	if(lpECB->lpszQueryString && *lpECB->lpszQueryString) {
char reconstructed_uri=(char )pool.malloc(	char *reconstructed_uri=new(PointerFreeGC) char[
strlen(lpECB->lpszPathInfo)+1/'?'/+	strlen(lpECB->lpszPathInfo)+1/'?'/+
strlen(lpECB->lpszQueryString)+1/0/);	strlen(lpECB->lpszQueryString)+1/0/];
strcpy(reconstructed_uri, lpECB->lpszPathInfo);	strcpy(reconstructed_uri, lpECB->lpszPathInfo);
strcat(reconstructed_uri, "?");	strcat(reconstructed_uri, "?");
strcat(reconstructed_uri, lpECB->lpszQueryString);	strcat(reconstructed_uri, lpECB->lpszQueryString);
Line 358 void real_parser_handler(Pool& pool, LPE	Line 350 void real_parser_handler(Pool& pool, LPE

request_info.content_type=lpECB->lpszContentType;	request_info.content_type=lpECB->lpszContentType;
request_info.content_length=lpECB->cbTotalBytes;	request_info.content_length=lpECB->cbTotalBytes;
request_info.cookie=SAPI::get_env(pool, "HTTP_COOKIE");	request_info.cookie=SAPI::get_env("HTTP_COOKIE");
request_info.mail_received=false;	request_info.mail_received=false;

// prepare to process request	// prepare to process request
Request request(pool,	Request request(pool,
request_info,	request_info,
String::UL_HTML\|String::UL_OPTIMIZE_BIT,	String::L_HTML\|String::L_OPTIMIZE_BIT,
#ifdef _DEBUG	#ifdef _DEBUG
true	true
#else	#else
Line 393 void real_parser_handler(Pool& pool, LPE	Line 385 void real_parser_handler(Pool& pool, LPE
header_only);	header_only);
}	}

void call_real_parser_handler__do_SEH(Pool& pool,	void call_real_parser_handler__do_SEH
LPEXTENSION_CONTROL_BLOCK lpECB,	LPEXTENSION_CONTROL_BLOCK lpECB,
bool header_only) {	bool header_only) {
#if _MSC_VER & !defined(_DEBUG)	#if _MSC_VER & !defined(_DEBUG)
LPEXCEPTION_POINTERS system_exception=0;	LPEXCEPTION_POINTERS system_exception=0;
__try {	__try {
#endif	#endif
real_parser_handler(pool, lpECB, header_only);	real_parser_handler(lpECB, header_only);

#if _MSC_VER & !defined(_DEBUG)	#if _MSC_VER & !defined(_DEBUG)
} __except (	} __except (
Line 432 inline DWORD RealHttpExtensionProc(LPEXT	Line 424 inline DWORD RealHttpExtensionProc(LPEXT

bool header_only=strcasecmp(lpECB->lpszMethod, "HEAD")==0;	bool header_only=strcasecmp(lpECB->lpszMethod, "HEAD")==0;
try { // global try	try { // global try
call_real_parser_handler__do_SEH(pool, lpECB, header_only);	call_real_parser_handler__do_SEH(lpECB, header_only);
// successful finish	// successful finish
} catch(const Exception& e) { // global problem	} catch(const Exception& e) { // global problem
// don't allocate anything on pool here:	// don't allocate anything on pool here:
Line 440 inline DWORD RealHttpExtensionProc(LPEXT	Line 432 inline DWORD RealHttpExtensionProc(LPEXT
// and there could be out-of-memory exception	// and there could be out-of-memory exception
const char* body=e.comment();	const char* body=e.comment();
// log it	// log it
SAPI::log(pool, "exception in request exception handler: %s", body);	SAPI::log("exception in request exception handler: %s", body);

//	//
int content_length=strlen(body);	int content_length=strlen(body);
Line 468 inline DWORD RealHttpExtensionProc(LPEXT	Line 460 inline DWORD RealHttpExtensionProc(LPEXT

// send body	// send body
if(!header_only)	if(!header_only)
SAPI::send_body(pool, body, content_length);	SAPI::send_body(body, content_length);

// unsuccessful finish	// unsuccessful finish
}	}

E-mail:

Removed from v.1.82.2.2
changed lines
	Added in v.1.82.2.6.2.6