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.182.2.1.2.1 and 1.196

version 1.182.2.1.2.1, 2001/12/06 20:23:45	version 1.196, 2002/03/27 13:33:32
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://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

$Id$	$Id$
*/	*/

#include "pa_config_includes.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 23 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_connection.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 34 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());
}	}

//	//
Line 62 Request::Request(Pool& apool,	Line 53 Request::Request(Pool& apool,
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 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)	exception_trace(apool)
#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
,sql_connect_time(0),sql_request_time(0)	,sql_connect_time(0),sql_request_time(0)
#endif	#endif
{	{
	// default charsets
	pool().set_source_charset(*utf8_charset);
	pool().set_client_charset(*utf8_charset);

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

Line 110 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 144 gettimeofday(&mt[0],NULL);	Line 149 gettimeofday(&mt[0],NULL);
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 153 gettimeofday(&mt[0],NULL);	Line 159 gettimeofday(&mt[0],NULL);
*/	*/
if(Value vcharsets=main_class->get_element(charsets_name)) {	if(Value vcharsets=main_class->get_element(charsets_name)) {
if(Hash *charsets=vcharsets->get_hash(0))	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 216 gettimeofday(&mt[0],NULL);	Line 221 gettimeofday(&mt[0],NULL);
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(0))
if(Value vcharset=(Value )hash->get(*charset_name))
pool().set_charset(vcharset->as_string());

// $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 243 gettimeofday(&mt[0],NULL);	Line 237 gettimeofday(&mt[0],NULL);
gettimeofday(&mt[1],NULL);	gettimeofday(&mt[1],NULL);
#endif	#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,
Line 269 gettimeofday(&mt[2],NULL);	Line 262 gettimeofday(&mt[2],NULL);
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 352 t[9]-t[3]	Line 345 t[9]-t[3]
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;stack]	// @unhandled_exception[exception;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();	// $exception
// origin	frame.store_param(method->name, &exception2vhash(pool(), e));
Value *origin_value=0;
#ifndef NO_STRING_ORIGIN
if(problem_source && problem_source->size()) {
const Origin& origin=problem_source->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);
origin_value=NEW VString(*NEW String(pool(),
buf, buf_size, true));
}
}
#endif
frame.store_param(method->name,
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,
source_value?source_value:NEW VVoid(pool()));

// 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);

// $stack[^table::set{name origin}]	// $stack[^table::set{name origin}]
Array& stack_trace_columns=*NEW Array(pool());	Array& stack_trace_columns=*NEW Array(pool());
stack_trace_columns+=NEW String(pool(), "name");	stack_trace_columns+=NEW String(pool(), "name");
stack_trace_columns+=NEW String(pool(), "origin");	stack_trace_columns+=NEW String(pool(), "file");
	stack_trace_columns+=NEW String(pool(), "lineno");
Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);	Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
Array_iter tracei(trace);	Array_iter tracei(exception_trace);
while(tracei.has_next()) {	while(tracei.has_next()) {
Array& row=*NEW Array(pool());	Array& row=*NEW Array(pool());

Line 429 t[9]-t[3]	Line 370 t[9]-t[3]
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
const Origin& origin=name->origin();	const Origin& origin=name->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, ORIGIN_FILE_LINE_FORMAT,	char buf=(char )malloc(MAX_NUMBER);
origin.file, 1+origin.line);	size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);
row+=NEW String(pool(), buf, buf_size, true); // origin column	row+=NEW String(pool(), buf, buf_size, true); // line column
}	}
#endif	#endif
stack_trace+=&row;	stack_trace+=&row;
Line 442 t[9]-t[3]	Line 383 t[9]-t[3]

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

Line 514 VStateless_class *Request::use_file(cons	Line 455 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 579 const String& Request::absolute(const St	Line 520 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) {
Request& r=static_cast<Request >(info);	Request& r=static_cast<Request >(info);
if(aattribute==*body_name)	if(aattribute==BODY_NAME
	\|\| aattribute==CHARSET_NAME)
return;	return;

Value& lmeaning=static_cast<Value >(ameaning);	Value& lmeaning=static_cast<Value >(ameaning);
Line 616 void Request::output_result(const VFile&	Line 558 void Request::output_result(const VFile&
// prepare header: $response:fields without :body	// prepare header: $response:fields without :body
response.fields().for_each(add_header_attribute, this);	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 632 void Request::output_result(const VFile&	Line 578 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 649 const String& Request::mime_type_of(cons	Line 595 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.182.2.1.2.1
changed lines
	Added in v.1.196