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.80 and 1.82.2.6.2.1

version 1.80, 2002/10/29 11:28:19	version 1.82.2.6.2.1, 2003/03/18 15:14:20
Line 1	Line 1
/** @file	/** @file
Parser: IIS extension.	Parser: IIS extension.

Copyright (c) 2000,2001, 2002 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2000,2001-2003 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

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 30 static const char* IDENT_PARSER3ISAPI_C=	Line 29 static const char* IDENT_PARSER3ISAPI_C=

// consts	// consts

const char *IIS51vars[]={	const char* IIS51vars[]={
"APPL_MD_PATH", "APPL_PHYSICAL_PATH",	"APPL_MD_PATH", "APPL_PHYSICAL_PATH",
"AUTH_PASSWORD", "AUTH_TYPE", "AUTH_USER",	"AUTH_PASSWORD", "AUTH_TYPE", "AUTH_USER",
"CERT_COOKIE", "CERT_FLAGS", "CERT_ISSUER", "CERT_KEYSIZE", "CERT_SECRETKEYSIZE",	"CERT_COOKIE", "CERT_FLAGS", "CERT_ISSUER", "CERT_KEYSIZE", "CERT_SECRETKEYSIZE",
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;
va_start(args,fmt);	va_start(args,fmt);
char buf[MAX_STRING];	char buf[MAX_STRING];
const char *prefix="PARSER_ERROR:";	const char* prefix="PARSER_ERROR:";
strcpy(buf, prefix);	strcpy(buf, prefix);
char *start=buf+strlen(prefix);	char *start=buf+strlen(prefix);
DWORD size=vsnprintf(start, MAX_STRING-strlen(prefix), fmt, args);	DWORD size=vsnprintf(start, MAX_STRING-strlen(prefix), fmt, 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(1);	// exit & try to produce core dump
	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);
	}

	void SAPI::abort(const char* fmt, ...) {
	va_list args;
	va_start(args, fmt);
	die_or_abort(fmt, args, true/write core?/);
	va_end(args);
}	}

const char SAPI::get_env(Pool& pool, const char name) {	const char* SAPI::get_envconst char* name) {
SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.get_context());

char variable_buf=(char )pool.malloc(MAX_STRING);	char *variable_buf=new 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 107 const char *SAPI::get_env(Pool& pool, co	Line 118 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 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 121 const char *SAPI::get_env(Pool& pool, co	Line 132 const char *SAPI::get_env(Pool& pool, co
return 0;	return 0;
}	}

static int grep_char(const char *s, char c) {	static int grep_char(const char* s, char c) {
int result=0;	int result=0;
if(s) {	if(s) {
while(s=strchr(s, c)) {	while(s=strchr(s, c)) {
Line 131 static int grep_char(const char *s, char	Line 142 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 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(pool, "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(pool, key))
*cur++=mk_env_pair(pool, key, value);	*cur++=mk_env_pair(pool, key, value);
}	}

Line 165 const char const SAPI::environment(Poo	Line 175 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 195 size_t SAPI::read_post(Pool& pool, char	Line 205 size_t SAPI::read_post(Pool& pool, char
return total_read;	return total_read;
}	}

void SAPI::add_header_attribute(Pool& pool, const char key, const char value) {	void SAPI::add_header_attribute
	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());

if(strcasecmp(key, "location")==0)	if(strcasecmp(key, "location")==0)
ctx.http_response_code=302;	ctx.http_response_code=302;

if(strcasecmp(key, "status")==0)	if(strcasecmp(key, "status")==0)
ctx.http_response_code=atoi(value);	ctx.http_response_code=atoi(dont_store_value);
else {	else {
ctx.header->APPEND_CONST(key);	todo: copy dont_store_ to nonvilotile
	ctx.header->APPEND_CONST(dont_store_key);
ctx.header->APPEND_CONST(": ");	ctx.header->APPEND_CONST(": ");
ctx.header->APPEND_CONST(value);	ctx.header->APPEND_CONST(dont_store_value);
ctx.header->APPEND_CONST("\r\n");	ctx.header->APPEND_CONST("\r\n");
}	}
}	}

/// @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 246 void SAPI::send_header(Pool& pool) {	Line 258 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 254 void SAPI::send_body(Pool& pool, const v	Line 266 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;
} catch(const Exception& e) { // global problem	} catch(const Exception& e) { // global problem
const char *body=e.comment();	const char* body=e.comment();

// unsuccessful finish	// unsuccessful finish
return false;	return false;
Line 315 BOOL WINAPI GetExtensionVersion(HSE_VERS	Line 312 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(pool, "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 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 343 void real_parser_handler(Pool& pool, LPE	Line 339 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 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 390 void real_parser_handler(Pool& pool, LPE	Line 386 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)
Line 435 inline DWORD RealHttpExtensionProc(LPEXT	Line 431 inline DWORD RealHttpExtensionProc(LPEXT
// don't allocate anything on pool here:	// don't allocate anything on pool here:
// possible pool' exception not catch-ed now	// possible pool' exception not catch-ed now
// 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(pool, "exception in request exception handler: %s", body);

Line 470 inline DWORD RealHttpExtensionProc(LPEXT	Line 466 inline DWORD RealHttpExtensionProc(LPEXT
// unsuccessful finish	// unsuccessful finish
}	}
/*	/*
const char *body="test";	const char* body="test";

//	//
int content_length=strlen(body);	int content_length=strlen(body);

E-mail:

Removed from v.1.80
changed lines
	Added in v.1.82.2.6.2.1