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.200 and 1.235

version 1.200, 2002/04/16 14:41:39	version 1.235, 2002/10/16 07:32:51
Line 3	Line 3

Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001, 2002 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)

$Id$
*/	*/

	static const char* IDENT_REQUEST_C="$Date$";

#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 19	Line 19
#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_charsets.h"
#include "pa_charset.h"	#include "pa_charset.h"
	#include "pa_charsets.h"

	const char *POST_PROCESS_METHOD_NAME="postprocess";
	const char *UNHANDLED_EXCEPTION_METHOD_NAME="unhandled_exception";

/// 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 29 const char *UNHANDLED_EXCEPTION_CONTENT_	Line 32 const char *UNHANDLED_EXCEPTION_CONTENT_
const char *DEFAULT_CONTENT_TYPE="text/html";	const char *DEFAULT_CONTENT_TYPE="text/html";
const char *ORIGINS_CONTENT_TYPE="text/plain";	const char *ORIGINS_CONTENT_TYPE="text/plain";

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

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

//	//
Request::Request(Pool& apool,	Request::Request(Pool& apool,
Info& ainfo,	Info& ainfo,
uchar adefault_lang,	uchar adefault_lang,
bool status_allowed) : Pooled(apool),	bool status_allowed) : Pooled(apool),
	main_method_name(apool, MAIN_METHOD_NAME),
stack(apool),	stack(apool),
OP(*MOP_create(apool)),	main_class(VClassMAIN_create(apool)),
env(apool),	env(apool),
status(apool),	status(apool),
form(apool),	form(apool),
	mail(apool),
