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.170 and 1.186

version 1.170, 2001/10/19 13:43:59	version 1.186, 2001/12/15 21:28:21
Line 2	Line 2
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 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	Author: Alexander Petrosyan <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 37 const char *ORIGINS_CONTENT_TYPE="text/p	Line 32 const char *ORIGINS_CONTENT_TYPE="text/p
Methoded *MOP_create(Pool&);	Methoded *MOP_create(Pool&);

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);	Value& value=static_cast<Value >(avalue);
Hash& CTYPE=static_cast<Hash >(info);

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

// charset->pcre_tables	if(!charsets->get(akey)) // don't we know that charset?
CTYPE.put(akey, connection.pcre_tables());	charsets->put(akey,
	new(charsets->pool()) Charset(charsets->pool(), akey, &value.as_string()));
}	}

//	//
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 70 Request::Request(Pool& apool,	Line 64 Request::Request(Pool& apool,
main_class(0),	main_class(0),
connection(0),	connection(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 87 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 105 Request::Request(Pool& apool,	Line 113 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 140 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 149 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 212 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 223 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);
Line 229 void Request::core(	Line 235 void Request::core(
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 261 void Request::core(	Line 271 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 305 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 310 void Request::core(	Line 341 void Request::core(
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);

Line 322 void Request::core(	Line 353 void Request::core(
const Origin& origin=problem_source->origin();	const Origin& origin=problem_source->origin();
if(origin.file) {	if(origin.file) {
char buf=(char )malloc(MAX_STRING);	char buf=(char )malloc(MAX_STRING);
size_t buf_size=snprintf(buf, MAX_STRING, "%s(%d)",	size_t buf_size=snprintf(buf, MAX_STRING, ORIGIN_FILE_LINE_FORMAT,
origin.file, 1+origin.line);	origin.file, 1+origin.line);
String *origin_file_line=NEW String(pool(),	origin_value=NEW VString(*NEW String(pool(),
buf, buf_size, true);	buf, buf_size, true));
origin_value=NEW VString(*origin_file_line);
}	}
}	}
#endif	#endif
Line 370 void Request::core(	Line 400 void Request::core(
code_value=NEW VVoid(pool());	code_value=NEW VVoid(pool());
frame.store_param(method->name, code_value);	frame.store_param(method->name, code_value);

	// $stack[^table::set{name origin}]
	Array& stack_trace_columns=*NEW Array(pool());
	stack_trace_columns+=NEW String(pool(), "name");
	stack_trace_columns+=NEW String(pool(), "origin");
	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
	const Origin& origin=name->origin();
	if(origin.file) {
	char buf=(char )malloc(MAX_STRING);
	size_t buf_size=snprintf(buf, MAX_STRING, ORIGIN_FILE_LINE_FORMAT,
	origin.file, 1+origin.line);
	row+=NEW String(pool(), buf, buf_size, true); // origin column
	}
	#endif
	stack_trace+=&row;
	}
	frame.store_param(method->name,
	NEW VTable(pool(), &stack_trace));

// 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 442 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 506 const String& Request::absolute(const St	Line 563 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 595 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 622 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 639 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.170
changed lines
	Added in v.1.186