parser3/src/main/pa_request.C - diff

Return to pa_request.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_request.C between versions 1.169 and 1.195

version 1.169, 2001/10/19 12:43:30	version 1.195, 2002/03/18 15:29:46
Line 1	Line 1
/** @file	/** @file
Parser: request class main part. @see compile.C and execute.C.	Parser: request class main part. @see compile.C and execute.C.

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

$Id$	$Id$
*/	*/

#include "pa_config_includes.h"

//#include "pcre.h"
//#include "internal.h"
extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c

#include "pa_sapi.h"	#include "pa_sapi.h"
#include "pa_common.h"	#include "pa_common.h"
#include "pa_request.h"	#include "pa_request.h"
Line 25 extern "C" unsigned char pcre_default_ta	Line 19 extern "C" unsigned char pcre_default_ta
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
#include "pa_dictionary.h"	#include "pa_dictionary.h"
#include "pa_charset_manager.h"	#include "pa_charsets.h"
	#include "pa_charset.h"

/// content type of exception response, when no @MAIN:exception handler defined	/// content type of exception response, when no @MAIN:exception handler defined
const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";	const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";
Line 35 const char *DEFAULT_CONTENT_TYPE="text/h	Line 30 const char *DEFAULT_CONTENT_TYPE="text/h
const char *ORIGINS_CONTENT_TYPE="text/plain";	const char *ORIGINS_CONTENT_TYPE="text/plain";

Methoded *MOP_create(Pool&);	Methoded *MOP_create(Pool&);
	// op.C
	VHash& exception2vhash(Pool& pool, const Exception& e);

static void load_charset(const Hash::Key& akey, Hash::Val *avalue,	static void load_charset(const Hash::Key& akey, Hash::Val *avalue,
void *info) {	void *) {
Value& value=static_cast<Value >(avalue);	charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());
Hash& CTYPE=static_cast<Hash >(info);

Charset_connection& connection=charset_manager->get_connection(akey, value.as_string());

// charset->pcre_tables
CTYPE.put(akey, connection.pcre_tables());
}	}

//	//
Request::Request(Pool& apool,	Request::Request(Pool& apool,
Info& ainfo,	Info& ainfo,
String::Untaint_lang adefault_lang) : Pooled(apool),	uchar adefault_lang,
	bool status_allowed) : Pooled(apool),
stack(apool),	stack(apool),
OP(*MOP_create(apool)),	OP(*MOP_create(apool)),
env(apool),	env(apool),
	status(apool),
