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.3 and 1.16

version 1.3, 2001/03/22 17:13:52	version 1.16, 2001/03/24 14:31:02
Line 1	Line 1
#ifndef _MSC_VER	#ifndef _MSC_VER
# error compile ISAPI module with MSVC	# error compile ISAPI module with MSVC [no urge for now to make it autoconf-ed (PAF)]
#endif	#endif

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

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

	#include "pa_sapi.h"
#include "pa_globals.h"	#include "pa_globals.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_version.h"	#include "pa_version.h"
	#include "pool_storage.h"

	#include "nt_log_events.h"

#define MAX_STATUS_LENGTH sizeof("xxxx LONGEST STATUS DESCRIPTION")	#define MAX_STATUS_LENGTH sizeof("xxxx LONGEST STATUS DESCRIPTION")

//@{	//@{
/// service func decl	/// SAPI funcs decl
	struct SAPI_func_context {
struct Service_func_context {
LPEXTENSION_CONTROL_BLOCK lpECB;	LPEXTENSION_CONTROL_BLOCK lpECB;
String *header;	String *header;
DWORD http_response_code;	DWORD http_response_code;
};	};

static const char get_env(Pool& pool, const char name) {	const char SAPI::get_env(Pool& pool, const char name) {
Service_func_context& ctx=static_cast<Service_func_context >(pool.context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.context());

char variable_buf=(char )pool.malloc(MAX_STRING);	char variable_buf=(char )pool.malloc(MAX_STRING);
DWORD variable_len = MAX_STRING-1;	DWORD variable_len = MAX_STRING-1;
Line 34 static const char *get_env(Pool& pool, c	Line 35 static const char *get_env(Pool& pool, c
variable_buf, &variable_len)) {	variable_buf, &variable_len)) {
variable_buf[variable_len]=0;	variable_buf[variable_len]=0;
return variable_buf;	return variable_buf;
	} else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
	variable_buf=(char *)pool.malloc(variable_len+1);

	if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name),
	variable_buf, &variable_len)) {
	variable_buf[variable_len]=0;
	return variable_buf;
	}
}	}

variable_buf=(char *)pool.malloc(variable_len+1);

if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name),
variable_buf, &variable_len)) {
variable_buf[variable_len]=0;
return variable_buf;
}

return 0;	return 0;
}	}