math(apool),	math(apool),
request(apool, *this),	request(apool, *this),
response(apool),	response(apool),
Line 57 Request::Request(Pool& apool,	Line 58 Request::Request(Pool& apool,
info(ainfo),	info(ainfo),
post_data(0), post_size(0),	post_data(0), post_size(0),
used_files(apool),	used_files(apool),
	configure_admin_done(false),
default_content_type(0),	default_content_type(0),
mime_types(0),	mime_types(0),
main_class(0),
fconnection(0),	fconnection(0),
classes_conf(apool),	classes_conf(apool),
anti_endless_execute_recoursion(0),	anti_endless_execute_recoursion(0),
Line 67 Request::Request(Pool& apool,	Line 68 Request::Request(Pool& 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
, self(0), root(0), rcontext(0), wcontext(0)	, self(0), method_frame(0), rcontext(0), wcontext(0)
{	{
// default charsets	// default charsets
pool().set_source_charset(*utf8_charset);	pool().set_source_charset(*utf8_charset);
Line 77 Request::Request(Pool& apool,	Line 78 Request::Request(Pool& apool,
cache_managers->maybe_expire();	cache_managers->maybe_expire();

/// directly used	/// directly used
// operators	// MAIN class, operators
OP.register_directly_used(*this);	classes().put(main_class.name(), &main_class);
// classes:	// classes:
// table, file, random, mail, image, ...	// table, file, random, mail, image, ...
methoded_array->register_directly_used(*this);	methoded_array->register_directly_used(*this);
Line 100 Request::Request(Pool& apool,	Line 101 Request::Request(Pool& apool,

/// bases used	/// bases used
// form class	// form class
classes().put(form.get_class()->base()->name(), &form);	classes().put(form.get_class()->base_class()->name(), &form);
	// mail class
	classes().put(mail.get_class()->base_class()->name(), &mail);
// math class	// math class
classes().put(math.get_class()->base()->name(), &math);	classes().put(math.get_class()->base_class()->name(), &math);
}	}

Request::~Request() {	Request::~Request() {
Line 115 Request::~Request() {	Line 118 Request::~Request() {
#endif	#endif
}	}

	static void load_charset(const Hash::Key& akey, Hash::Val avalue, void ) {
	charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());
	}
	void Request::configure_admin(VStateless_class& conf_class, const String *source) {
	if(configure_admin_done)
	throw Exception("parser.runtime",
	source,
	"parser already configured");
	configure_admin_done=true;

	// charsets must only be specified in method_frame config
	// so that users would not interfere

	/* $MAIN:CHARSETS[
	$.charsetname1[/full/path/to/charset/file.cfg]
	...
	]
	*/
	if(Value vcharsets=conf_class.get_element(charsets_name, &conf_class, false)) {
	if(Hash *charsets=vcharsets->get_hash(0))
	charsets->for_each(load_charset);
	else if(!vcharsets->get_string())
	throw Exception("parser.runtime",
	0,
	"$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
	}

	// configure method_frame options
	// until someone with less privileges have overriden them
	methoded_array->configure_admin(*this);
	}

/**	/**
load MAIN class, execute @main.	load MAIN class, execute @main.
Line 128 Request::~Request() {	Line 162 Request::~Request() {

*/	*/
void Request::core(	void Request::core(
const char *root_config_filespec, bool root_config_fail_on_read_problem,	const char *config_filespec, bool config_fail_on_read_problem,
const char *site_config_filespec, bool site_config_fail_on_read_problem,
bool header_only) {	bool header_only) {

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
Line 141 gettimeofday(&mt[0],NULL);	Line 174 gettimeofday(&mt[0],NULL);
try {	try {
char auto_filespec=(char )malloc(MAX_STRING);	char auto_filespec=(char )malloc(MAX_STRING);

// loading root config	// loading config
if(root_config_filespec) {	if(config_filespec) {
String& filespec=*NEW String(pool());	String& filespec=*NEW String(pool());
filespec.APPEND_CLEAN(root_config_filespec, 0, "root_config", 0);	filespec.APPEND_CLEAN(config_filespec, 0, "config", 0);
main_class=use_file(	use_file(main_class,
filespec,	filespec, true/* ignore class_path */,
true/ignore class_path/, root_config_fail_on_read_problem,	config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);
main_class_name, main_class);
}
// charsets must only be specified in root config
// so that users would not interfere
if(main_class) {
/* $MAIN:CHARSETS[
$.charsetname1[/full/path/to/charset/file.cfg]
...
]
*/
if(Value vcharsets=main_class->get_element(charsets_name)) {
if(Hash *charsets=vcharsets->get_hash(0))
charsets->for_each(load_charset);
else
throw Exception("parser.runtime",
&vcharsets->name(),
"must be hash");
}
}
// configure root options
// until someone with less privileges have overriden them
OP.configure_admin(*this);
methoded_array->configure_admin(*this);

// loading site config
if(site_config_filespec) {
String& filespec=*NEW String(pool());
filespec.APPEND_CLEAN(site_config_filespec, 0, "site_config", 0);
main_class=use_file(
filespec,
true/ignore class_path/, site_config_fail_on_read_problem,
main_class_name, main_class);
}	}

// loading auto.p files from document_root/..	// loading auto.p files from document_root/..
Line 203 gettimeofday(&mt[0],NULL);	Line 204 gettimeofday(&mt[0],NULL);
"path-translated-scanned", step++);	"path-translated-scanned", step++);
sfile_spec << "/" AUTO_FILE_NAME;	sfile_spec << "/" AUTO_FILE_NAME;

main_class=use_file(sfile_spec,	use_file(main_class,
true/ignore class_path/, false/ignore read problem/,	sfile_spec, true/* ignore class_path */,
main_class_name, main_class);	true/* fail on read problem /, false/ but ignore absence, sole user */);
}	}
after=before+1;	after=before+1;
}	}
Line 214 gettimeofday(&mt[0],NULL);	Line 215 gettimeofday(&mt[0],NULL);
// compile requested file	// compile requested file
String& spath_translated=*NEW String(pool());	String& spath_translated=*NEW String(pool());
spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);	spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);
main_class=use_file(spath_translated,	use_file(main_class,
true/ignore class_path/, true/don't ignore read problem/,	spath_translated, true/* ignore class_path */,
main_class_name, main_class);	true/* fail on read problem/, true/ fail on abscence */);

	// configure method_frame options if not configured yet
	if(!configure_admin_done)
	configure_admin(main_class, 0);

// configure not-root=user options	// configure not-method_frame=user options
OP.configure_user(*this);
methoded_array->configure_user(*this);	methoded_array->configure_user(*this);

// $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, &main_class, false))
if(Table *table=element->get_table())	if(Table *table=element->get_table())
mime_types=table;	mime_types=table;

Line 233 gettimeofday(&mt[0],NULL);	Line 237 gettimeofday(&mt[0],NULL);
// filling cookies	// filling cookies
cookie.fill_fields(*this);	cookie.fill_fields(*this);

	// filling mail received
	mail.fill_received(*this);

#ifdef RESOURCES_DEBUG	#ifdef RESOURCES_DEBUG
//measure:after compile	//measure:after compile
gettimeofday(&mt[1],NULL);	gettimeofday(&mt[1],NULL);
#endif	#endif
// execute @main[]	// execute @main[]
const String body_string=execute_virtual_method(main_class, *main_method_name);	const String *body_string=execute_virtual_method(main_class, main_method_name);
if(!body_string)	if(!body_string)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	0,
Line 252 gettimeofday(&mt[2],NULL);	Line 259 gettimeofday(&mt[2],NULL);
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(
	*NEW String(pool(), POST_PROCESS_METHOD_NAME),
	&main_class,
	false))
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
// @postprocess[data]	// @postprocess[data]
VMethodFrame frame(pool(), value->name(), *junction);	VMethodFrame frame(pool(), method->name, junction, 0/no parent*/);
frame.set_self(*main_class);	frame.set_self(main_class);

frame.store_param(method->name,	frame.store_param(&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 lorigins_mode=origins_mode();

const VFile *body_file=body_vstring_after_post_process->as_vfile(	const VFile *body_file=body_vstring_after_post_process->as_vfile(
String::UL_UNSPECIFIED, origins_mode);	String::UL_UNSPECIFIED, lorigins_mode);

// extract response body	// extract response body
Value body_value=static_cast<Value >(	Value body_value=static_cast<Value >(
response.fields().get(*body_name));	response.fields().get(*body_name));
if(body_value) // there is some $response.body	if(body_value) // there is some $response:body
body_file=body_value->as_vfile();	body_file=body_value->as_vfile();
else if(origins_mode)	else if(lorigins_mode)
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)));

Line 310 t[9]-t[3]	Line 319 t[9]-t[3]
// we're returning not result, but error explanation	// we're returning not result, but error explanation
try {	try {
// log the beast	// log the beast
const String *problem_source=e.problem_source();	if(const String *problem_source=e.problem_source())
if(problem_source && problem_source->size())
SAPI::log(pool(),	SAPI::log(pool(),
"%s: "	"%s: "
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
Line 325 t[9]-t[3]	Line 333 t[9]-t[3]
#endif	#endif
problem_source->cstr(),	problem_source->cstr(),
e.comment(),	e.comment(),
e.type()?e.type():"-"	e.type()
);	);
else	else
SAPI::log(pool(),	SAPI::log(pool(),
"%s: "	"%s: "
"%s [%s]",	"%s [%s]",
info.uri,	info.uri,
e.comment(),	e.comment(), e.type()
e.type()?e.type():"-"
);	);

// reset language to default	// reset language to default
Line 345 t[9]-t[3]	Line 352 t[9]-t[3]
// this is what we'd return in $response:body	// this is what we'd return in $response:body
const String *body_string=0;	const String *body_string=0;

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(
if(Value value=main_class->get_element(unhandled_exception_method_name))	*NEW String(pool(), UNHANDLED_EXCEPTION_METHOD_NAME),
if(Junction *junction=value->get_junction())	&main_class,
if(const Method *method=junction->method) {	false)) {
// preparing to pass parameters to	if(Junction *junction=value->get_junction()) {
// @unhandled_exception[exception;stack]	if(const Method *method=junction->method) {
VMethodFrame frame(pool(), value->name(), *junction);	// preparing to pass parameters to
frame.set_self(*main_class);	// @unhandled_exception[exception;stack]
	VMethodFrame frame(pool(), method->name, junction, 0/no caller*/);
// $exception	frame.set_self(main_class);
frame.store_param(method->name, &exception2vhash(pool(), e));
// $stack[^table::set{name origin}]	// $exception
Array& stack_trace_columns=*NEW Array(pool());	frame.store_param(&exception2vhash(pool(), e));
stack_trace_columns+=NEW String(pool(), "name");	// $stack[^table::set{name origin}]
stack_trace_columns+=NEW String(pool(), "file");	Array& stack_trace_columns=*NEW Array(pool());
stack_trace_columns+=NEW String(pool(), "lineno");	stack_trace_columns+=NEW String(pool(), "name");
Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);	stack_trace_columns+=NEW String(pool(), "file");
Array_iter tracei(exception_trace);	stack_trace_columns+=NEW String(pool(), "lineno");
while(tracei.has_next()) {	Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
Array& row=*NEW Array(pool());	Array_iter tracei(exception_trace);
	while(tracei.has_next()) {
	Array& row=*NEW Array(pool());

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

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

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

if(!body_string) { // couldn't report an error beautifully?	if(!body_string) { // couldn't report an error beautifully?
Line 396 t[9]-t[3]	Line 405 t[9]-t[3]
// make up result: $origin $source $comment $type $code	// make up result: $origin $source $comment $type $code
char buf=(char )malloc(MAX_STRING);	char buf=(char )malloc(MAX_STRING);
size_t printed=0;	size_t printed=0;
const String *problem_source=e.problem_source();	if(const String *problem_source=e.problem_source()) {
if(problem_source) {
#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)
Line 409 t[9]-t[3]	Line 417 t[9]-t[3]
printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",	printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",
problem_source->cstr());	problem_source->cstr());
}	}
printed+=snprintf(buf+printed, MAX_STRING-printed, "%s",	if(const char *comment=e.comment(true))
e.comment());	printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", comment);
if(const char *type=e.type())	if(const char *type=e.type(true))
printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s", type);	printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s", type);

// future $response:content-type	// future $response:content-type
Line 432 t[9]-t[3]	Line 440 t[9]-t[3]
}	}
}	}

VStateless_class *Request::use_file(const String& file_name,	VStateless_class *Request::use_file(VStateless_class& aclass,
bool ignore_class_path, bool fail_on_read_problem,	const String& file_name, bool ignore_class_path,
const String *name,	bool fail_on_read_problem, bool fail_on_file_absence) {
VStateless_class *base_class) {
// cyclic dependence check	// cyclic dependence check
if(used_files.get(file_name))	if(used_files.get(file_name))
return base_class;	return 0;
used_files.put(file_name, (Hash::Val *)true);	used_files.put(file_name, (Hash::Val *)true);

const String *file_spec;	const String *file_spec;
Line 448 VStateless_class *Request::use_file(cons	Line 455 VStateless_class *Request::use_file(cons
file_spec=&absolute(file_name);	file_spec=&absolute(file_name);
else {	else {
file_spec=0;	file_spec=0;
if(main_class)	if(Value element=main_class.get_element(class_path_name, &main_class, false)) {
if(Value element=main_class->get_element(class_path_name)) {	if(element->is_string()) {
if(element->is_string()) {	file_spec=file_readable(absolute(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(absolute(path), file_name))
if(file_spec=file_readable(absolute(path), file_name))	break; // found along class_path
break; // found along class_path	}
}	} else
} else	throw Exception("parser.runtime",
throw Exception("parser.runtime",	0,
&element->name(),	"$" CLASS_PATH_NAME " must be string or table");
"must be string or table");	if(!file_spec)
if(!file_spec)	throw Exception("parser.runtime",
throw Exception("parser.runtime",	&file_name,
&file_name,	"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);	}
}
if(!file_spec)	if(!file_spec)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&file_name,	&file_name,
"usage failed - no " MAIN_CLASS_NAME ":" CLASS_PATH_NAME " were specified");	"usage failed - no $" MAIN_CLASS_NAME ":" CLASS_PATH_NAME " were specified");
}	}

	if(fail_on_read_problem && !fail_on_file_absence) // ignore file absence if asked for
	if(!entry_exists(*file_spec))
	return 0;

char source=file_read_text(pool(), file_spec, fail_on_read_problem);	char source=file_read_text(pool(), file_spec, fail_on_read_problem);
if(!source)	if(!source)
return base_class;	return 0;

return use_buf(source, file_spec->cstr(), 0/new class/, name, base_class);	return use_buf(aclass, source, *file_spec, file_spec->cstr());
}	}

VStateless_class Request::use_buf(const char source, const char *file,
VStateless_class aclass, const String name,	VStateless_class *Request::use_buf(VStateless_class& aclass,
VStateless_class *base_class) {	const char *source,
	const String& filespec, const char *filespec_cstr) {
	// temporary zero @conf so to maybe-replace it in compiled code
	Temp_method temp_method_conf(aclass, *conf_method_name, 0);
	// temporary zero @auto so to maybe-replace it in compiled code
	Temp_method temp_method_auto(aclass, *auto_method_name, 0);

// compile loaded class	// compile loaded class
VStateless_class& cclass=COMPILE(source, aclass, name, base_class, file);	VStateless_class& cclass=COMPILE(aclass, source, filespec_cstr);

// locate and execute possible @auto[] static method	// locate and execute possible @conf[] static
execute_nonvirtual_method(cclass, auto_method_name, false /no result needed*/);	VString *vfilespec=NEW VString(filespec);
	const Method *method_called;
	execute_nonvirtual_method(cclass,
	*conf_method_name, vfilespec,
	0/no result needed/, &method_called);
	if(method_called)
	configure_admin(cclass, &method_called->name);

	// locate and execute possible @auto[] static
	execute_nonvirtual_method(cclass,
	*auto_method_name, vfilespec,
	0/no result needed/);
return &cclass;	return &cclass;
}	}

const String& Request::relative(const char *apath, const String& relative_name) {	const String& Request::relative(const char *apath, const String& relative_name) {
int lpath_buf_size=strlen(apath)+1;	int hpath_buf_size=strlen(apath)+1;
char lpath=(char )malloc(lpath_buf_size);	char hpath=(char )malloc(hpath_buf_size);
memcpy(lpath, apath, lpath_buf_size);	memcpy(hpath, apath, hpath_buf_size);
if(!rsplit(lpath, '/'))	String& result=*NEW String(pool());
strcpy(lpath, ".");	if(rsplit(hpath, '/')) // if something/splitted
String& result=*NEW String(pool(), lpath);	result << hpath << "/";
result << "/" << relative_name;	result << relative_name;
return result;	return result;
}	}

const String& Request::absolute(const String& relative_name) {	const String& Request::absolute(const String& relative_name) {
char *relative_name_cstr=relative_name.cstr();	if(relative_name.first_char()=='/') {
if(relative_name_cstr[0]=='/') {
String& result=*NEW String(pool(), info.document_root);	String& result=*NEW String(pool(), info.document_root);
result << relative_name;	result << relative_name;
return result;	return result;
Line 531 void Request::output_result(const VFile&	Line 557 void Request::output_result(const VFile&
// header: cookies	// header: cookies
cookie.output_result();	cookie.output_result();

	Value *body_file_content_type;
// set content-type	// set content-type
if(String body_file_content_type=static_cast<String >(	if(body_file_content_type=static_cast<Value *>(
body_file.fields().get(*vfile_mime_type_name))) {	body_file.fields().get(*content_type_name))) {
// body file content type	// body file content type
response.fields().put(*content_type_name, body_file_content_type);	response.fields().put(*content_type_name, body_file_content_type);
} else {	} else {
Line 554 void Request::output_result(const VFile&	Line 581 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);

// transcode
const void *client_body;	const void *client_body;
size_t client_content_length;	size_t client_content_length;
Charset::transcode(pool(),	// transcode text body when "text/*" or simple result
pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),	if(body_file_content_type)
pool().get_client_charset(), client_body, client_content_length	if(Hash *hash=body_file_content_type->get_hash(0))
);	body_file_content_type=static_cast<Value >(hash->get(value_name));
	if(!body_file_content_type/vstring.as_vfile/ \|\| body_file_content_type->as_string().pos("text/")==0) {
	Charset::transcode(pool(),
	pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),
	pool().get_client_charset(), client_body, client_content_length
	);
	} else {
	client_body=body_file.value_ptr();
	client_content_length=body_file.value_size();
	}

// prepare header: content-length	// prepare header: content-length
char content_length_cstr[MAX_NUMBER];	char content_length_cstr[MAX_NUMBER];
Line 579 const String& Request::mime_type_of(cons	Line 614 const String& Request::mime_type_of(cons
if(mime_types)	if(mime_types)
if(const char *cext=strrchr(user_file_name_cstr, '.')) {	if(const char *cext=strrchr(user_file_name_cstr, '.')) {
String sext(pool(), ++cext);	String sext(pool(), ++cext);
if(mime_types->locate(0, sext))	if(mime_types->locate(0, sext.change_case(pool(), String::CC_LOWER)))
if(const String *result=mime_types->item(1))	if(const String *result=mime_types->item(1))
return *result;	return *result;
else	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
mime_types->origin_string(),	mime_types->origin_string(),
"MIME-TYPE table column elements must not be empty");	MIME_TYPES_NAME " table column elements must not be empty");
}	}
return *NEW String(pool(), "application/octet-stream");	return *NEW String(pool(), "application/octet-stream");
}	}

	bool Request::origins_mode() {
	return main_class.get_element(*origins_mode_name, &main_class, false)!=0; // $ORIGINS mode
	}

E-mail:

Removed from v.1.200
changed lines
	Added in v.1.235