--- parser3/src/main/pa_request.C	2001/03/24 19:12:20	1.78
+++ parser3/src/main/pa_request.C	2020/12/15 12:16:04	1.403
@@ -1,83 +1,398 @@
 /** @file
 	Parser: request class main part. @see compile.C and execute.C.
 
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
-
-	$Id: pa_request.C,v 1.78 2001/03/24 19:12:20 paf Exp $
+	Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-#include "pa_config_includes.h"
-
 #include "pa_sapi.h"
 #include "pa_common.h"
+#include "pa_os.h"
 #include "pa_request.h"
 #include "pa_wwrapper.h"
 #include "pa_vclass.h"
-#include "_root.h"
-#include "_table.h"
 #include "pa_globals.h"
 #include "pa_vint.h"
-#include "pa_vmframe.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_http.h"
+#include "pa_vmail.h"
+#include "pa_vform.h"
+#include "pa_vcookie.h"
+#include "pa_vresponse.h"
+#include "pa_vmemory.h"
+#include "pa_vconsole.h"
+#include "pa_vdate.h"
+
+volatile const char * IDENT_PA_REQUEST_C="$Id: pa_request.C,v 1.403 2020/12/15 12:16:04 moko Exp $" IDENT_PA_REQUEST_H IDENT_PA_REQUEST_CHARSETS_H IDENT_PA_REQUEST_INFO_H IDENT_PA_VCONSOLE_H;
+
+// consts
+
+#define UNHANDLED_EXCEPTION_METHOD_NAME "unhandled_exception"
+
+/// content type of response when no $MAIN:defaults.content-type defined
+const char* DEFAULT_CONTENT_TYPE="text/html";
+
+const uint LOOP_LIMIT=20000;
+const uint EXECUTE_RECOURSION_LIMIT=1000;
+const uint HTTPD_TIMEOUT=4;
+const size_t FILE_SIZE_LIMIT=512*1024*1024;
+
+// defines for globals
+
+#define MAIN_METHOD_NAME "main"
+#define AUTO_METHOD_NAME "auto"
+#define USE_METHOD_NAME "use"
+#define AUTOUSE_METHOD_NAME "autouse"
+
+#define EXCEPTION_TYPE_PART_NAME "type"
+#define EXCEPTION_SOURCE_PART_NAME "source"
+#define EXCEPTION_COMMENT_PART_NAME "comment"
+
+#define ORIGIN_KEY "origin"
+
+// globals
+
+const String main_method_name(MAIN_METHOD_NAME);
+const String auto_method_name(AUTO_METHOD_NAME);
+static const String use_method_name(USE_METHOD_NAME);
+static const String autouse_method_name(AUTOUSE_METHOD_NAME);
+
+const String exception_type_part_name(EXCEPTION_TYPE_PART_NAME);
+const String exception_source_part_name(EXCEPTION_SOURCE_PART_NAME);
+const String exception_comment_part_name(EXCEPTION_COMMENT_PART_NAME);
+const String exception_handled_part_name(EXCEPTION_HANDLED_PART_NAME);
+
+static const String origin_key(ORIGIN_KEY);
+
+int pa_loop_limit=LOOP_LIMIT;
+int pa_execute_recoursion_limit=EXECUTE_RECOURSION_LIMIT;
+int pa_httpd_timeout=HTTPD_TIMEOUT;
+size_t pa_file_size_limit=FILE_SIZE_LIMIT;
+
+// defines for statics
+
+#define MIME_TYPES_NAME "MIME-TYPES"
+#define CLASS_PATH_NAME "CLASS_PATH"
+
+#define DOWNLOAD_NAME_UPPER "DOWNLOAD"
+#define BODY_NAME_UPPER "BODY"
+
+// statics
+
+static const String main_class_name(MAIN_CLASS_NAME);
+static const String mime_types_name(MIME_TYPES_NAME);
+static const String class_path_name(CLASS_PATH_NAME);
+
+static const String charsets_name("CHARSETS");
+static const String strict_vars_name("STRICT-VARS");
+static const String prototype_name("OBJECT-PROTOTYPE");
+static const String limits_name("LIMITS");
+static const String loop_limit_name("max_loop");
+static const String recoursion_limit_name("max_recoursion");
+static const String file_size_limit_name("max_file_size");
+static const String lock_wait_timeout_name("lock_wait_timeout");
+static const String httpd_name("HTTPD");
+static const String httpd_timeout_name("timeout");
+static const String httpd_mode_name("mode");
+
+static const String conf_method_name("conf");
+static const String post_process_method_name("postprocess");
+static const String response_body_file_name("file");
+
+static const String download_name_upper(DOWNLOAD_NAME_UPPER);
+static const String body_name_upper(BODY_NAME_UPPER);
+
+// more static
+
+static const String content_type_name_upper(HTTP_CONTENT_TYPE_UPPER);
+static const String content_disposition_name_upper(CONTENT_DISPOSITION_UPPER);
+static const String content_disposition_inline(CONTENT_DISPOSITION_INLINE);
+static const String content_disposition_attachment(CONTENT_DISPOSITION_ATTACHMENT);
+
+// defines
+
+#define CHARSET_NAME_UPPER "CHARSET"
+#define LAST_MODIFIED_NAME_UPPER "LAST-MODIFIED"
 
-/// $limits.post_max_size default 10M
-const size_t MAX_POST_SIZE_DEFAULT=10*0x400*400;
+// op.C
+VStateless_class& VClassMAIN_create();
 
 //
-Request::Request(Pool& apool,
-				 Info& ainfo,
-				 String::Untaint_lang adefault_lang) : Pooled(apool),
-	stack(apool),
-	ROOT(apool),
-	env(apool),
-	form(apool),
-	request(apool, *this),
-	response(apool),
-	cookie(apool),
-	fclasses(apool),
-	fdefault_lang(adefault_lang), flang(adefault_lang),
-	info(ainfo),
-	default_content_type(0),
-	used_files(apool)
+Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, 
+				 String::Language adefault_lang):
+	// private
+	anti_endless_execute_recoursion(0),
+
+	// public
+	allow_class_replace(false),
+	method_frame(0),
+	rcontext(0),
+	wcontext(0),
+	flang(adefault_lang),
+	fconnection(0),
+	fin_cycle(0),
+	fskip(SKIP_NOTHING),
+
+	// public
+	request_info(arequest_info),
+	sapi_info(asapi_info),
+	charsets(pa_UTF8_charset, pa_UTF8_charset, pa_UTF8_charset), // default charsets
+
+	main_class(VClassMAIN_create()),
+	form(*new VForm(charsets, arequest_info)),
+	mail(*new VMail),
+	response(*new VResponse(arequest_info, charsets)),
+	cookie(*new VCookie(charsets, arequest_info)),
+	console(*new VConsole),
+
+	// private
+	configure_admin_done(false),
+
+	// private defaults
+	fdefault_lang(adefault_lang), 
+	// private mime types
+	mime_types(0)
 {
-	// root superclass, 
-	//   parent of all classes, 
-	//   operators holder
-	initialize_root_class(pool(), ROOT);
-	classes().put(*root_class_name, &ROOT);
-	// table class
-	classes().put(*table_class_name, table_class);	
+	pa_register_thread_request(*this);
+
+	// file_no=0 => unknown
+	file_list+="UNKNOWN";
+	file_list+="-body of process-"; // pseudo_file_no__process
+
+	// maybe expire old caches
+	cache_managers->maybe_expire();
+	
+	/// directly used
+	// MAIN class, operators
+	put_class(&main_class);
+	// classes:
+	// table, file, random, mail, image, ...
+	methoded_array().register_directly_used(*this);
+
+	/// methodless
 
 	// env class
-	classes().put(*env_class_name, &env);
-	// form class
-	classes().put(*form_class_name, &form);	
+	put_class(new VEnv(asapi_info));
+	// status class
+	put_class(new VStatus());
 	// request class
-	classes().put(*request_class_name, &request);	
-	// response class
-	classes().put(*response_class_name, &response);	
+	put_class(new VRequest(arequest_info, charsets, form, asapi_info));
 	// cookie class
-	classes().put(*cookie_class_name, &cookie);
+	put_class(&cookie);
+	// console class
+	put_class(&console);
+
+	/// methoded
+
+	// response class
+	put_class(&response);
+	// form class
+	put_class(&form);
+	// mail class
+	put_class(&mail);
+	// math class
+	put_class(new VMath);
+	// memory class
+	put_class(new VMemory);
 }
 
-static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning, 
-								 void *info) {
-	String *attribute_to_exclude=static_cast<String *>(info);
-	if(aattribute==*attribute_to_exclude)
-		return;
+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);
+		pa_free((void *)xml_generic_errors);
+	}
+#endif
+}
 
-	Value& lmeaning=*static_cast<Value *>(ameaning);
-	Pool& pool=lmeaning.pool();
+Value& Request::get_self() { return method_frame/*always have!*/->self(); }
 