form(apool),	form(apool),
math(apool),	math(apool),
request(apool, *this),	request(apool, *this),
response(apool),	response(apool),
cookie(apool),	cookie(apool),
fclasses(apool),	fclasses(apool),
CTYPE(apool),
fdefault_lang(adefault_lang), flang(adefault_lang),	fdefault_lang(adefault_lang), flang(adefault_lang),
info(ainfo),	info(ainfo),
post_data(0), post_size(0),	post_data(0), post_size(0),
Line 68 Request::Request(Pool& apool,	Line 60 Request::Request(Pool& apool,
default_content_type(0),	default_content_type(0),
mime_types(0),	mime_types(0),
main_class(0),	main_class(0),
connection(0),	fconnection(0),
classes_conf(apool),	classes_conf(apool),
anti_endless_execute_recoursion(0)	anti_endless_execute_recoursion(0),
	trace(apool)
	#ifdef RESOURCES_DEBUG
	,sql_connect_time(0),sql_request_time(0)
	#endif
{	{
	// default charsets
	pool().set_source_charset(*utf8_charset);
	pool().set_client_charset(*utf8_charset);

	// maybe expire old caches
	cache_managers->maybe_expire();

/// directly used	/// directly used
// operators	// operators
OP.register_directly_used(*this);	OP.register_directly_used(*this);
Line 82 Request::Request(Pool& apool,	Line 85 Request::Request(Pool& apool,
/// methodless	/// methodless
// env class	// env class
classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);	classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);
	// status class
	if(status_allowed)
	classes().put(*NEW String(pool(), STATUS_CLASS_NAME), &status);
// request class	// request class
classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);	classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);
// cookie class	// cookie class
Line 98 Request::Request(Pool& apool,	Line 104 Request::Request(Pool& apool,
classes().put(math.get_class()->base()->name(), &math);	classes().put(math.get_class()->base()->name(), &math);
}	}

	Request::~Request() {
	#ifdef XML
	// if for some strange reason xml generic errors failed to be reported, free them up
	if(const char *xml_generic_errors=xmlGenericErrors()) {
	SAPI::log(pool(), "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
	free((void *)xml_generic_errors);
	}
	#endif
	}


/**	/**
load MAIN class, execute @main.	load MAIN class, execute @main.
MAIN class consists of all the auto.p files we'd manage to find	MAIN class consists of all the auto.p files we'd manage to find
Line 105 Request::Request(Pool& apool,	Line 122 Request::Request(Pool& apool,
the file user requested us to process	the file user requested us to process
all located classes become children of one another,	all located classes become children of one another,
composing class we name 'MAIN'	composing class we name 'MAIN'

	@test log stack trace

*/	*/
void Request::core(	void Request::core(
const char *root_config_filespec, bool root_config_fail_on_read_problem,	const char *root_config_filespec, bool root_config_fail_on_read_problem,
const char *site_config_filespec, bool site_config_fail_on_read_problem,	const char *site_config_filespec, bool site_config_fail_on_read_problem,
bool header_only) {	bool header_only) {
//_asm { int 3 }
	#ifdef RESOURCES_DEBUG
	//measures
	struct timeval mt[10];
	//measure:before all
	gettimeofday(&mt[0],NULL);
	#endif
try {	try {
char auto_filespec=(char )malloc(MAX_STRING);	char auto_filespec=(char )malloc(MAX_STRING);

Line 123 void Request::core(	Line 149 void Request::core(
true/ignore class_path/, root_config_fail_on_read_problem,	true/ignore class_path/, root_config_fail_on_read_problem,
main_class_name, main_class);	main_class_name, main_class);
}	}
	// charsets must only be specified in root config
	// so that users would not interfere
if(main_class) {	if(main_class) {
/* $MAIN:CHARSETS[	/* $MAIN:CHARSETS[
$.charsetname1[/full/path/to/charset/file.cfg]	$.charsetname1[/full/path/to/charset/file.cfg]
Line 131 void Request::core(	Line 158 void Request::core(
]	]
*/	*/
if(Value vcharsets=main_class->get_element(charsets_name)) {	if(Value vcharsets=main_class->get_element(charsets_name)) {
if(Hash *charsets=vcharsets->get_hash())	if(Hash *charsets=vcharsets->get_hash(0))
charsets->for_each(load_charset, &CTYPE);	charsets->for_each(load_charset);
else	else
throw Exception(0, 0,	throw Exception(0, 0,
&vcharsets->name(),	&vcharsets->name(),
"must be hash");	"must be hash");
}	}
}	}

// configure root options	// configure root options
// until someone with less privileges have overriden them	// until someone with less privileges have overriden them
OP.configure_admin(*this);	OP.configure_admin(*this);
Line 195 void Request::core(	Line 221 void Request::core(
OP.configure_user(*this);	OP.configure_user(*this);
methoded_array->configure_user(*this);	methoded_array->configure_user(*this);

// $MAIN:DEFAULTS
Value defaults=main_class->get_element(defaults_name);
// value must be allocated on request's pool for that pool used on
// meaning constructing @see attributed_meaning_to_string
default_content_type=defaults?defaults->get_element(*content_type_name):0;
// record default charset
if(default_content_type)
if(Hash *hash=default_content_type->get_hash())
if(Value vcharset=(Value )hash->get(*charset_name))
pool().set_charset(vcharset->as_string());

if(Value element=main_class->get_element(user_html_name))
if(Table *table=element->get_table())
pool().set_tag(NEW Dictionary(*table));

// $MAIN:MIME-TYPES	// $MAIN:MIME-TYPES
if(Value element=main_class->get_element(mime_types_name))	if(Value element=main_class->get_element(mime_types_name))
if(Table *table=element->get_table())	if(Table *table=element->get_table())
Line 221 void Request::core(	Line 232 void Request::core(
// filling cookies	// filling cookies
cookie.fill_fields(*this);	cookie.fill_fields(*this);

	#ifdef RESOURCES_DEBUG
	//measure:after compile
	gettimeofday(&mt[1],NULL);
	#endif
// execute @main[]	// execute @main[]
const String *body_string=execute_virtual_method(	const String body_string=execute_virtual_method(main_class, *main_method_name);
main_class, main_method_name);
if(!body_string)	if(!body_string)
throw Exception(0,0,	throw Exception(0,0,
0,	0,
"'"MAIN_METHOD_NAME"' method not found");	"'"MAIN_METHOD_NAME"' method not found");

	#ifdef RESOURCES_DEBUG
	//measure:after main
	gettimeofday(&mt[2],NULL);
	#endif

VString body_vstring_before_post_process(*body_string);	VString body_vstring_before_post_process(*body_string);
VString *body_vstring_after_post_process=&body_vstring_before_post_process;	VString *body_vstring_after_post_process=&body_vstring_before_post_process;

// @postprocess	// @postprocess
if(Value value=main_class->get_element(post_process_method_name))	if(Value value=main_class->get_element(post_process_method_name))
if(Junction *junction=value->get_junction())	if(Junction *junction=value->get_junction())
Line 244 void Request::core(	Line 262 void Request::core(
frame.store_param(method->name,	frame.store_param(method->name,
&body_vstring_before_post_process);	&body_vstring_before_post_process);
body_vstring_after_post_process=	body_vstring_after_post_process=
NEW VString(execute_method(frame, method));	NEW VString(execute_method(frame, *method));
}	}

bool origins_mode=main_class->get_element(*origins_mode_name)!=0;	bool origins_mode=main_class->get_element(*origins_mode_name)!=0;
Line 261 void Request::core(	Line 279 void Request::core(
response.fields().put(*content_type_name,	response.fields().put(*content_type_name,
NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));	NEW VString(*NEW String(pool(), ORIGINS_CONTENT_TYPE)));

	#ifdef RESOURCES_DEBUG
	//measure:after postprocess
	gettimeofday(&mt[3],NULL);
	#endif

// OK. write out the result	// OK. write out the result
output_result(*body_file, header_only);	output_result(*body_file, header_only);
}
catch(const Exception& e) { // request handling problem	#ifdef RESOURCES_DEBUG
	//measure:after output_result
	gettimeofday(&mt[9],NULL);
	t[9]=mt[9].tv_sec+mt[9].tv_usec/1000000.0;

	double t[10];
	for(int i=0;i<10;i++)
	t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;
	//measure:log2 compile,main,postprocess,output
	SAPI::log(pool(), "rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f",
	info.uri,
	t[1]-t[0],
	t[2]-t[1],
	t[3]-t[2],
	sql_connect_time,sql_request_time,
	t[9]-t[3]
	);
	#endif
	} catch(const Exception& e) { // request handling problem
// we're returning not result, but error explanation	// we're returning not result, but error explanation
try {	try {
// log the beast	// log the beast
Line 272 void Request::core(	Line 313 void Request::core(
if(problem_source && problem_source->size())	if(problem_source && problem_source->size())
SAPI::log(pool(),	SAPI::log(pool(),
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
"%s(%d): "	ORIGIN_FILE_LINE_FORMAT": "
#endif	#endif
"'%s' %s [%s %s]",	"'%s' %s [%s %s]",
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
problem_source->origin().file?problem_source->origin().file:"global",	problem_source->origin().file?problem_source->origin().file:"global",
problem_source->origin().line,	problem_source->origin().line,
#endif	#endif
problem_source->cstr(String::UL_AS_IS),	problem_source->cstr(),
e.comment(),	e.comment(),
e.type()?e.type()->cstr(String::UL_AS_IS):"-",	e.type()?e.type()->cstr():"-",
e.code()?e.code()->cstr(String::UL_AS_IS):"-"	e.code()?e.code()->cstr():"-"
);	);
else	else
SAPI::log(pool(),	SAPI::log(pool(),
"%s [%s %s]",	"%s [%s %s]",
e.comment(),	e.comment(),
e.type()?e.type()->cstr(String::UL_AS_IS):"-",	e.type()?e.type()->cstr():"-",
e.code()?e.code()->cstr(String::UL_AS_IS):"-"	e.code()?e.code()->cstr():"-"
);	);

// reset language to default	// reset language to default
flang=fdefault_lang;	flang=fdefault_lang;
if(flang==String::UL_USER_HTML)
flang=String::UL_HTML; // no _ & Co conversions in @exception[params]

// reset response	// reset response
response.fields().clear();	response.fields().clear();
Line 306 void Request::core(	Line 345 void Request::core(
if(main_class) { // we've managed to end up with some main_class	if(main_class) { // we've managed to end up with some main_class
// maybe we'd be lucky enough as to report an error	// maybe we'd be lucky enough as to report an error
// in a gracefull way...	// in a gracefull way...
if(Value value=main_class->get_element(exception_method_name))	if(Value value=main_class->get_element(unhandled_exception_method_name))
if(Junction *junction=value->get_junction())	if(Junction *junction=value->get_junction())
if(const Method *method=junction->method) {	if(const Method *method=junction->method) {
// preparing to pass parameters to	// preparing to pass parameters to
// @exception[origin;source;comment;type;code]	// @exception[origin;source;comment;type;code;stack]
VMethodFrame frame(pool(), value->name(), *junction);	VMethodFrame frame(pool(), value->name(), *junction);
frame.set_self(*main_class);	frame.set_self(*main_class);

const String *problem_source=e.problem_source();	frame.store_param(method->name, &exception2vhash(pool(), e));
// origin	// $stack[^table::set{name origin}]
Value *origin_value=0;	Array& stack_trace_columns=*NEW Array(pool());
	stack_trace_columns+=NEW String(pool(), "name");
	stack_trace_columns+=NEW String(pool(), "file");
	stack_trace_columns+=NEW String(pool(), "lineno");
	Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
	Array_iter tracei(trace);
	while(tracei.has_next()) {
	Array& row=*NEW Array(pool());

	const String name=(const String )tracei.next();
	row+=name; // name column
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
if(problem_source && problem_source->size()) {	const Origin& origin=name->origin();
const Origin& origin=problem_source->origin();
if(origin.file) {	if(origin.file) {
char buf=(char )malloc(MAX_STRING);	row+=NEW String(pool(), origin.file, 0, true); // file column
size_t buf_size=snprintf(buf, MAX_STRING, "%s(%d)",	char buf=(char )malloc(MAX_NUMBER);
origin.file, 1+origin.line);	size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);
String *origin_file_line=NEW String(pool(),	row+=NEW String(pool(), buf, buf_size, true); // line column
buf, buf_size, true);
origin_value=NEW VString(*origin_file_line);
}	}
}
#endif	#endif
frame.store_param(method->name,	stack_trace+=&row;
origin_value?origin_value:NEW VVoid(pool()));

// source
Value *source_value=0;
if(problem_source && problem_source->size()) {
String& problem_source_copy=*NEW String(pool());
problem_source_copy.append(*problem_source,
flang, true);
source_value=NEW VString(problem_source_copy);
}	}
frame.store_param(method->name,	frame.store_param(method->name,
source_value?source_value:NEW VVoid(pool()));	NEW VTable(pool(), &stack_trace));

// comment
String *comment_value=NEW String(pool(),
e.comment(), 0, true);
frame.store_param(method->name,
NEW VString(*comment_value));

// type
Value *type_value;
if(e.type()) {
String& type_copy=*NEW String(pool());
type_value=NEW VString(type_copy.append(*e.type(),
flang, true));
} else
type_value=NEW VVoid(pool());
frame.store_param(method->name, type_value);

// code
Value *code_value;
if(e.code()) {
String& code_copy=*NEW String(pool());
code_value=NEW VString(code_copy.append(*e.code(),
flang, true));
} else
code_value=NEW VVoid(pool());
frame.store_param(method->name, code_value);

// future $response:body=	// future $response:body=
// execute ^exception[origin;source;comment;type;code]	// execute ^exception[origin;source;comment;type;code;stack]
body_string=execute_method(frame, *method);	body_string=&execute_method(frame, *method);
}	}
}	}

Line 387 void Request::core(	Line 397 void Request::core(
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
const Origin& origin=problem_source->origin();	const Origin& origin=problem_source->origin();
if(origin.file)	if(origin.file)
printed+=snprintf(buf+printed, MAX_STRING-printed, "%s(%d): ",	printed+=snprintf(buf+printed, MAX_STRING-printed,
origin.file, 1+origin.line);	ORIGIN_FILE_LINE_FORMAT": ",
	origin.file, 1+origin.line
	);
#endif	#endif
printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",	printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",
problem_source->cstr(String::UL_AS_IS));	problem_source->cstr());
}	}
printed+=snprintf(buf+printed, MAX_STRING-printed, "%s",	printed+=snprintf(buf+printed, MAX_STRING-printed, "%s",
e.comment());	e.comment());
const String *type=e.type();	const String *type=e.type();
if(type) {	if(type) {
printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s",	printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s",
type->cstr(String::UL_AS_IS));	type->cstr());
const String *code=e.code();	const String *code=e.code();
if(code)	if(code)
printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s",	printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s",
code->cstr(String::UL_AS_IS));	code->cstr());
}	}

// future $response:content-type	// future $response:content-type
Line 417 void Request::core(	Line 429 void Request::core(

// ERROR. write it out	// ERROR. write it out
output_result(*body_file, header_only);	output_result(*body_file, header_only);
} catch(const Exception& e) {	} catch(const Exception& ) {
/re/throw;	/re/throw;
}	}
}	}
Line 442 VStateless_class *Request::use_file(cons	Line 454 VStateless_class *Request::use_file(cons
if(main_class)	if(main_class)
if(Value element=main_class->get_element(class_path_name)) {	if(Value element=main_class->get_element(class_path_name)) {
if(element->is_string()) {	if(element->is_string()) {
file_spec=file_readable(element->as_string(), file_name); // found at class_path?	file_spec=file_readable(absolute(element->as_string()), file_name); // found at class_path?
} else if(Table *table=element->get_table()) {	} else if(Table *table=element->get_table()) {
int size=table->size();	int size=table->size();
for(int i=size; i--; ) {	for(int i=size; i--; ) {
const String& path=static_cast<Array >(table->get(i))->get_string(0);	const String& path=static_cast<Array >(table->get(i))->get_string(0);
if(file_spec=file_readable(path, file_name))	if(file_spec=file_readable(absolute(path), file_name))
break; // found along class_path	break; // found along class_path
}	}
} else	} else
Line 506 const String& Request::absolute(const St	Line 518 const String& Request::absolute(const St

static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,	static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,
void *info) {	void *info) {
String attribute_to_exclude=static_cast<String >(info);	Request& r=static_cast<Request >(info);
if(aattribute==*attribute_to_exclude)	if(aattribute==BODY_NAME
	\|\| aattribute==CHARSET_NAME)
return;	return;

Value& lmeaning=static_cast<Value >(ameaning);	Value& lmeaning=static_cast<Value >(ameaning);
Pool& pool=lmeaning.pool();	Pool& pool=lmeaning.pool();

SAPI::add_header_attribute(pool,	SAPI::add_header_attribute(pool,
aattribute.cstr(String::UL_AS_IS),	aattribute.cstr(),
attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());	attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());
}	}
void Request::output_result(const VFile& body_file, bool header_only) {	void Request::output_result(const VFile& body_file, bool header_only) {
Line 537 void Request::output_result(const VFile&	Line 550 void Request::output_result(const VFile&
if(VString vfile_name=static_cast<VString >(body_file.fields().get(*name_name)))	if(VString vfile_name=static_cast<VString >(body_file.fields().get(*name_name)))
if(vfile_name->string()!=NONAME_DAT) {	if(vfile_name->string()!=NONAME_DAT) {
VHash& vhash=*NEW VHash(pool());	VHash& vhash=*NEW VHash(pool());
vhash.hash().put(*content_disposition_filename_name, vfile_name);	vhash.hash(0).put(*content_disposition_filename_name, vfile_name);
response.fields().put(*content_disposition_name, &vhash);	response.fields().put(*content_disposition_name, &vhash);
}	}

// prepare header: $response:fields without :body	// prepare header: $response:fields without :body
response.fields().for_each(add_header_attribute, /excluding/ body_name);	response.fields().for_each(add_header_attribute, this);

// prepare...	// transcode
const void *body=body_file.value_ptr();	const void *client_body;
size_t content_length=body_file.value_size();	size_t client_content_length;
	Charset::transcode(pool(),
	pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),
	pool().get_client_charset(), client_body, client_content_length
	);

// prepare header: content-length	// prepare header: content-length
if(content_length) { // useful for redirecting [header "location: http://..."]	if(client_content_length) { // useful for redirecting [header "location: http://..."]
char content_length_cstr[MAX_NUMBER];	char content_length_cstr[MAX_NUMBER];
snprintf(content_length_cstr, MAX_NUMBER, "%u", content_length);	snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);
SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);	SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);
}	}

Line 560 void Request::output_result(const VFile&	Line 577 void Request::output_result(const VFile&

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

const String& Request::mime_type_of(const char *user_file_name_cstr) {	const String& Request::mime_type_of(const char *user_file_name_cstr) {
Line 577 const String& Request::mime_type_of(cons	Line 594 const String& Request::mime_type_of(cons
}	}
return *NEW String(pool(), "application/octet-stream");	return *NEW String(pool(), "application/octet-stream");
}	}

const unsigned char *Request::pcre_tables() {
if(unsigned char result=(unsigned char )CTYPE.get(pool().get_charset()))
return result;

// this is not for pcre itself,
// it can do default, it's for string.lower&co
return pcre_default_tables;
}

E-mail:

Removed from v.1.169
changed lines
	Added in v.1.195