--- parser3/src/main/pa_request.C	2001/03/10 14:05:36	1.4
+++ parser3/src/main/pa_request.C	2003/03/21 15:36:04	1.245.2.37.2.7
@@ -1,102 +1,692 @@
-/*
-$Id: pa_request.C,v 1.4 2001/03/10 14:05:36 paf Exp $
+/** @file
+	Parser: request class main part. @see compile.C and execute.C.
+
+	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
+static const char* IDENT_REQUEST_C="$Date: 2003/03/21 15:36:04 $";
+
+#include "pa_sapi.h"
+#include "pa_common.h"
 #include "pa_request.h"
 #include "pa_wwrapper.h"
-#include "pa_common.h"
 #include "pa_vclass.h"
-#include "classes/_root.h"
-#include "classes/_env.h"
-
-#include <stdio.h>
-
-Request::Request(Pool& apool) : Pooled(apool),
-	stack(apool),
-	root_class(apool),
-	env_class(apool),
-	fclasses(apool),
-	fclasses_array(apool),
-	lang(String::Untaint_lang::HTML_TYPO)
+#include "pa_globals.h"
+#include "pa_vint.h"
+#include "pa_vmethod_frame.h"
+#include "pa_types.h"
+#include "pa_venv.h"
+#include "pa_vmath.h"
+#include "pa_vstatus.h"
+#include "pa_vrequest.h"
+#include "pa_vtable.h"
+#include "pa_vfile.h"
+#include "pa_dictionary.h"
+#include "pa_charset.h"
+#include "pa_charsets.h"
+#include "pa_cache_managers.h"
+#include "pa_vmail.h"
+#include "pa_vform.h"
+#include "pa_vcookie.h"
+#include "pa_vresponse.h"
+
+// consts
+
+const char* UNHANDLED_EXCEPTION_METHOD_NAME="unhandled_exception";
+
+/// content type of exception response, when no @MAIN:exception handler defined
+const char* UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";
+
+/// content type of response when no $MAIN:defaults.content-type defined
+const char* DEFAULT_CONTENT_TYPE="text/html";
+const char* ORIGINS_CONTENT_TYPE="text/plain";
+
+// defines for globals
+
+#define MAIN_METHOD_NAME "main"
+#define AUTO_METHOD_NAME "auto"
+#define BODY_NAME "body"
+
+// globals
+
+const String main_method_name(MAIN_METHOD_NAME);
+const String auto_method_name(AUTO_METHOD_NAME);
+const String content_disposition_name(CONTENT_DISPOSITION_NAME);
+const String content_disposition_value(CONTENT_DISPOSITION_VALUE);
+const String content_disposition_filename_name(CONTENT_DISPOSITION_FILENAME_NAME);
+const String body_name(BODY_NAME);
+
+// defines for statics
+
+#define CHARSETS_NAME "CHARSETS"
+#define MIME_TYPES_NAME "MIME-TYPES"
+#define ORIGINS_MODE_NAME "ORIGINS"
+#define CONF_METHOD_NAME "conf"
+#define POST_PROCESS_METHOD_NAME "postprocess"
+#define DOWNLOAD_NAME "download"
+#define CLASS_PATH_NAME "CLASS_PATH"
+
+// statics
+
+static const String charsets_name(CHARSETS_NAME);
+static const String main_class_name(MAIN_CLASS_NAME);
+static const String mime_types_name(MIME_TYPES_NAME);
+static const String origins_mode_name(ORIGINS_MODE_NAME);
+static const String conf_method_name(CONF_METHOD_NAME);
+static const String post_process_method_name(POST_PROCESS_METHOD_NAME);
+static const String download_name(DOWNLOAD_NAME);
+static const String class_path_name(CLASS_PATH_NAME);
+
+// defines
+
+// op.C
+VStateless_class* VClassMAIN_create();
+// op.C
+VHash& exception2vhash(const Exception& e);
+
+//
+Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, 
+		 String::Language adefault_lang, bool status_allowed):
+	// private
+	anti_endless_execute_recoursion(0),
+
+	// public
+	method_frame(0),
+	rcontext(0),
+	wcontext(0),
+	flang(adefault_lang),
+	fconnection(0),
+	finterrupted(false),
+
+	// public
+#ifdef RESOURCES_DEBUG
+	sql_connect_time(0),
+	sql_request_time(0),
+#endif	
+
+	// public
+	sapi_info(asapi_info),
+	request_info(arequest_info),
+	charsets(UTF8_charset, UTF8_charset, UTF8_charset), // default charsets
+
+	main_class(*VClassMAIN_create()),
+	form(*new VForm),
+	mail(*new VMail),
+	response(*new VResponse(arequest_info, charsets)),
+	cookie(*new VCookie),
+
+	// private
+	configure_admin_done(false),
+
+	// private defaults
+	fdefault_lang(adefault_lang), 
+	// private mime types
+	mime_types(0)
 {
-	// root class
-	initialize_root_class(pool(), root_class);
-	// adding root superclass, 
-	//   parent of all classes, 
-	//   operators holder
-	String ROOT(pool()); ROOT.APPEND_CONST(ROOT_NAME);
-	classes().put(ROOT, &root_class);
+	// maybe expire old caches
+	cache_managers.maybe_expire();
+	
+	/// directly used
+	// MAIN class, operators
+	classes().put(main_class.name(), &main_class);
+	// classes:
+	// table, file, random, mail, image, ...
+	methoded_array().register_directly_used(*this);
 
+	/// methodless
 	// env class
-	initialize_env_class(pool(), env_class);
-	String ENV(pool()); ENV.APPEND_CONST(ENV_NAME);
-	classes().put(ENV, &env_class);
-}
-
-void Request::core() {
-	TRY {
-		char *file="Y:\\parser3\\src\\test.p";
-		String RUN(pool()); RUN.APPEND_CONST(RUN_NAME);
-		use(file, &RUN);
-
-		char *result=execute_MAIN();
-		printf("result-----------------\n%sEOF----------------\n", result);
-	} 
-	CATCH(e) {
-		printf("\nERROR: ");
-		const String *problem_source=e.problem_source();
-		if(problem_source) {
-			const Origin& origin=problem_source->origin();
-			if(origin.file)
-				printf("%s(%d): ",
-				origin.file, 1+origin.line);
-			printf("'%s' ", 
-				problem_source->cstr());
-		}
-		printf("%s", e.comment());
-		const String *type=e.type();
-		if(type) {
-			printf("  type: %s", type->cstr());
-			const String *code=e.code();
-			if(code)
-				printf(", code: %s", code->cstr());
-		}
-		printf("\n");
-	}
-	END_CATCH
-}
-
-void Request::use(char *file, String *name) {
-	// TODO: обнаружить|решить cyclic dependences
-	char *source=file_read(pool(), file);
-	if(!source)
-		THROW(0,0,
-			0,
-			"use: can not read '%s' file", file);
-
-	VClass& vclass=COMPILE(source, name, file);
-
-	// locate and execute possible @auto[] static method
-	String name_auto(pool());
-	name_auto.APPEND_CONST(AUTO_METHOD_NAME);
-	execute_static(vclass, name_auto, false);
-}
-
-char *Request::execute_MAIN() {
-	// locate class with @main & it's code
-	String name_main(pool());
-	name_main.APPEND_CONST(MAIN_METHOD_NAME);
-
-	// looking for latest known @main
-	for(int i=classes_array().size(); --i>=0;) {
-		VClass *vclass=static_cast<VClass *>(classes_array().get(i));
-		char *result=execute_static(*vclass, name_main, true);
-		if(result)
-			return result;
+	classes().put(*new StringBody(ENV_CLASS_NAME), new VEnv(asapi_info));
+	// status class
+	if(status_allowed)
+		classes().put(*new StringBody(STATUS_CLASS_NAME), new VStatus());
+	// request class
+	classes().put(*new StringBody(REQUEST_CLASS_NAME), new VRequest(arequest_info, charsets));	
+	// cookie class
+	classes().put(*new StringBody(COOKIE_CLASS_NAME), &cookie);
+
+	/// methoded
+	// response class
+	classes().put(response.get_class()->name(), &response);
+
+	/// bases used
+	// form class
+	classes().put(form.get_class()->base_class()->name(), &form);
+	// mail class
+	classes().put(mail.get_class()->base_class()->name(), &mail);
+	// math class
+	{
+		Value& math=*new VMath;
+		classes().put(math.get_class()->base_class()->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(sapi_info, "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
+		free((void *)xml_generic_errors);
+	}
+#endif
+}
+
+Value& Request::get_self() { return method_frame/*always have!*/->self(); }
+
+static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, int) {
+	::charsets.load_charset(*new String(akey, String::L_CLEAN), 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(!vcharsets->is_string())
+			if(HashStringValue* charsets=vcharsets->get_hash())
+				charsets->for_each(load_charset, 0);
+			else
+				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.
+	MAIN class consists of all the auto.p files we'd manage to find
+	plus
+	the file user requested us to process
+	all located classes become children of one another,
+	composing class we name 'MAIN'
+
+	@test log stack trace
+
+*/
+void Request::core(const char* config_filespec, bool config_fail_on_read_problem, bool header_only) {
+
+#ifdef RESOURCES_DEBUG
+//measures
+struct timeval mt[10];
+//measure:before all
+gettimeofday(&mt[0],NULL);
+#endif
+	try {
+		// loading config
+		if(config_filespec) {
+			const String& filespec=*new String(config_filespec);
+			use_file(main_class,
+				filespec, true/* ignore class_path */, 
+				config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);
+		}
+
+		// loading auto.p files from document_root/.. 
+		// to the one beside requested file.
+		// all assigned bases from upper dir
+		{
+			const char* after=request_info.path_translated;
+			size_t drlen=strlen(request_info.document_root);
+			if(memcmp(after, request_info.document_root, drlen)==0) {
+				after+=drlen;
+				if(after[-1]=='/') 
+					--after;
+			}
+			
+			int step=0;
+			while(const char* before=strchr(after, '/')) {
+				String& sfile_spec=*new String;
+				if(after!=request_info.path_translated) {
+					sfile_spec.append(
+						request_info.path_translated, before-request_info.path_translated,
+						String::L_CLEAN);
+					sfile_spec << "/" AUTO_FILE_NAME;
+
+					use_file(main_class,
+						sfile_spec, true/* ignore class_path */, 
+						true/* fail on read problem */, false/* but ignore absence, sole user */);
+				}
+				after=before+1;
+			}
+		}
+
+		// compile requested file
+		String& spath_translated=*new String;
+		spath_translated.append(request_info.path_translated, 0, String::L_TAINTED);
+		use_file(main_class,
+			spath_translated, true/* ignore class_path */, 
+			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-method_frame=user options
+		methoded_array().configure_user(*this);
+
+		// $MAIN:MIME-TYPES
+		if(Value* element=main_class.get_element(mime_types_name, main_class, false))
+			if(Table *table=element->get_table())
+				mime_types=table;			
+
+		// filling form fields
+		form.fill_fields_and_tables(charsets, request_info);
+
+		// filling cookies
+		cookie.fill_fields(request_info);
+
+		// filling mail received
+		mail.fill_received(*this);
+
+#ifdef RESOURCES_DEBUG
+//measure:after compile
+gettimeofday(&mt[1],NULL);
+#endif
+		// execute @main[]
+		const String* body_string=execute_virtual_method(main_class, main_method_name);
+		if(!body_string)
+			throw Exception("parser.runtime",
+				0,
+				"'"MAIN_METHOD_NAME"' method not found");
+
+#ifdef RESOURCES_DEBUG
+		//measure:after main
+gettimeofday(&mt[2],NULL);
+#endif
+
+		VString& body_vstring_before_post_process=*new VString(*body_string);
+		VString* body_vstring_after_post_process=&body_vstring_before_post_process;
+		// @postprocess
+		if(Value* value=main_class.get_element(post_process_method_name, main_class, false))
+			if(Junction* junction=value->get_junction())
+				if(const Method *method=junction->method) {
+					// preparing to pass parameters to 
+					//	@postprocess[data]
+					VMethodFrame frame(/*method->name, */ *junction, 0/*no parent*/);
+					frame.set_self(main_class);
+
+					frame.store_param(body_vstring_before_post_process);
+					body_vstring_after_post_process=
+						new VString(execute_method(frame, *method));
+				}
+
+		VFile* body_file=body_vstring_after_post_process->as_vfile(
+			String::L_UNSPECIFIED);
+
+		// extract response body
+		Value* body_value=response.fields().get(download_name);
+		bool as_attachment=body_value!=0;
+		if(!body_value)
+			body_value=response.fields().get(body_name);
+
+		if(body_value) // there is some $response:body
+			body_file=body_value->as_vfile();
+
+#ifdef RESOURCES_DEBUG
+//measure:after postprocess
+gettimeofday(&mt[3],NULL);		
+#endif
+
+		// OK. write out the result
+		output_result(body_file, header_only, as_attachment);
+
+#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("rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f", 
+request_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
+		try {
+			// log the beast
+			if(const String* problem_source=e.problem_source())
+				SAPI::log(sapi_info,
+					"%s: "
+					"'%s' %s [%s]",
+					request_info.uri,
+					problem_source->cstr(),
+					e.comment(),
+					e.type()
+				);
+			else
+				SAPI::log(sapi_info,
+					"%s: "
+					"%s [%s]",
+					request_info.uri,
+					e.comment(), e.type()
+				);
+
+			// reset language to default
+			flang=fdefault_lang;
+			
+			// reset response
+			response.fields().clear();
+
+			// this is what we'd return in $response:body
+			const String* body_string=0;
+
+			// maybe we'd be lucky enough as to report an error
+			// in a gracefull way...
+			if(Value* value=main_class.get_element(
+					*new String(UNHANDLED_EXCEPTION_METHOD_NAME), 
+					main_class,
+					false)) {
+				if(Junction* junction=value->get_junction()) {
+					if(const Method *method=junction->method) {
+		 				// preparing to pass parameters to 
+						//	@unhandled_exception[exception;stack]
+						VMethodFrame frame(/*method->name, */ *junction, 0/*no caller*/);
+						frame.set_self(main_class);
+
+						// $exception
+						frame.store_param(exception2vhash(e));
+						// $stack[^table::set{name	origin}]
+						Table::columns_type stack_trace_columns(new ArrayString);
+						*stack_trace_columns+=*new StringBody("name"));
+						*stack_trace_columns+=*new StringBody("file"));
+						*stack_trace_columns+=*new StringBody("lineno"));
+						Table* stack_trace(new Table(0, stack_trace_columns));
+						Array_iterator<String*> tracei(exception_trace);
+						while(tracei.has_next()) {
+							Table::element_type row(new ArrayString);
+
+							const String& name=tracei.next();
+							*row+=name; // name column
+#ifndef NO_STRING_ORIGIN
+							const String_fragment::Origin& origin=name->origin();
+							if(origin.file) {
+								*row+=*new StringBody(origin.file, 0, true)); // file column
+								*row+=*new StringBody(
+									pool().format_integer(1+origin.line), 
+									0, true)); // line column
+							}
+#endif
+							*stack_trace+=row;
+						}
+						frame.store_param(new VTable(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?
+				// doing that ugly
+
+				// make up result: $origin $source $comment $type $code
+				char *buf=new char[MAX_STRING];
+				size_t printed=0;
+				if(const String* problem_source=e.problem_source()) {
+#ifndef NO_STRING_ORIGIN
+					const String_fragment::Origin& origin=problem_source->origin();
+					if(origin.file)
+						printed+=snprintf(buf+printed, MAX_STRING-printed, 
+							ORIGIN_FILE_LINE_FORMAT": ", 
+							origin.file, 1+origin.line
+						);
+#endif
+					printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ", 
+						problem_source->cstr().get());
+				}
+				if(const char* comment=e.comment(true))
+					printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", comment);
+				if(const char* type=e.type(true)) 
+					printed+=snprintf(buf+printed, MAX_STRING-printed, "  type: %s",  type);
+
+				// future $response:content-type
+				response.fields().put(content_type_name, 
+					new VString(*new StringBody(UNHANDLED_EXCEPTION_CONTENT_TYPE)))));
+				// future $response:body
+				body_string=*new StringBody(buf));
+			}
+
+			VString body_vstring(body_string);
+			VFile* body_file=body_vstring.as_vfile();
+
+			// ERROR. write it out
+			output_result(body_file, header_only, false);
+		} catch(const Exception& ) {
+			rethrow;
+		}
+	}
+}
+
+void Request::use_file(VStateless_class& aclass,
+									const String& file_name, bool ignore_class_path, 
+									bool fail_on_read_problem, bool fail_on_file_absence) {
+	// cyclic dependence check
+	if(used_files.get(file_name))
+		return;
+	used_files.put(file_name, true);
+
+	const String& file_spec;
+	if(ignore_class_path) // ignore_class_path?
+		file_spec=file_name;
+	else if(file_name->first_char()=='/') //absolute path, no need to scan MAIN:CLASS_PATH?
+		file_spec=absolute(file_name);
+	else {
+		file_spec=0;
+		if(Value* element=main_class.get_element(class_path_name, main_class, false)) {
+			if(element->is_string()) {
+				file_spec=file_readable(*absolute(element->as_string()), *file_name); // found at class_path?
+			} else if(Table *table=element->get_table()) {
+				int size=table->count();
+				for(int i=size; i--; ) {
+					const String& path=(*table->get(i))[0];
+					if(file_spec=file_readable(*absolute(path), *file_name))
+						break; // found along class_path
+				}
+			} else
+				throw Exception("parser.runtime",
+					0,
+					"$" CLASS_PATH_NAME " must be string or table");
+			if(!file_spec)
+				throw Exception("parser.runtime",
+					file_name,
+					"not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
+		}
+		if(!file_spec)
+			throw Exception("parser.runtime",
+				file_name,
+				"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;
+
+	if(const char* source=file_read_text(charsets.source(), file_spec, fail_on_read_problem))
+		use_buf(aclass, source, file_spec, file_spec->cstr());
+}
+
+
+void Request::use_buf(VStateless_class& aclass,
+								   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, Method*(0));
+	// temporary zero @auto so to maybe-replace it in compiled code
+	Temp_method temp_method_auto(aclass, auto_method_name, Method*(0));
+
+	// compile loaded class
+	VStateless_class& cclass=COMPILE(&aclass, source, filespec_cstr);
+
+	// locate and execute possible @conf[] static
+	const VString& vfilespec(new VString(filespec));
+	Execute_nonvirtual_method_result executed=execute_nonvirtual_method(cclass, 
+		conf_method_name, vfilespec,
+		false/*no string result needed*/);
+	if(executed.method)
+		configure_admin(cclass, executed.method->name);
+
+	// locate and execute possible @auto[] static
+	execute_nonvirtual_method(cclass, 
+		auto_method_name, vfilespec,
+		false/*no result needed*/);
+}
+
+const String& Request::relative(const char* apath, const String& relative_name) {
+    char *hpath=pool().copy(apath);
+	const String& result(new String);
+    if(rsplit(hpath, '/')) // if something/splitted
+		*result << hpath << "/";
+    *result << relative_name;
+    return result;
+}
+
+const String& Request::absolute(const String& relative_name) {
+	if(relative_name->first_char()=='/') {
+		const String& result=*new StringBody(request_info.document_root));
+		*result << relative_name;
+		return result;
+	} else 
+		return relative_name->pos("://")<0? relative(request_info.path_translated, relative_name)
+			:relative_name; // something like "http://xxx"
+}
+
+static void add_header_attribute(
+								 HashStringValue::key_type aattribute, 
+								 HashStringValue::value_type ameaning, 
+								 Request *r) {
+	if(*aattribute==BODY_NAME
+		|| *aattribute==DOWNLOAD_NAME
+		|| *aattribute==CHARSET_NAME)
+		return;
+
+	SAPI::add_header_attribute(r->sapi_info,
+		aattribute->cstr(), 
+		attributed_meaning_to_string(r->ameaning, String::L_HTTP_HEADER, false)->
+			cstr(String::L_UNSPECIFIED));
+}
+void Request::output_result(VFile* body_file, bool header_only, bool as_attachment) {
+	// header: cookies
+	cookie->output_result(sapi_info);
 	
-	THROW(0,0,
-		0, 
-		"'"MAIN_METHOD_NAME"' method not found");
-	return 0;
+	Value* body_file_content_type;
+	// set content-type
+	if(body_file_content_type=body_file->fields().get(content_type_name)) {
+		// body file content type
+		response.fields().put(content_type_name, body_file_content_type);
+	} else {
+		// default content type
+		response.fields().put_dont_replace(content_type_name, 
+			new VString(*new StringBody(DEFAULT_CONTENT_TYPE)))));
+	}
+
+	// content-disposition
+	if(Value* vfile_name=body_file->fields().get(name_name))
+		if(*vfile_name->get_string(&fpool)!=NONAME_DAT) {
+			VHash* hash(new VHash);
+			HashStringValue &h=hash->hash(0);
+			if(as_attachment)
+				h.put(value_name, new VString(content_disposition_value)));
+			h.put(content_disposition_filename_name, vfile_name);
+			response.fields().put(content_disposition_name, hash);
+		}
+
+	// prepare header: $response:fields without :body
+	response.fields().for_each(add_header_attribute, this);
+
+	const void *client_body;
+	size_t client_content_length;
+	// transcode text body when "text/*" or simple result
+	if(body_file_content_type)
+		if(HashStringValue *hash=body_file_content_type->get_hash())
+			body_file_content_type=hash->get(value_name);
+	if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string().pos("text/")==0) {
+		Charset::transcode(
+			charsets.source(), body_file->value_ptr(), body_file->value_size(),
+			charsets.client(), client_body, client_content_length
+		);
+	} else {
+		client_body=body_file->value_ptr();
+		client_content_length=body_file->value_size();
+	}
+
+	// prepare header: content-length
+	char content_length_cstr[MAX_NUMBER];
+	snprintf(content_length_cstr, MAX_NUMBER, "%u", client_content_length);
+	SAPI::add_header_attribute(sapi_info, "content-length", content_length_cstr);
+
+	// send header
+	SAPI::send_header(sapi_info);
+	
+	// send body
+	if(!header_only)
+		SAPI::send_body(sapi_info, client_body, client_content_length);
+}
+
+const String& Request::mime_type_of(const char* user_file_name_cstr) {
+	if(mime_types)
+		if(const char* cext=strrchr(user_file_name_cstr, '.')) {
+			String sext(++cext);
+			if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER)))
+				if(const String& result=mime_types->item(1))
+					return result;
+				else
+					throw Exception("parser.runtime",
+						mime_types->origin_string(),
+						MIME_TYPES_NAME  " table column elements must not be empty");
+		}
+
+	return *new StringBody("application/octet-stream"));
+}
+
+#ifdef XML
+
+GdomeDOMString_auto_ptr Request::transcode(const String& s) {
+	return charsets.source().transcode(s);
+}
+
+const String& Request::transcode(GdomeDOMString* s
+#ifndef NO_STRING_ORIGIN
+	, const String& origin
+#endif
+	) {
+	return charsets.source().transcode(s
+#ifndef NO_STRING_ORIGIN
+		, origin
+#endif
+		);
+}
+
+const String& Request::transcode(xmlChar* s
+#ifndef NO_STRING_ORIGIN
+	, const String& origin
+#endif
+	) {
+	return charsets.source().transcode(s
+#ifndef NO_STRING_ORIGIN
+		, origin
+#endif
+		);
 }
+#endif