static uint read_post(Pool& pool, char *buf, uint max_bytes) {	uint SAPI::read_post(Pool& pool, char *buf, uint max_bytes) {
Service_func_context& ctx=static_cast<Service_func_context >(pool.context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.context());

DWORD read_from_buf=0;	DWORD read_from_buf=0;
DWORD read_from_input=0;	DWORD read_from_input=0;
Line 77 static uint read_post(Pool& pool, char *	Line 78 static uint read_post(Pool& pool, char *
return total_read;	return total_read;
}	}

static void add_header_attribute(Pool& pool, const char key, const char value) {	void SAPI::add_header_attribute(Pool& pool, const char key, const char value) {
Service_func_context& ctx=static_cast<Service_func_context >(pool.context());	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.context());

if(strcasecmp(key, "location")==0)	if(strcasecmp(key, "location")==0)
ctx.http_response_code=302;	ctx.http_response_code=302;
Line 94 static void add_header_attribute(Pool& p	Line 95 static void add_header_attribute(Pool& p
}	}

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

ctx.header->APPEND_CONST("Cache-Control: no-cache\n");	ctx.header->APPEND_CONST(
ctx.header->APPEND_CONST("\n");	"expires: Fri, 23 Mar 2001 09:32:23 GMT\n"
	"\n");
HSE_SEND_HEADER_EX_INFO header_info;	HSE_SEND_HEADER_EX_INFO header_info;

char status_buf[MAX_STATUS_LENGTH];	char status_buf[MAX_STATUS_LENGTH];
Line 109 static void send_header(Pool& pool) {	Line 111 static void send_header(Pool& pool) {
case 302:	case 302:
header_info.pszStatus="302 Moved Temporarily";	header_info.pszStatus="302 Moved Temporarily";
break;	break;
/*case 401:	case 401:// useless untill parser auth mech
header_info.pszStatus="401 Authorization Required";	header_info.pszStatus="401 Authorization Required";
break;*/	break;
default:	default:
snprintf(status_buf, MAX_STATUS_LENGTH,	snprintf(status_buf, MAX_STATUS_LENGTH,
"%d Undescribed", ctx.http_response_code);	"%d Undescribed", ctx.http_response_code);
Line 121 static void send_header(Pool& pool) {	Line 123 static void send_header(Pool& pool) {
header_info.cchStatus=strlen(header_info.pszStatus);	header_info.cchStatus=strlen(header_info.pszStatus);
header_info.pszHeader=ctx.header->cstr();	header_info.pszHeader=ctx.header->cstr();
header_info.cchHeader=ctx.header->size();	header_info.cchHeader=ctx.header->size();
	header_info.fKeepConn=true;

ctx.lpECB->dwHttpStatusCode=ctx.http_response_code;	ctx.lpECB->dwHttpStatusCode=ctx.http_response_code;

Line 128 static void send_header(Pool& pool) {	Line 131 static void send_header(Pool& pool) {
HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);	HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);
}	}

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

DWORD num_bytes=size;	DWORD num_bytes=size;
ctx.lpECB->WriteClient(ctx.lpECB->ConnID,	ctx.lpECB->WriteClient(ctx.lpECB->ConnID,
const_cast<char *>(buf), &num_bytes, HSE_IO_SYNC);	const_cast<char *>(buf), &num_bytes, HSE_IO_SYNC);
}	}
//@}

/// Service funcs	/// goes to 'cs-uri-query' log file field. webmaster: switch it ON[default OFF].
Service_funcs service_funcs={	void SAPI::log(Pool& pool, const char *fmt, ...) {
get_env,	SAPI_func_context& ctx=static_cast<SAPI_func_context >(pool.context());
read_post,
add_header_attribute,	va_list args;
send_header,	va_start(args,fmt);
send_body	char buf[MAX_STRING];
};	const char *prefix="PARSER_ERROR:";
	strcpy(buf, prefix);
	DWORD size=vsnprintf(buf+strlen(prefix), MAX_STRING-strlen(prefix), fmt, args);

	ctx.lpECB->ServerSupportFunction(ctx.lpECB->ConnID,
	HSE_APPEND_LOG_PARAMETER, buf, &size, 0);
	}
	//@}

//	//

static void parser_init() {	static bool parser_init() {
static bool globals_inited=false;	static bool globals_inited=false;
if(globals_inited)	if(globals_inited)
return;	return true;
globals_inited=true;	globals_inited=true;

static Pool pool; // global pool	static Pool pool(0); // global pool
PTRY {	PTRY {
// init global variables	// init global variables
globals_init(pool);	pa_globals_init(pool);

//...	// successful finish
	return true;
} PCATCH(e) { // global problem	} PCATCH(e) { // global problem
const char *body=e.comment();	//const char *body=e.comment();
// TODO: somehow report that error
	// unsuccessful finish
	return false;
}	}
PEND_CATCH	PEND_CATCH
}	}
Line 170 static void parser_init() {	Line 182 static void parser_init() {
/// ISAPI //	/// ISAPI //
BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO *pVer) {	BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO *pVer) {
pVer->dwExtensionVersion = HSE_VERSION;	pVer->dwExtensionVersion = HSE_VERSION;
strncpy(pVer->lpszExtensionDesc, "Parser " PARSER_VERSION, HSE_MAX_EXT_DLL_NAME_LEN);	strncpy(pVer->lpszExtensionDesc, "Parser "PARSER_VERSION, HSE_MAX_EXT_DLL_NAME_LEN);
return TRUE;	return parser_init();
}	}

/// ISAPI // main workhorse	/**
	ISAPI // main workhorse

	@todo
	IIS: remove trailing default-document[index.html] from $request.uri.
	to do that we need to consult metabase,
	wich is tested&works but seems slow runtime
	and not could-be-quickly-implemented if prepared.
	*/
DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK lpECB) {	DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK lpECB) {
Pool pool;	Pool_storage pool_storage;
// TODO r->no_cache=1;	Pool pool(&pool_storage); // no allocations until assigned context [for reporting]
	SAPI_func_context ctx={
	lpECB,
	0, // filling later: so that if there would be error pool would have ctx
	200
	};
	pool.set_context(&ctx);// no allocations before this line!

bool header_only=strcasecmp(lpECB->lpszMethod, "HEAD")==0;	bool header_only=strcasecmp(lpECB->lpszMethod, "HEAD")==0;
PTRY { // global try	PTRY { // global try
// must be first in PTRY{}PCATCH	ctx.header=new(pool) String(pool);

Service_func_context ctx={
lpECB,
new(pool) String(pool),
200
};
pool.set_context(&ctx);

const char *filespec_to_process=lpECB->lpszPathTranslated;

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

const char *document_root=0; // todo: get from somewhere?	size_t path_translated_buf_size=strlen(lpECB->lpszPathTranslated)+1;
if(!document_root) {	char filespec_to_process=(char )malloc(path_translated_buf_size);
static char fake_document_root[MAX_STRING];	memcpy(filespec_to_process, lpECB->lpszPathTranslated, path_translated_buf_size);
strncpy(fake_document_root, filespec_to_process, MAX_STRING);	#ifdef WIN32
rsplit(fake_document_root, '/'); rsplit(fake_document_root, '\\');// strip filename	back_slashes_to_slashes(filespec_to_process);
document_root=fake_document_root;	#endif
}
request_info.document_root=document_root;	if(const char *path_info=SAPI::get_env(pool, "PATH_INFO")) {
	// IIS
	size_t len=strlen(filespec_to_process)-strlen(path_info);
	char buf=(char )pool.malloc(len+1);
	strncpy(buf, filespec_to_process, len);
	buf[len]=0;
	request_info.document_root=buf;
	} else
	PTHROW(0, 0,
	0,
	"ISAPI: no PATH_INFO defined (in reinventing DOCUMENT_ROOT)");

request_info.path_translated=filespec_to_process;	request_info.path_translated=filespec_to_process;
request_info.method=lpECB->lpszMethod;	request_info.method=lpECB->lpszMethod;
request_info.query_string=lpECB->lpszQueryString;	request_info.query_string=lpECB->lpszQueryString;
char reconstructed_uri[MAX_STRING];
if(lpECB->lpszQueryString && *lpECB->lpszQueryString) {	if(lpECB->lpszQueryString && *lpECB->lpszQueryString) {
strncpy(reconstructed_uri, lpECB->lpszPathInfo,	char reconstructed_uri=(char )malloc(
MAX_STRING-1/'?'/-strlen(lpECB->lpszQueryString));	strlen(lpECB->lpszPathInfo)+1/'?'/+
	strlen(lpECB->lpszQueryString)+1/0/);
	strcpy(reconstructed_uri, lpECB->lpszPathInfo);
strcat(reconstructed_uri, "?");	strcat(reconstructed_uri, "?");
strcat(reconstructed_uri, lpECB->lpszPathInfo);	strcat(reconstructed_uri, lpECB->lpszQueryString);
request_info.uri=reconstructed_uri;	request_info.uri=reconstructed_uri;
} else	} else
request_info.uri=lpECB->lpszPathInfo;	request_info.uri=lpECB->lpszPathInfo;

request_info.content_type=lpECB->lpszContentType;	request_info.content_type=lpECB->lpszContentType;
request_info.content_length=lpECB->cbTotalBytes;	request_info.content_length=lpECB->cbTotalBytes;
// cookie	request_info.cookie=SAPI::get_env(pool, "HTTP_COOKIE");
request_info.cookie=0;
char cookie_buf[MAX_STRING];
{
DWORD cookie_len = MAX_STRING-1;

if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_COOKIE", cookie_buf, &cookie_len)) {
cookie_buf[cookie_len]=0;
request_info.cookie=cookie_buf;
} else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
char tmp_cookie_buf=(char )pool.malloc(cookie_len+1);

if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_COOKIE", tmp_cookie_buf, &cookie_len)) {
tmp_cookie_buf[cookie_len]=0;
request_info.cookie=tmp_cookie_buf;
}
}
}

// prepare to process request	// prepare to process request
Request request(pool,	Request request(pool,
request_info,	request_info,
String::UL_HTML_TYPO	String::UL_HTML_TYPO
);	);

// some root-controlled location	// some root-controlled location
char *root_auto_path;	// c:\windows
// c:\windows	// must be dynamic: rethrowing from request.core
root_auto_path=(char *)pool.malloc(MAX_STRING);	// may return 'source' which can be inside of 'root auto.p@exeception'
	char root_auto_path=(char )pool.malloc(MAX_STRING);
GetWindowsDirectory(root_auto_path, MAX_STRING);	GetWindowsDirectory(root_auto_path, MAX_STRING);
/*
char *fuck_it="fff";
DWORD num_bytes=strlen(fuck_it);;
lpECB->WriteClient(lpECB->ConnID, fuck_it, &num_bytes, HSE_IO_SYNC);
return HSE_STATUS_SUCCESS;
*/
// process the request	// process the request
request.core(	request.core(
root_auto_path, false/may be abcent/, // /path/to/admin/auto.p	root_auto_path, false/may be abcent/, // /path/to/admin/auto.p
0/parser_site_auto_path/, false, // /path/to/site/auto.p	0/parser_site_auto_path/, false, // /path/to/site/auto.p
header_only);	header_only);

// successful finish	// successful finish
} PCATCH(e) { // global problem	} PCATCH(e) { // global problem
	// don't allocate anything on pool here:
	// possible pool' exception not catch-ed now
	// and there could be out-of-memory exception
const char *body=e.comment();	const char *body=e.comment();
int content_length=strlen(body);	// log it
	SAPI::log(pool, "exception in request exception handler: %s", body);

// prepare header	//
(*service_funcs.add_header_attribute)(pool, "content-type", "text/plain");	int content_length=strlen(body);
char content_length_cstr[MAX_NUMBER];
snprintf(content_length_cstr, MAX_NUMBER, "%d", content_length);
(*service_funcs.add_header_attribute)(pool, "content-length",
content_length_cstr);

	// prepare header // not using SAPI func wich allocates on pool
	char header_buf[MAX_STRING];
	int header_len=snprintf(header_buf, MAX_STRING,
	"content-type: text/plain\n"
	"content-length: %ul\n"
	"expires: Fri, 23 Mar 2001 09:32:23 GMT\n"
	"\n",
	content_length);

	HSE_SEND_HEADER_EX_INFO header_info;
	header_info.pszStatus="200 OK";
	header_info.cchStatus=strlen(header_info.pszStatus);
	header_info.pszHeader=header_buf;
	header_info.cchHeader=header_len;
	header_info.fKeepConn=true;

// send header	// send header
(*service_funcs.send_header)(pool);	lpECB->dwHttpStatusCode=200;
	lpECB->ServerSupportFunction(lpECB->ConnID,
	HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);

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

// unsuccessful finish	// unsuccessful finish
_endthread();
}	}
PEND_CATCH	PEND_CATCH

return HSE_STATUS_SUCCESS;	return HSE_STATUS_SUCCESS_AND_KEEP_CONN;
}


BOOL APIENTRY DllMain(HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
parser_init();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}	}

E-mail:

Removed from v.1.3
changed lines
	Added in v.1.16