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.166 and 1.200

version 1.166, 2001/10/03 12:20:58	version 1.200, 2002/04/16 14:41:39
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),
	exception_trace(apool)
	#ifdef RESOURCES_DEBUG
	, sql_connect_time(0),sql_request_time(0)
	#endif
	, self(0), root(0), rcontext(0), wcontext(0)
{	{
	// 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 86 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 105 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 123 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 }
bool need_rethrow=false; Exception rethrow_me;	#ifdef RESOURCES_DEBUG
TRY {	//measures
	struct timeval mt[10];
	//measure:before all
	gettimeofday(&mt[0],NULL);
	#endif
	try {
char auto_filespec=(char )malloc(MAX_STRING);	char auto_filespec=(char )malloc(MAX_STRING);

// loading root config	// loading root config
Line 124 void Request::core(	Line 150 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 132 void Request::core(	Line 159 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(0, 0,	throw Exception("parser.runtime",
&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 196 void Request::core(	Line 222 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;
#ifdef XML
// 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());
#endif

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 224 void Request::core(	Line 233 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(0,0,	throw Exception("parser.runtime",
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 247 void Request::core(	Line 263 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 264 void Request::core(	Line 280 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(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
const String *problem_source=e.problem_source();	const String *problem_source=e.problem_source();
if(problem_source && problem_source->size())	if(problem_source && problem_source->size())
SAPI::log(pool(),	SAPI::log(pool(),
	"%s: "
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
"%s(%d): "	ORIGIN_FILE_LINE_FORMAT": "
#endif	#endif
"'%s' %s [%s %s]",	"'%s' %s [%s]",
	info.uri,
#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():"-"
e.code()?e.code()->cstr(String::UL_AS_IS):"-"
);	);
else	else
SAPI::log(pool(),	SAPI::log(pool(),
"%s [%s %s]",	"%s: "
	"%s [%s]",
	info.uri,
e.comment(),	e.comment(),
e.type()?e.type()->cstr(String::UL_AS_IS):"-",	e.type()?e.type():"-"
e.code()?e.code()->cstr(String::UL_AS_IS):"-"	);
);

// 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 309 void Request::core(	Line 348 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]	// @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;	// $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(), "file");
	stack_trace_columns+=NEW String(pool(), "lineno");
	Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
	Array_iter tracei(exception_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 390 void Request::core(	Line 401 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();	if(const char *type=e.type())
if(type) {	printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s", type);
printed+=snprintf(buf+printed, MAX_STRING-printed, " type: %s",
type->cstr(String::UL_AS_IS));
const String *code=e.code();
if(code)
printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s",
code->cstr(String::UL_AS_IS));
}

// future $response:content-type	// future $response:content-type
response.fields().put(*content_type_name,	response.fields().put(*content_type_name,
Line 420 void Request::core(	Line 426 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& ) {
	/re/throw;
}	}
CATCH(e) {
// exception in request exception handler
// remember to rethrow it
rethrow_me=e; need_rethrow=true;
}
END_CATCH
}	}
END_CATCH // do not use pool() after this point - no exception handler set
// any throw() would try to use zero exception() pointer

if(need_rethrow) // were there an exception for us to rethrow?
THROW(rethrow_me.type(), rethrow_me.code(),
rethrow_me.problem_source(),
rethrow_me.comment());
}	}

VStateless_class *Request::use_file(const String& file_name,	VStateless_class *Request::use_file(const String& file_name,
Line 456 VStateless_class *Request::use_file(cons	Line 451 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
THROW(0, 0,	throw Exception("parser.runtime",
&element->name(),	&element->name(),
"must be string or table");	"must be string or table");
if(!file_spec)	if(!file_spec)
THROW(0, 0,	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(0, 0,	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");
}	}
Line 520 const String& Request::absolute(const St	Line 515 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 551 void Request::output_result(const VFile&	Line 547 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://..."]	char content_length_cstr[MAX_NUMBER];
char content_length_cstr[MAX_NUMBER];	snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);
snprintf(content_length_cstr, MAX_NUMBER, "%u", content_length);	SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);
SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);
}

// send header	// send header
SAPI::send_header(pool());	SAPI::send_header(pool());

// 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 585 const String& Request::mime_type_of(cons	Line 583 const String& Request::mime_type_of(cons
if(const String *result=mime_types->item(1))	if(const String *result=mime_types->item(1))
return *result;	return *result;
else	else
THROW(0, 0,	throw Exception("parser.runtime",
mime_types->origin_string(),	mime_types->origin_string(),
"MIME-TYPE table column elements must not be empty");	"MIME-TYPE table column elements must not be empty");
}	}
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.166
changed lines
	Added in v.1.200