-	String attribute(pool);
-	SAPI::add_header_attribute(pool,
-		attribute.append(aattribute, String::UL_HEADER, true).cstr(), 
-		attributed_meaning_to_string(lmeaning).cstr());
+VStateless_class* Request::get_class(const String& name){
+	VStateless_class* result=classes().get(name);
+	if(!result)
+		if(const Method *method=main_class.get_element_method(autouse_method_name)){
+			Value *vname=new VString(name);
+			CONSTRUCTOR_FRAME_ACTION(*method, 0 /*no parent*/, main_class, {
+				frame.store_params(&vname, 1);
+				// we don't need the result
+				call(frame);
+			});
+			result=classes().get(name);
+		}
+	return result;
+}
+
+static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, Request_charsets* charsets) {
+	pa_charsets.load_charset(*charsets, akey, avalue->as_string());
 }
 
+
+#define CONF_OPTION(config, name, code, exception_name)		\
+	if(config)						\
+		if(Value* option=config->get_element(name)) {	\
+			if(option->is_evaluated_expr()) {	\
+				code;				\
+			} else					\
+				throw Exception(PARSER_RUNTIME, 0, "$main:" exception_name, name.cstr()); \
+		}
+
+void Request::configure_admin(VStateless_class& conf_class) {
+	if(configure_admin_done)
+		throw Exception(PARSER_RUNTIME, 0, "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)) {
+		if(!vcharsets->is_string()) {
+			if(HashStringValue* charsets=vcharsets->get_hash())
+				charsets->for_each<Request_charsets*>(load_charset, &this->charsets);
+			else
+				throw Exception(PARSER_RUNTIME, 0, "$main:%s must be hash", charsets_name.cstr());
+		}
+	}
+
+#ifdef STRICT_VARS
+	VVoid::strict_vars=false;
+	if(Value* strict_vars=conf_class.get_element(strict_vars_name)) {
+		if(strict_vars->is_bool())
+			VVoid::strict_vars=strict_vars->as_bool();
+		else
+			throw Exception(PARSER_RUNTIME, 0, "$main:%s must be bool", strict_vars_name.cstr());
+	}
+#endif
+
+#ifdef OBJECT_PROTOTYPE
+	VClass::prototype=true;
+	if(Value* prototype=conf_class.get_element(prototype_name)) {
+		if(prototype->is_bool())
+			VClass::prototype=prototype->as_bool();
+		else
+			throw Exception(PARSER_RUNTIME, 0, "$main:%s must be bool", prototype_name.cstr());
+	}
+#endif
+
+	Value* limits=conf_class.get_element(limits_name);
+
+	pa_loop_limit=LOOP_LIMIT;
+	CONF_OPTION(limits, loop_limit_name, {
+		pa_loop_limit=option->as_int();
+		if(pa_loop_limit==0) pa_loop_limit=INT_MAX;
+	}, "LIMITS.%s must be int");
+
+	pa_execute_recoursion_limit=EXECUTE_RECOURSION_LIMIT;
+	CONF_OPTION(limits, recoursion_limit_name, {
+		pa_execute_recoursion_limit=option->as_int();
+		if(pa_execute_recoursion_limit==0) pa_execute_recoursion_limit=INT_MAX;
+	}, "LIMITS.%s must be int");
+
+	pa_file_size_limit=FILE_SIZE_LIMIT;
+	CONF_OPTION(limits, file_size_limit_name, {
+		double limit=option->as_double();
+		if(limit >= (double)SSIZE_MAX)
+			throw Exception(PARSER_RUNTIME, 0, "$main:LIMITS.%s must be less then %.15g", file_size_limit_name.cstr(), (double)SSIZE_MAX);
+		pa_file_size_limit=(size_t)limit;
+		if(pa_file_size_limit==0)
+			pa_file_size_limit=SSIZE_MAX;
+	}, "LIMITS.%s must be number");
+
+	pa_lock_attempts=PA_LOCK_ATTEMPTS;
+	CONF_OPTION(limits, lock_wait_timeout_name, {
+		double limit=option->as_double();
+		if(limit >= 3600*24)
+			throw Exception(PARSER_RUNTIME, 0, "$main:LIMITS.%s must be less then %d", lock_wait_timeout_name.cstr(), 3600*24);
+		pa_lock_attempts=(unsigned int)(limit*2)+1;
+	}, "LIMITS.%s must be number");
+
+	Value* httpd=conf_class.get_element(httpd_name);
+
+	pa_httpd_timeout=HTTPD_TIMEOUT;
+	CONF_OPTION(httpd, httpd_timeout_name, {
+		pa_httpd_timeout=option->as_int();
+		if(pa_httpd_timeout==0) pa_httpd_timeout=INT_MAX;
+	}, "HTTPD.%s must be int");
+
+	if(httpd)
+		if(Value* option=httpd->get_element( httpd_mode_name)) {
+			if(option->get_junction())
+				throw Exception(PARSER_RUNTIME, 0, "$main:HTTPD:mode must be string");
+			HTTPD_Server::set_mode(option->as_string());
+		}
+
+	// configure method_frame options
+	//	until someone with less privileges have overriden them
+	methoded_array().configure_admin(*this);
+}
+
+const char* Request::get_exception_cstr(const Exception& e, Request::Exception_details& details) {
+
+#define PA_URI_FORMAT "%s: "
+#define PA_COMMENT_TYPE_FORMAT "%s [%s]"
+
+#define PA_ORIGIN_FILE_POS_FORMAT "%s(%d:%d): "
+#define PA_SOURCE_FORMAT "'%s' "
+
+#define PA_ORIGIN_FILE_POS_VALUE file_list[details.origin.file_no].cstr(), 1+details.origin.line, 1+details.origin.col,
+#define PA_SOURCE_VALUE details.problem_source->cstr(),
+
+#define EXCEPTION_CSTR(f1,v1,f2,v2) \
+			snprintf(result, MAX_STRING, \
+				PA_URI_FORMAT \
+				f1 f2 \
+				PA_COMMENT_TYPE_FORMAT, \
+				request_info.uri, \
+				v1 v2 \
+				e.comment(), e.type() \
+			);
+
+	char* result=new(PointerFreeGC) char[MAX_STRING];
+
+	if(details.problem_source) { // do we know the guy?
+		if(details.origin.file_no) // do whe know where he came from?
+			EXCEPTION_CSTR(PA_ORIGIN_FILE_POS_FORMAT, PA_ORIGIN_FILE_POS_VALUE, PA_SOURCE_FORMAT, PA_SOURCE_VALUE)
+		else
+			EXCEPTION_CSTR(PA_SOURCE_FORMAT, PA_SOURCE_VALUE,,)
+	} else {
+		if(details.origin.file_no) // do whe know where he came from?
+			EXCEPTION_CSTR(PA_ORIGIN_FILE_POS_FORMAT, PA_ORIGIN_FILE_POS_VALUE,,)
+		else
+			EXCEPTION_CSTR(,,,)
+	}
+
+	return result;
+}
+
+void Request::configure() {
+	// configure admin options if not configured yet
+	if(!configure_admin_done)
+		configure_admin(main_class);
+
+	// configure not-admin=user options
+	methoded_array().configure_user(*this);
+
+	// $MAIN:MIME-TYPES
+	if(Value* element=main_class.get_element(mime_types_name))
+		if(Table *table=element->get_table())
+			mime_types=table;
+}
 /**
 	load MAIN class, execute @main.
 	MAIN class consists of all the auto.p files we'd manage to find
@@ -85,374 +400,638 @@ static void add_header_attribute(const H
 	the file user requested us to process
 	all located classes become children of one another,
 	composing class we name 'MAIN'
-*/
-void Request::core(const char *root_auto_path, bool root_auto_fail,
-				   const char *site_auto_path, bool site_auto_fail,
-				   bool header_only) {
-	VStateless_class *main_class=0;
-	bool need_rethrow=false;  Exception rethrow_me;
-	TRY {
-		char *auto_filespec=(char *)malloc(MAX_STRING);
-		
-		// loading root auto.p 
-		if(root_auto_path) {
-			String& filespec=*NEW String(pool());
-			filespec.APPEND(root_auto_path, 0, "root_auto", 0);
-			filespec.APPEND_CONST("/" AUTO_FILE_NAME);
-			main_class=use_file(
-				filespec, root_auto_fail,
-				main_class_name, main_class);
-		}
-
-		// $MAIN:limits hash used here,
-		//	until someone with less privileges have overriden them
-		{
-			Value *limits=main_class?main_class->get_element(*limits_name):0;
-			// $limits.post_max_size default 10M
-			Value *element=limits?limits->get_element(*post_max_size_name):0;
-			size_t value=element?(size_t)element->get_double():0;
-			size_t post_max_size=value?value:MAX_POST_SIZE_DEFAULT;
-			
-			form.fill_fields(*this, post_max_size);
-		}
-
-		// filling cookies
-		cookie.fill_fields(*this);
-
-		// loading site auto.p
-		if(site_auto_path) {
-			String& filespec=*NEW String(pool());
-			filespec.APPEND(site_auto_path, 0, "site_auto", 0);
-			filespec.APPEND_CONST("/" AUTO_FILE_NAME);
-			main_class=use_file(
-				filespec, site_auto_fail,
-				main_class_name, main_class);
-		}
 
-		// loading auto.p files from document_root/.. 
-		// to the one beside requested file.
-		// all assigned bases from upper dir
-		{
-			/* /document/root */
-			char *file_spec=
-				(char *)malloc(strlen(info.path_translated)+strlen(AUTO_FILE_NAME)+1);
-			strcpy(file_spec, info.document_root);
-
-			/* /requested/file.html */
-			char *branches=(char *)malloc(strlen(info.path_translated)+1);
-			strcpy(branches, info.path_translated+strlen(info.document_root));
-			char *next=branches;
-
-			char *append_here=file_spec+strlen(file_spec);
-			size_t slash_auto_p_size=strlen("/" AUTO_FILE_NAME);
-			while(true) {
-				char *step=lsplit(&next, '/');
-				if(next) { // not 'file.html' part
-					size_t step_size=strlen(step);
-					memcpy(append_here, step, step_size);
-					append_here+=step_size;
-					memcpy(append_here, "/" AUTO_FILE_NAME, slash_auto_p_size+1);
-					append_here++/* / */;
-
-					String& sfile_spec=*NEW String(pool());
-					sfile_spec.APPEND(file_spec, 0, "scanned", 0);
-					main_class=use_file(sfile_spec, false/*ignore read problem*/,
-						main_class_name, main_class);
-				} else
-					break;
-			}
-		}
+	@test log stack trace
 
-		// compiling requested file
-		String& spath_translated=*NEW String(pool());
-		spath_translated.APPEND(info.path_translated, 0, "user-request", 0);
-		main_class=use_file(spath_translated, true/*don't ignore read problem*/,
-			main_class_name, main_class);
-
-		// $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)
-			:NEW VString(*NEW String(pool(), "text/html"));
-		if(Value *element=main_class->get_element(*html_typo_name))
-			if(VTable *vtable=element->get_vtable())
-				pool().set_tag(&vtable->table());
+*/
+void Request::core(const char* config_filespec, bool header_only, const String &amain_method_name) {
+	try {
+		// loading config
+		if(config_filespec)
+			use_file_directly(*new String(config_filespec));
+
+		// filling mail received
+		mail.fill_received(*this);
+
+		try {
+			// compile requested file
+			if(request_info.path_translated)
+				use_file_directly(*new String(request_info.path_translated, String::L_TAINTED), true, true /* load auto.p files */);
+			configure();
+		} catch(...) {
+			configure(); // configure anyway, useful in @unhandled_exception [say, if they would want to mail by SMTP something]
+			rethrow;
+		}
 
 		// execute @main[]
-		const String *body_string=execute_method(*main_class, *main_method_name);
+		const String* body_string=amain_method_name.is_empty() ? &String::Empty : execute_method(main_class, amain_method_name);
 		if(!body_string)
-			THROW(0,0,
-			0, 
-			"'"MAIN_METHOD_NAME"' method not found");
+			throw Exception(PARSER_RUNTIME, 0, "'%s' method not found", amain_method_name.cstr());
 
 		// extract response body
-		Value *body_value=static_cast<Value *>(
-			response.fields().get(*body_name));
-		if(body_value) // there is some $request.body
-			body_string=&body_value->as_string();// TODO: IMAGE&FILE
+		Value* body_value=response.fields().get(download_name_upper); // $response:download?
+		bool as_attachment=body_value!=0;
+		if(!body_value)
+			body_value=response.fields().get(body_name_upper); // $response:body
+		if(!body_value)
+			body_value=new VString(*body_string); // just result of ^main[]
+
+		// @postprocess
+		if(const Method *method=main_class.get_method(post_process_method_name)) {
+			// preparing to pass parameters to
+			//	@postprocess[data]
+			METHOD_FRAME_ACTION(*method, 0 /*no parent*/, main_class, {
+				frame.store_params(&body_value, 1);
+				call(frame);
+				body_value=&frame.result();
+			});
+		}
+
+		VFile* body_file=body_value->as_vfile(flang, &charsets);
 
 		// OK. write out the result
-		output_result(*body_string, header_only);
-	} 
-	CATCH(e) { // request handling problem
+		output_result(body_file, header_only, as_attachment);
+
+	} catch(const Exception& e) { // request handling problem
+		try {
 		// we're returning not result, but error explanation
-		TRY {
-			// log the beast
-			const String *problem_source=e.problem_source();
-			if(problem_source)
-				SAPI::log(pool(),
-#ifndef NO_STRING_ORIGIN
-					"%s(%d): "
-#endif
-					"'%s' %s [%s %s]",
-#ifndef NO_STRING_ORIGIN
-					problem_source->origin().file?problem_source->origin().file:"global",
-					problem_source->origin().line,
-#endif
-					problem_source->cstr(),
-					e.comment(),
-					e.type()?e.type()->cstr():"-",
-					e.code()?e.code()->cstr():"-"
-				);
-			else
-				SAPI::log(pool(),
-					"%s [%s %s]",
-					e.comment(),
-					e.type()?e.type()->cstr():"-",
-					e.code()?e.code()->cstr():"-"
-					);
-
-			// 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;
-
-			if(main_class) { // we've managed to end up with some main_class
-				// maybe we'd be lucky enough as to report an error
-				// in a gracefull way...
-				if(Value *value=main_class->get_element(*exception_method_name))
-					if(Junction *junction=value->get_junction())
-						if(const Method *method=junction->method) {
-							// preparing to pass parameters to 
-							//	@exception[origin;source;comment;type;code]
-							VMethodFrame frame(pool(), *junction);
-							frame.set_self(*main_class);
-
-							const String *problem_source=e.problem_source();
-							// origin
-							String origin_name(pool(), "origin");
-							Value *origin_value=0;
-#ifndef NO_STRING_ORIGIN
-							if(problem_source) {
-								const Origin& origin=problem_source->origin();
-								if(origin.file) {
-									char *buf=(char *)malloc(MAX_STRING);
-									snprintf(buf, MAX_STRING, "%s(%d):", 
-										origin.file, 1+origin.line);
-									String *origin_file_line=NEW String(pool(),
-										buf, true);
-									origin_value=NEW VString(*origin_file_line);
-								}
-							}
-#endif
-							frame.store_param(origin_name, 
-								origin_value?origin_value:NEW VUnknown(pool()));
 
-							// source
-							String source_name(pool(), "source");
-							Value *source_value=0;
-							if(problem_source) {
-								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(source_name, 
-								source_value?source_value:NEW VUnknown(pool()));
-
-							// comment
-							String comment_name(pool(), "comment");
-							String *comment_value=NEW String(pool(),
-								e.comment(), true);
-							frame.store_param(comment_name, 
-								NEW VString(*comment_value));
-
-							// type
-							String type_name(pool(), "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 VUnknown(pool());
-							frame.store_param(type_name, type_value);
-
-							// code
-							String code_name(pool(), "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 VUnknown(pool());
-							frame.store_param(code_name, code_value);
-
-							// future $response:body=
-							//   execute ^exception[origin;source;comment;type;code]
-							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=(char *)malloc(MAX_STRING);
-				size_t printed=0;
-				const String *problem_source=e.problem_source();
-				if(problem_source) {
-#ifndef NO_STRING_ORIGIN
-					const Origin& origin=problem_source->origin();
-					if(origin.file)
-						printed+=snprintf(buf+printed, MAX_STRING-printed, "%s(%d): ", 
-						origin.file, 1+origin.line);
-#endif
-					printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ", 
-						problem_source->cstr());
-				}
-				printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", 
-					e.comment());
-				const String *type=e.type();
-				if(type) {
-					printed+=snprintf(buf+printed, MAX_STRING-printed, "  type: %s", 
-						type->cstr());
-					const String *code=e.code();
-					if(code)
-						printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s", 
-						code->cstr());
+		Request::Exception_details details=get_details(e);
+		const char* exception_cstr=get_exception_cstr(e, details);
+
+		// 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(const Method *method=main_class.get_method(*new String(UNHANDLED_EXCEPTION_METHOD_NAME))) {
+			// preparing to pass parameters to 
+			//	@unhandled_exception[exception;stack]
+
+			// $stack[^table::create{name	file	lineno	colno}]
+			Table::columns_type stack_trace_columns(new ArrayString);
+			*stack_trace_columns+=new String("name");
+			*stack_trace_columns+=new String("file");
+			*stack_trace_columns+=new String("lineno");
+			*stack_trace_columns+=new String("colno");
+			Table& stack_trace=*new Table(stack_trace_columns);
+			if(!exception_trace.is_empty()/*signed!*/) 
+				for(size_t i=exception_trace.bottom_index(); i<exception_trace.top_index(); i++) {
+					Trace trace=exception_trace.get(i);
+					Table::element_type row(new ArrayString);
+
+					*row+=trace.name(); // name column
+					Operation::Origin origin=trace.origin();
+					if(origin.file_no) {
+						*row+=new String(file_list[origin.file_no], String::L_TAINTED); // 'file' column
+						*row+=new String(String::Body::Format(1+origin.line), String::L_CLEAN); // 'lineno' column
+						*row+=new String(String::Body::Format(1+origin.col), String::L_CLEAN); // 'colno' column
+					}
+					stack_trace+=row;
 				}
 
-				// future $response:content-type
-				response.fields().put(*content_type_name, 
-					NEW VString(*NEW String(pool(), "text/plain")));
-				// future $response:body
-				body_string=NEW String(pool(), buf);
-			}
+			// future $response:body=
+			//   execute ^unhandled_exception[exception;stack]
+			exception_trace.clear(); // forget all about previous life, in case there would be error inside of this method, error handled  would not be mislead by old stack contents (see extract_origin)
+
+			Value *params[]={&details.vhash, new VTable(&stack_trace)};
+			METHOD_FRAME_ACTION(*method, 0 /*no caller*/, main_class, {
+				frame.store_params(params, 2);
+				call(frame);
+				body_string=&frame.result().as_string();
+			});
+		}
+		
+		// conditionally log it
+		Value* vhandled=details.vhash.hash().get(exception_handled_part_name);
+		if(!vhandled || !vhandled->as_bool()) {
+			SAPI::log(sapi_info, "%s", exception_cstr);
+		}
 
-			// ERROR. write it out
-			output_result(*body_string, header_only);
+		if(body_string) {  // could report an error beautifully?
+			VString body_vstring(*body_string);
+			VFile* body_file=body_vstring.as_vfile(flang, &charsets);
+			// write it out the error
+			output_result(body_file, header_only, false);
+		} else {
+			// doing that ugly
+			SAPI::send_error(sapi_info, exception_cstr, !strcmp(e.type(), "file.missing") ? "404" : "500");
 		}
-		CATCH(e) {
-			// exception in request exception handler
-			// remember to rethrow it
-			rethrow_me=e;  need_rethrow=true; 
+
+		} catch(const Exception& e) { // exception in unhandled exception
+			Request::Exception_details details=get_details(e);
+			const char* exception_cstr=get_exception_cstr(e, details);
+			// unconditionally log the beast in exception handler
+			throw Exception(0, 0, "Unhandled exception in %s", exception_cstr);
 		}
-		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) // there were an exception set for us to rethrow?
-		THROW(rethrow_me.type(), rethrow_me.code(),
-			rethrow_me.problem_source(),
-			rethrow_me.comment());
+}
 
+uint Request::register_file(String::Body file_spec) {
+	file_list+=file_spec;
+	return file_list.count()-1;
 }
 
-VStateless_class *Request::use_file(const String& file_spec, bool fail_on_read_problem,
-									const String *name, 
-									VStateless_class *base_class) {
+void Request::use_file_directly(const String& file_spec, bool fail_on_file_absence, bool with_auto_p) {
 	// cyclic dependence check
 	if(used_files.get(file_spec))
-		return base_class;
-	used_files.put(file_spec, (Hash::Val *)true);
+		return;
+	used_files.put(file_spec, true);
+
+	if(!fail_on_file_absence && !entry_exists(file_spec)) // ignore file absence if asked for
+		return;
+
+	if(with_auto_p) {
+		// loading auto.p files from document_root/.. 
+		// to the one beside requested file.
+		// all assigned bases from upper dir
+		const char* target=file_spec.cstr();
+
+		// all relative paths are calculated from main document
+		request_info.path_translated=target;
 
+		const char* after=target;
+		size_t drlen=strlen(request_info.document_root);
+		if(memcmp(after, request_info.document_root, drlen)==0) {
+			after+=drlen;
+			if(after[-1]=='/') 
+				--after;
+		}
+
+		while(const char* before=strchr(after, '/')) {
+			String& sfile_spec=*new String;
+			if(after!=target) {
+				sfile_spec.append_strdup(target, before-target, String::L_CLEAN);
+				sfile_spec << "/" AUTO_FILE_NAME;
 
-	char *source=file_read_text(pool(), file_spec, fail_on_read_problem);
-	if(!source)
-		return base_class;
+				use_file_directly(sfile_spec, false /*ignore absence, sole user*/);
+			}
+			for(after=before+1;*after=='/';after++);
+		}
+	}
 
-	return use_buf(source, file_spec.cstr(), 0/*new class*/, name, base_class);
+	if(const char* source=file_read_text(charsets, file_spec, true))
+		use_buf(main_class, source, 0, register_file(file_spec));
 }
 
-VStateless_class *Request::use_buf(const char *source, const char *file,
-								   VStateless_class *aclass, const String *name, 
-								   VStateless_class *base_class) {
-	// compile loaded class
-	VStateless_class& cclass=COMPILE(source, aclass, name, base_class, file);
 
-	// locate and execute possible @auto[] static method
-	execute_method(cclass, *auto_method_name, false /*no result needed*/);
-	return &cclass;
+void Request::use_file(const String& file_name, const String* use_filespec/*absolute*/, bool with_auto_p) {
+	if(file_name.is_empty())
+		throw Exception(PARSER_RUNTIME, 0, "usage failed - no filename was specified");
+
+	const String* filespec=0;
+
+	if(file_name.first_char()=='/') //absolute path? [no need to scan MAIN:CLASS_PATH]
+		filespec=&full_disk_path(file_name);
+	else if(use_filespec){ // search in current dir first
+		size_t last_slash_pos=use_filespec->strrpbrk("/");
+		if(last_slash_pos!=STRING_NOT_FOUND)
+			filespec=file_exist(use_filespec->mid(0, last_slash_pos), file_name); // found in current dir?
+	}
+
+	if(!filespec){
+		// prevent multiple scan CLASS_PATH for searching one file
+		if(searched_along_class_path.get(file_name))
+			return;
+		searched_along_class_path.put(file_name, true);
+		if(Value* element=main_class.get_element(class_path_name)) {
+			if(element->is_string()) {
+				filespec=file_exist(full_disk_path(element->as_string()), file_name); // found at class_path?
+			} else if(Table *table=element->get_table()) {
+				for(size_t i=table->count(); i--; ) {
+					const String& path=*(*table->get(i))[0];
+					if(filespec=file_exist(full_disk_path(path), file_name))
+						break; // found along class_path
+				}
+			} else
+				throw Exception(PARSER_RUNTIME, 0, "$" CLASS_PATH_NAME " must be string or table");
+			if(!filespec)
+				throw Exception(PARSER_RUNTIME, &file_name, "not found along $main:" CLASS_PATH_NAME);
+		} else 
+			throw Exception(PARSER_RUNTIME, &file_name, "usage failed - no $main:" CLASS_PATH_NAME " were specified");
+	}
+
+	use_file_directly(*filespec, true, with_auto_p);
 }
 
-/**
-	- fail_if_junction(true, junction = fail
-	- fail_if_junction(false, not junction = fail
-*/
-void Request::fail_if_junction_(bool is, Value& value, 
-								const String& method_name, const char *msg) {
+void Request::use_file(const String& file_name, const String* use_filespec/*absolute*/, Operation::Origin origin) {
+	static String use("USE");
+	try {
+		static VHash* voptions=new VHash();
+		if(const Method *method=main_class.get_method(use_method_name)){
+			Value *params[]={new VString(file_name), voptions};
+			voptions->hash().put(origin_key, new VString(*use_filespec));
+
+			CONSTRUCTOR_FRAME_ACTION(*method, 0 /*no parent*/, main_class, {
+				frame.store_params(params, 2);
+				// we don't need the result
+				call(frame);
+			});
+		}
+	} catch (...) {
+		exception_trace.push(Trace(&use, origin));
+		rethrow;
+	}
+}
 
-	if((value.get_junction()!=0) ^ !is)
-		THROW(0, 0,
-			&method_name,
-			msg);
-}
-
-const String& Request::relative(const char *apath, const String& relative_name) {
-	int lpath_buf_size=strlen(apath)+1;
-    char *lpath=(char *)malloc(lpath_buf_size);
-	memcpy(lpath, apath, lpath_buf_size);
-    rsplit(lpath, '/');
-	String& result=*NEW String(pool(), lpath);
-    result.APPEND_CONST("/");
-	result.append(relative_name, String::UL_PASS_APPENDED);
-    return result;
-}
-
-const String& Request::absolute(const String& relative_name) {
-	char *relative_name_cstr=relative_name.cstr();
-	if(relative_name_cstr[0]=='/') {
-		String& result=*NEW String(pool(), info.document_root);
-		result.append(relative_name, String::UL_PASS_APPENDED);
+void Request::use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset) {
+	// temporary zero @conf to avoid it second execution
+	Temp_method temp_method_conf(aclass, conf_method_name, 0);
+	// temporary zero @auto to avoid it second execution
+	Temp_method temp_method_auto(aclass, auto_method_name, 0);
+
+	// compile loaded classes
+	ArrayClass& cclasses=compile(&aclass, source, main_alias, file_no, line_no_offset);
+
+	VString* vfilespec=
+		new VString(*new String(file_list[file_no], String::L_TAINTED));
+
+	for(size_t i=0; i<cclasses.count(); i++){
+		VStateless_class& cclass=*cclasses.get(i);
+
+		// locate and execute possible @conf[] static
+		if(execute_method_if_exists(cclass, conf_method_name, vfilespec))
+			configure_admin(cclass/*, executed.method->name*/);
+
+		// locate and execute possible @auto[] static
+		execute_method_if_exists(cclass, auto_method_name, vfilespec);
+
+		cclass.enable_default_setter();
+	}
+}
+
+const String& Request::relative(const char* apath, const String& relative_name) {
+	char *hpath=pa_strdup(apath);
+	String& result=*new String;
+	if(rsplit(hpath, '/')) // if something/splitted
+		result << hpath << "/";
+	result << relative_name;
+	return result;
+}
+
+const String& Request::full_disk_path(const String& relative_name) {
+	if(relative_name.first_char()=='/') {
+		String& result=*new String(pa_strdup(request_info.document_root));
+		result << relative_name;
 		return result;
-	} else 
-		return relative(info.path_translated, relative_name);
+	}
+	if(relative_name.pos("://")!=STRING_NOT_FOUND // something like "http://xxx"
+#ifdef WIN32
+		|| relative_name.pos(":")==1  // DRIVE:
+		|| relative_name.starts_with("\\\\") // UNC1
+		|| relative_name.starts_with("//") // UNC2
+#endif
+		)
+		return relative_name;
+
+	return relative(request_info.path_translated ? request_info.path_translated : request_info.document_root, relative_name);
 }
 
-void Request::output_result(const String& body_string, bool header_only) {
-	// header: cookies
-	cookie.output_result();
+#ifndef DOXYGEN
+class Add_header_attribute_info
+{
+public:
+	Add_header_attribute_info(Request& ar) : r(ar), add_last_modified(true) {}
+	Request& r;
+	bool add_last_modified;
+};
+#endif
+static void add_header_attribute(HashStringValue::key_type name, HashStringValue::value_type value, Add_header_attribute_info* info) {
+	if(name==BODY_NAME_UPPER || name==DOWNLOAD_NAME_UPPER || name==CHARSET_NAME_UPPER)
+		return;
 	
-	// set default content-type
-	response.fields().put_dont_replace(*content_type_name, default_content_type);
+	if(name==LAST_MODIFIED_NAME_UPPER)
+		info->add_last_modified=false;
 
-	// prepare header: $response:fields without :body
-	response.fields().for_each(add_header_attribute, /*excluding*/ body_name);
+	const char* aname=String(name, String::L_URI).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets);
 
-	// prepare...
-	const char *body=body_string.cstr();
-	size_t content_length=strlen(body);
-
-	// prepare header: content-length
-	if(content_length) { // useful for redirecting [header "location: http://..."]
-		char content_length_cstr[MAX_NUMBER];
-		snprintf(content_length_cstr, MAX_NUMBER, "%lu", content_length);
-		SAPI::add_header_attribute(pool(), "content-length", content_length_cstr);
-	}
+	SAPI::add_header_attribute(info->r.sapi_info,
+			aname,
+			attributed_meaning_to_string(*value, String::L_URI, false).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets)
+		);
+}
+
+static void output_sole_piece(Request& r, bool header_only, VFile& body_file, Value* body_file_content_type) {
+	// transcode text body when "text/*" or simple result
+	String::C output(body_file.value_ptr(), body_file.value_size());
+	if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string().pos("text/")==0)
+		output=Charset::transcode(output, r.charsets.source(), r.charsets.client());
+
+	// prepare header: Content-Length
+	SAPI::add_header_attribute(r.sapi_info, HTTP_CONTENT_LENGTH, format(output.length, "%u"));
 
 	// send header
-	SAPI::send_header(pool());
+	SAPI::send_header(r.sapi_info);
 	
 	// send body
 	if(!header_only)
-		SAPI::send_body(pool(), body, content_length);
+		SAPI::send_body(r.sapi_info, output.str, output.length);
+}
+
+#ifndef DOXYGEN
+struct Range
+{
+	uint64_t start;
+	uint64_t end;
+};
+#endif
+
+#define UNSET ((uint64_t)-1)
+
+static void parse_range(const String* s, Array<Range> &ar) {
+	const char *p = s->cstr();
+	if(s->starts_with("bytes="))
+		p += 6;
+	Range r;
+	while(*p){
+		r.start = UNSET;
+		r.end = UNSET;
+
+		while(*p==' ' || *p=='\t') p++;
+
+		if(*p >= '0' && *p <= '9'){
+			const char *s=p;
+			while(*p>='0' && *p<='9') p++;
+			r.start = pa_atoul(pa_strdup(s,p-s));
+		}
+
+		while(*p==' ' || *p=='\t') p++;
+
+		if(*p++ != '-') break;
+
+		while(*p==' ' || *p=='\t') p++;
+
+		if(*p >= '0' && *p <= '9'){
+			const char *s=p;
+			while(*p>='0' && *p<='9') p++;
+			r.end = pa_atoul(pa_strdup(s,p-s));
+		}
+
+		while(*p==' ' || *p=='\t') p++;
+
+		if(*p)
+			if(*p++ != ',') break;
+
+		ar += r;
+	}
+}
+
+struct Send_range_action_info {
+	Request *r;
+	uint64_t offset;
+	uint64_t part_length;
+};
+
+static void send_range(struct stat& /*finfo*/, int f, const String& /*file_spec*/, void *context){
+	Send_range_action_info &info = *(Send_range_action_info*)context;
+
+	pa_lseek(f, info.offset, SEEK_SET);
+
+	const size_t BUFSIZE = 128*0x400;
+	char buf[BUFSIZE];
+	do{
+		size_t to_read = info.part_length < BUFSIZE ? (size_t)info.part_length : BUFSIZE;
+		size_t to_write = file_block_read(f, buf, to_read);
+
+		if(to_write == 0)
+			break;
+
+		size_t size = SAPI::send_body(info.r->sapi_info, buf, to_write);
+		if(size != to_write)
+			break;
+
+		info.part_length -= to_write;
+	} while (info.part_length);
+}
+
+static void output_pieces(Request& r, bool header_only, const String& filename, uint64_t content_length, Value& date, bool add_last_modified) {
+	SAPI::add_header_attribute(r.sapi_info, "accept-ranges", "bytes");
+
+	const char *range = SAPI::Env::get(r.sapi_info, "HTTP_RANGE");
+	uint64_t offset=0;
+	uint64_t part_length=content_length;
+
+	if(range && content_length){
+		Array<Range> ar;
+		parse_range(new String(range), ar);
+		int count = ar.count();
+		if(count == 1){
+			Range &rg = ar.get_ref(0);
+
+			if(rg.start == UNSET && rg.end == UNSET)
+				return SAPI::send_error(r.sapi_info, "", "416");
+
+			if(rg.start == UNSET && rg.end != UNSET){
+				if(rg.end > content_length)
+					rg.end = content_length;
+				rg = { content_length - rg.end, content_length-1 };
+			} else if(rg.start != UNSET && rg.end == UNSET){
+				if(rg.start >= content_length)
+					return SAPI::send_error(r.sapi_info, "", "416");
+				rg.end = content_length-1;
+			} else {
+				if(rg.start >= content_length || rg.start > rg.end)
+					return SAPI::send_error(r.sapi_info, "", "416");
+				if(rg.end >= content_length)
+					rg.end = content_length-1;
+			}
+
+			offset = rg.start;
+			part_length = rg.end-rg.start+1;
+
+			char buf[MAX_STRING];
+			snprintf(buf, MAX_STRING, "bytes %.15g-%.15g/%.15g", (double)rg.start, (double)rg.end, (double)content_length);
+			SAPI::add_header_attribute(r.sapi_info, HTTP_STATUS, "206");
+			SAPI::add_header_attribute(r.sapi_info, "content-range", buf);
+		} else {
+			return SAPI::send_error(r.sapi_info, count ? "Multiple ranges not supported" : "Invalid range", count ? "501" : "400");
+		}
+	}
+
+	SAPI::add_header_attribute(r.sapi_info, HTTP_CONTENT_LENGTH, format((double)part_length, "%.15g"));
+
+	if(add_last_modified)
+		SAPI::add_header_attribute(r.sapi_info, "last-modified", attributed_meaning_to_string(date, String::L_AS_IS, true).cstr());
+
+	SAPI::send_header(r.sapi_info);
+
+	if(!header_only){
+		Send_range_action_info info = { &r, offset, part_length};
+		file_read_action_under_lock(r.full_disk_path(filename), "send", send_range, &info);
+	}
+}
+
+void Request::output_result(VFile* body_file, bool header_only, bool as_attachment) {
+	// header: cookies
+	cookie.output_result(sapi_info);
+	
+	// $.file and $.name (when body is real vfile)
+	Value* vfile = body_file->fields().get(response_body_file_name);
+	Value* vname = body_file->fields().get(name_name);
+
+	const String* sfile = vfile ? &vfile->as_string() : NULL;
+	const String* sname = vname ? &vname->as_string() : NULL;
+
+	if(sname && *sname == NONAME_DAT)
+		sname = NULL;
+
+	// Content-Disposition
+	const String* disposition_name = sname ? sname->is_empty() ? NULL : sname : sfile;
+	if(disposition_name) {
+		VHash& hash=*new VHash();
+		hash.hash().put(value_name, new VString(as_attachment ? content_disposition_attachment : content_disposition_inline));
+		hash.hash().put(content_disposition_filename_name, new VString(*new String(*disposition_name, String::L_HTTP_HEADER)));
+		response.fields().put(content_disposition_name_upper, &hash);
+	}
+
+	// _file_ content-type might be specified
+	Value* body_file_content_type = body_file->fields().get(content_type_name);
+	if(!body_file_content_type){
+		const String* scontent_name = sname && !sname->is_empty() ? sname : sfile;
+		if(scontent_name)
+			body_file_content_type = new VString(mime_type_of(scontent_name->cstr()));
+	}
+
+	// set Content-Type
+	if(body_file_content_type) {
+		// body file content type
+		response.fields().put(content_type_name_upper, body_file_content_type);
+	} else {
+		// default content type
+		response.fields().put_dont_replace(content_type_name_upper, new VString(*new String(DEFAULT_CONTENT_TYPE)));
+	}
+
+	// prepare header: $response:fields without :body, :download and :charset
+	Add_header_attribute_info info(*this);
+	response.fields().for_each<Add_header_attribute_info*>(add_header_attribute, &info);
+
+	if(sfile) {
+		// $response:[download|body][$.file[filespec]] -- optput specified file
+		uint64_t content_length=0;
+		time_t atime=0, mtime=0, ctime=0;
+		file_stat(full_disk_path(*sfile), content_length, atime, mtime, ctime);
+
+		VDate* vdate=0;
+		if(Value* v=body_file->fields().get("mdate")) {
+			if(Value* vdatep=v->as(VDATE_TYPE))
+				vdate=static_cast<VDate*>(vdatep);
+			else 
+				throw Exception(PARSER_RUNTIME, 0, "mdate must be a date");
+		}
+		if(!vdate)
+			vdate=new VDate((pa_time_t)mtime);
+
+		output_pieces(*this, header_only, *sfile, content_length, *vdate, info.add_last_modified);
+	} else {
+		if(body_file_content_type)
+			if(HashStringValue *hash=body_file_content_type->get_hash())
+				body_file_content_type=hash->get(value_name);
+
+		output_sole_piece(*this, header_only, *body_file, body_file_content_type);
+	}
+}
+
+const String& Request::mime_type_of(const String* file_name) {
+	return mime_type_of(file_name?file_name->taint_cstr(String::L_FILE_SPEC):0);
+}
+
+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);
+			Table::Action_options options;
+			if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options)) {
+				if(const String* result=mime_types->item(1))
+					return *result;
+				else
+					throw Exception(PARSER_RUNTIME, 0, MIME_TYPES_NAME " table column elements must not be empty");
+			}
+		}
+
+	return *new String("application/octet-stream");
+}
+
+const String* Request::get_used_filespec(uint file_no){
+	if(file_no < file_list.count())
+		return new String(file_list[file_no], String::L_TAINTED);
+	return 0;
+}
+
+#ifdef XML
+xmlChar* Request::transcode(const String& s) {
+	return charsets.source().transcode(s);
+}
+
+xmlChar* Request::transcode(const String::Body s) {
+	return charsets.source().transcode(s);
+}
+
+const String& Request::transcode(const xmlChar* s) {
+	return charsets.source().transcode(s);
+}
+#endif
+
+Request::Exception_details Request::get_details(const Exception& e) {
+	const String* problem_source=e.problem_source();
+	VHash& vhash=*new VHash;  HashStringValue& hash=vhash.hash();
+	Operation::Origin origin={0, 0, 0};
+
+	if(!exception_trace.is_empty()) {
+		Trace bottom=exception_trace.bottom_value();
+		origin=bottom.origin();
+		if(!problem_source) { // we don't know who trigged the bug
+			problem_source=bottom.name(); // we usually know source of next-from-throw-point exception did that
+			exception_trace.set_bottom_index(exception_trace.bottom_index()+1);
+		} else if (bottom.name()==problem_source) { // it is that same guy?
+			exception_trace.set_bottom_index(exception_trace.bottom_index()+1); // throw away that trace
+		} else {
+			// stack top contains not us, leaving intact to help ^throw
+		}
+	}
+
+	// $.type
+	if(const char* type=e.type(true))
+		hash.put(exception_type_part_name, new VString(*new String(type)));
+
+	// $.source
+	if(problem_source)
+		hash.put(exception_source_part_name, new VString(*new String(*problem_source, String::L_TAINTED)));
+
+	// $.file $.lineno $.colno
+	if(origin.file_no){
+		hash.put("file", new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));
+		hash.put("lineno", new VInt(1+origin.line));
+		hash.put("colno", new VInt(1+origin.col));
+	}
+
+	// $.comment
+	if(const char* comment=e.comment(true))
+		hash.put(exception_comment_part_name, new VString(*new String(comment, String::L_TAINTED)));
+
+	// $.handled(0)
+	hash.put(exception_handled_part_name, &VBool::get(false));
+
+	return Request::Exception_details(origin, problem_source, vhash);
+}
+
+Temp_value_element::Temp_value_element(Request& arequest, Value& awhere, const String& aname, Value* awhat) :
+	frequest(arequest),
+	fwhere(awhere),
+	fname(aname),
+	saved(awhere.get_element(aname))
+{
+	Junction* junction;
+	if(saved && (junction=saved->get_junction()) && junction->is_getter)
+		saved=0;
+	frequest.put_element(fwhere, aname, awhat);
+}
+
+Temp_value_element::~Temp_value_element() {
+	frequest.put_element(fwhere, fname, saved ? saved : VVoid::get());
 }