--- parser3/src/classes/mail.C	2001/08/24 06:26:13	1.35
+++ parser3/src/classes/mail.C	2002/08/13 15:55:41	1.78
@@ -1,24 +1,25 @@
 /** @file
 	Parser: @b mail parser class.
 
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
-
-	$Id: mail.C,v 1.35 2001/08/24 06:26:13 parser Exp $
+	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
-static const char *RCSId="$Id: mail.C,v 1.35 2001/08/24 06:26:13 parser Exp $"; 
 
-#include "pa_config_includes.h"
+static const char* IDENT_MAIL_C="$Date: 2002/08/13 15:55:41 $";
 
-#ifdef _MSC_VER
-#	include "smtp/smtp.h"
-#endif
+#include "pa_config_includes.h"
 
 #include "pa_common.h"
 #include "pa_request.h"
 #include "pa_vfile.h"
 #include "pa_exec.h"
+#include "pa_charsets.h"
+#include "pa_charset.h"
+#include "pa_uue.h"
+
+#ifdef _MSC_VER
+#	include "smtp/smtp.h"
+#endif
 
 // defines
 
@@ -26,9 +27,13 @@ static const char *RCSId="$Id: mail.C,v
 
 #define MAIL_NAME "MAIL"
 
+// consts
+
+const int ATTACHMENT_WEIGHT=100;
+
 // global variable
 
-Methoded *mail_class;
+Methoded *mail_base_class;
 
 // class
 
@@ -36,90 +41,12 @@ class MMail : public Methoded {
 public:
 	MMail(Pool& pool);
 public: // Methoded
-	bool used_directly() { return true; }
+	bool used_directly() { return false; }
 	void configure_user(Request& r);
 private:
 	String mail_name;
-	String content_disposition_name;
-	String content_disposition_filename_name;
 };
 
-// helpers
-
-// uuencode
-
-static unsigned char uue_table[64] = {
-  '`', '!', '"', '#', '$', '%', '&', '\'',
-  '(', ')', '*', '+', ',', '-', '.', '/',
-  '0', '1', '2', '3', '4', '5', '6', '7',
-  '8', '9', ':', ';', '<', '=', '>', '?',
-  '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-  'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-  'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
-  'X', 'Y', 'Z', '[', '\\',']', '^', '_'
-};
-static void uuencode(String& result, const char *file_name_cstr, const VFile& vfile) {
-	//header
-	result << "content-transfer-encoding: x-uuencode\n" << "\n";
-	result << "begin 644 " << file_name_cstr << "\n";
-
-	//body
-	const unsigned char *in=(const unsigned char *)vfile.value_ptr();
-	size_t in_length=vfile.value_size();
-
-	int count=45;
-	for(const unsigned char *itemp=in; itemp<(in+in_length); itemp+=count) {
-		int index;	
-
-		if((itemp+count)>(in+in_length)) 
-			count=in_length-(itemp-in);
-
-		char *buf=(char *)result.pool().malloc(MAX_STRING);
-		char *optr=buf;
-		
-		/*
-		* for UU and XX, encode the number of bytes as first character
-		*/
-		*optr++ = uue_table[count];
-		
-		for (index=0; index<=count-3; index+=3) {
-			*optr++ = uue_table[itemp[index] >> 2];
-			*optr++ = uue_table[((itemp[index  ] & 0x03) << 4) | (itemp[index+1] >> 4)];
-			*optr++ = uue_table[((itemp[index+1] & 0x0f) << 2) | (itemp[index+2] >> 6)];
-			*optr++ = uue_table[  itemp[index+2] & 0x3f];
-		}
-		
-		/*
-		* Special handlitempg for itempcomplete litempes
-		*/
-		if (index != count) {
-			if (count - index == 2) {
-				*optr++ = uue_table[itemp[index] >> 2];
-				*optr++ = uue_table[((itemp[index  ] & 0x03) << 4) | 
-					( itemp[index+1] >> 4)];
-				*optr++ = uue_table[((itemp[index+1] & 0x0f) << 2)];
-				*optr++ = uue_table[0];
-			}
-			else if (count - index == 1) {
-				*optr++ = uue_table[ itemp[index] >> 2];
-				*optr++ = uue_table[(itemp[index] & 0x03) << 4];
-				*optr++ = uue_table[0];
-				*optr++ = uue_table[0];
-			}
-		}
-		/*
-		* end of line
-		*/
-		*optr++ = '\n';	
-		*optr = 0;
-		result << buf;
-	}
-	
-	//footer
-	result.APPEND_AS_IS((const char *)uue_table, 1/* one char */, 0, 0) << "\n"
-		"end\n";
-}
-
 /** ^mail:send[$attach[$type[uue|mime64] $value[DATA]]] 
 	@todo solve - bad with html attaches
 */
@@ -127,17 +54,13 @@ static const String& attach_hash_to_stri
 										   Hash& attach_hash) {
 	Pool& pool=r.pool();
 
-	Value *vtype=static_cast<Value *>(attach_hash.get(*new(pool) String(pool, "type")));
-	if(!vtype)
-		PTHROW(0, 0,
-			&origin_string,
-			"has no $type");
+	Value *vformat=static_cast<Value *>(attach_hash.get(*new(pool) String(pool, "format")));
 
 	const VFile *vfile;
 	if(Value *value=static_cast<Value *>(attach_hash.get(*value_name)))
 		vfile=value->as_vfile(String::UL_AS_IS); // bad with html attaches. todo: solve
 	else
-		PTHROW(0, 0,
+		throw Exception("parser.runtime",
 			&origin_string,
 			"has no $value");
 
@@ -147,135 +70,137 @@ static const String& attach_hash_to_stri
 		file_name=&vfile_name->as_string();
 	else // no $file-name, VFile surely knows name
 		file_name=&static_cast<Value *>(vfile->fields().get(*name_name))->as_string();
-	const char *file_name_cstr=file_name->cstr(String::UL_FILE_NAME);
+	const char *file_name_cstr=file_name->cstr();
 
 	String& result=*new(pool) String(pool);
 
 	// content-type: application/octet-stream
-	result << "content-type: " << r.mime_type_of(file_name_cstr) << "\n";
+	result << "content-type: " << r.mime_type_of(file_name_cstr) 
+		<< "; name=\"" << file_name_cstr << "\"\n";
 	// content-disposition: attachment; filename="user_file_name"
 	result << "content-disposition: attachment; filename=\"" << file_name_cstr << "\"\n";
 
-	const String& type=vtype->as_string();
-	if(type=="uue") {
-		uuencode(result, file_name_cstr, *vfile);
-	} else 
-		PTHROW(0, 0,
-			&type,
-			"unknown encode type");
+	const String *type=vformat?&vformat->as_string():0;
+	if(!type/*default = uue*/ || *type=="uue") {
+		pa_uuencode(result, file_name_cstr, *vfile);
+	} else // for now
+		throw Exception("parser.runtime",
+			type,
+			"unknown attachment encode format");
 	
 	return result;
 }
 
 
-static void *find_content_type(const Hash::Key& aattribute, Hash::Val *ameaning, 
-							  void *) {
-	return StrEqNc(aattribute.cstr(), CONTENT_TYPE_NAME)?ameaning:0;
-}
-static void *find_content_type_charset(const Hash::Key& aattribute, Hash::Val *ameaning, 
-									  void *) {
-	return StrEqNc(aattribute.cstr(), "charset")?ameaning:0;
-}
-
-/// used by mail: _send / letter_hash_to_string / add_header_attribute
+#ifndef DOXYGEN
 struct Mail_info {
-	String *attribute_to_exclude;
-	const char *charset;
+	Charset *charset; const char *content_charset_name;
 	String *header;
 	const String **from, **to;
+	const String *errors_to;
 };
-static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning, 
-								 void *info) {
+#endif
 
-	Value& lmeaning=*static_cast<Value *>(ameaning);
+const String& extractEmail(const String& string);
+static void add_header_attribute(const Hash::Key& raw_element_name, Hash::Val *aelement_value, 
+								 void *info) {
+	Value& element_value=*static_cast<Value *>(aelement_value);
+	const String& low_element_name=raw_element_name.change_case(raw_element_name.pool(), String::CC_LOWER);
 	Mail_info& mi=*static_cast<Mail_info *>(info);
 
 	// exclude one attribute [body]
-	if(aattribute==*mi.attribute_to_exclude)
+	if(low_element_name==BODY_NAME
+		|| low_element_name==CHARSET_NAME)
 		return;
 
 	// fetch from & to from header for SMTP
-	if(mi.from && aattribute=="from")
-		*mi.from=&lmeaning.as_string();
-	if(mi.to && aattribute=="to")
-		*mi.to=&lmeaning.as_string();
+	if(mi.from && low_element_name=="from")
+		*mi.from=&extractEmail(element_value.as_string());
+	if(mi.to && low_element_name=="to")
+		*mi.to=&extractEmail(element_value.as_string());
+	if(low_element_name=="errors-to")
+		mi.errors_to=&extractEmail(element_value.as_string());
 
 	// append header line
 	*mi.header << 
-		aattribute << ":" << 
-		attributed_meaning_to_string(lmeaning, String::UL_MAIL_HEADER).
-			cstr(String::UL_UNSPECIFIED, 0, mi.charset) << 
+		low_element_name << ":" << 
+		attributed_meaning_to_string(element_value, String::UL_MAIL_HEADER).
+			cstr(String::UL_UNSPECIFIED, 0, mi.charset, mi.content_charset_name) << 
 		"\n";
 }
 
-/// used in mail: _send / letter_hash_to_string / add_part
+#ifndef DOXYGEN
 struct Mail_seq_item {
-	const String *part_name;
-	Value *part_value;
+	int weight;
+	const String *name;
+	Value *value;
 };
+#endif
+static int get_part_name_weight(const Hash::Key& part_name) {
+	const char *cstr=part_name.cstr();
+	int offset=0;
+	if(strncmp(cstr, "text", 4)==0) {
+		cstr+=4;
+	} else if(strncmp(cstr, "attach", 6)==0) {
+		cstr+=6;
+		offset=ATTACHMENT_WEIGHT;
+	} else
+		throw Exception("parser.runtime",
+			&part_name,
+			"is neither text# nor attach#");
+
+	char *error_pos;
+	return strtol(cstr, &error_pos, 10)+offset;
+}
 static void add_part(const Hash::Key& part_name, Hash::Val *part_value, 
 					 void *info) {
 	Mail_seq_item **seq_ref=static_cast<Mail_seq_item **>(info);
-	(**seq_ref).part_name=&part_name;
-	(**seq_ref).part_value=static_cast<Value *>(part_value);
+	(**seq_ref).weight=get_part_name_weight(part_name);
+	(**seq_ref).name=&part_name;
+	(**seq_ref).value=static_cast<Value *>(part_value);
 	(*seq_ref)++;
 }
-static double key_of_part(const void *item) {
-	const char *cstr=static_cast<const Mail_seq_item *>(item)->part_name->cstr();
-	char *error_pos;
-	return strtod(cstr, &error_pos);
+static int key_of_part(const void *item) {
+	return static_cast<const Mail_seq_item *>(item)->weight;
 }
 static int sort_cmp_string_double_value(const void *a, const void *b) {
-	double va=key_of_part(a);
-	double vb=key_of_part(b);
-
-	// 0 logically equals infinity. so that attachments would go last
-	if(va==0)
-		return +1;
-	if(vb==0)
-		return -1;
-
-	if(va<vb)
-		return -1;
-	else if(va>vb)
-		return +1;
-	else 
-		return 0;
+	return key_of_part(a)-key_of_part(b);
 }
-static const String& letter_hash_to_string(Request& r, const String& method_name, 
-										   Hash& letter_hash, int level,
+static const String& message_hash_to_string(Request& r, const String& method_name, 
+										   Hash& message_hash, int level,
 										   const String **from, const String **to) {
 	Pool& pool=r.pool();
 
 	// prepare header: 'hash' without "body"
 	String& result=*new(pool) String(pool);
 
-	const char *charset=0;
-	if(Value *content_type=
-		static_cast<Value *>(letter_hash.first_that(find_content_type)))
-		if(Hash *hash=content_type->get_hash())
-			if(Value *content_type_charset=
-				static_cast<Value *>(hash->first_that(find_content_type_charset)))
-				charset=content_type_charset->as_string().cstr();
+	Charset *charset;
+	if(Value *vrecodecharset_name=static_cast<Value *>(message_hash.get(*charset_name)))
+		charset=&charsets->get_charset(vrecodecharset_name->as_string());
+	else
+		charset=&pool.get_source_charset();
 
-	*from=*to=0;
+	const char *content_charset_name=0;
+	if(Value *vcontent_type=static_cast<Value *>(message_hash.get(*content_type_name)))
+		if(Hash *hcontent_type=vcontent_type->get_hash(0))
+			if(Value *vcontentcharset_name=static_cast<Value *>(hcontent_type->get(*charset_name)))
+				content_charset_name=vcontentcharset_name->as_string().cstr();
+
+	if(from)
+		*from=0;
+	if(to)
+		*to=0;
 	Mail_info mail_info={
-		/*excluding*/ body_name,
-		charset,
+		charset, content_charset_name,
 		&result,
 		from, to
 	};
-	letter_hash.for_each(add_header_attribute, &mail_info);
-
-	if(Value *body_element=static_cast<Value *>(letter_hash.get(*body_name))) {
-		if(Hash *body_hash=body_element->get_hash()) {
-			char *boundary=(char *)pool.malloc(MAX_NUMBER);
-			snprintf(boundary, MAX_NUMBER-5/*lEvEl*/, "lEvEl%d", level);
-			// multi-part
-			result << "content-type: multipart/mixed; boundary=\"" << boundary << "\"\n";
-			result << "\n" 
-				"This is a multi-part message in MIME format.";
+	message_hash.for_each(add_header_attribute, &mail_info);
+	if(!mail_info.errors_to)
+		result << "errors-to: postmaster\n"; // errors-to: default
 
+	if(Value *body_element=static_cast<Value *>(message_hash.get(*body_name))) {
+		if(Hash *body_hash=body_element->get_hash(&method_name)) {
 			// body parts..
 			// ..collect
 			Mail_seq_item *seq=(Mail_seq_item *)pool.malloc(sizeof(Mail_seq_item)*body_hash->size());
@@ -283,32 +208,58 @@ static const String& letter_hash_to_stri
 			// ..sort
 			_qsort(seq, body_hash->size(), sizeof(Mail_seq_item), 
 				sort_cmp_string_double_value);
+
+			bool multipart=body_hash->size()>1;
+			// header
+			char *boundary=0;
+			if(multipart) {
+				boundary=(char *)pool.malloc(MAX_NUMBER);
+				snprintf(boundary, MAX_NUMBER-5/*lEvEl*/, "lEvEl%d", level);
+				// multi-part
+				result << "content-type: multipart/mixed; boundary=\"" << boundary << "\"\n";
+				result << "\n" 
+					"This is a multi-part message in MIME format.";
+			}
+
 			// ..insert in 'seq' order
 			for(int i=0; i<body_hash->size(); i++) {
-				// intermediate boundary
-				result << "\n--" << boundary << "\n";
+				if(multipart) {
+					// intermediate boundary
+					result << "\n--" << boundary << "\n";
+				}
 
-				if(Hash *part_hash=seq[i].part_value->get_hash())
-					if(seq[i].part_name->mid(0, 6/*attach*/)=="attach")
-						result << attach_hash_to_string(r, *seq[i].part_name, *part_hash);
+				if(Hash *part_hash=seq[i].value->get_hash(&method_name))
+					if(seq[i].weight>=ATTACHMENT_WEIGHT)
+						result << attach_hash_to_string(r, *seq[i].name, *part_hash);
 					else 
-						result << letter_hash_to_string(r, method_name, *part_hash, 
+						result << message_hash_to_string(r, method_name, *part_hash, 
 							level+1, 0, 0);
 				else
-					PTHROW(0, 0,
-						seq[i].part_name,
+					throw Exception("parser.runtime",
+						seq[i].name,
 						"part is not hash");
 			}
 
 			// finish boundary
-			result << "\n--" << boundary << "--\n";
+			if(multipart) {
+				result << "\n--" << boundary << "--\n";
+			}
 		} else {
 			result << 
-				"\n" << // header|body separator
-				body_element->as_string();  // body
+				"\n"; // header|body separator
+
+			const String& body=body_element->as_string();
+			const char *body_ptr=body.cstr(String::UL_UNSPECIFIED);  // body
+			size_t body_size=strlen(body_ptr);  // body
+			const void *mail_ptr;
+			size_t mail_size;
+			Charset::transcode(pool, 
+				pool.get_source_charset(), body_ptr, body_size,
+				*charset/*always set - either mail.charset or $request:charset*/, mail_ptr, mail_size);
+			result.APPEND_CLEAN((const char*)mail_ptr, mail_size, 0, 0);
 		}
 	} else 
-		PTHROW(0, 0,
+		throw Exception("parser.runtime",
 			&method_name,
 			"has no $body");
 
@@ -316,22 +267,23 @@ static const String& letter_hash_to_stri
 }
 
 static void sendmail(Request& r, const String& method_name, 
-					 const String& letter, 
+					 const String& message, 
 					 const String *from, const String *to) {
 	Pool& pool=r.pool();
 
-	char *letter_cstr=letter.cstr();
-	Hash *mail_conf=static_cast<Hash *>(r.classes_conf.get(mail_class->name()));
+	char *message_cstr=message.cstr(String::UL_UNSPECIFIED);
+	Hash *mail_conf=static_cast<Hash *>(r.classes_conf.get(mail_base_class->name()));
 
-#ifdef _MSC_VER
+	const char *exception_type="email.format";
 	if(!from)
-		PTHROW(0, 0,
+		throw Exception(exception_type,
 			&method_name,
-			"has no 'from' header specified");
+			"parameter does not specify 'from' header field");
 	if(!to)
-		PTHROW(0, 0,
+		throw Exception(exception_type,
 			&method_name,
-			"has no 'to' header specified");
+			"parameter does not specify 'to' header field");
+#ifdef _MSC_VER
 
 	SMTP& smtp=*new(pool) SMTP(pool, method_name);
 	Value *server_port;
@@ -344,73 +296,91 @@ static void sendmail(Request& r, const S
 		if(!port)
 			port="25";
 
-		smtp.Send(server, port, letter_cstr, from->cstr(), to->cstr());
+		smtp.Send(server, port, message_cstr, from->cstr(), to->cstr());
 	} else
-		PTHROW(0, 0,
+		throw Exception("parser.runtime",
 			&method_name,
 			"$"MAIN_CLASS_NAME":"MAIL_NAME".SMTP not defined");
 #else
 	// unix
-	// $MAIN:MAIL.prog1["/usr/sbin/sendmail -t"] default
-	// $MAIN:MAIL.prog2["/usr/lib/sendmail -t"] default
+	// $MAIN:MAIL.sendmail["/usr/sbin/sendmail -t -i -f postmaster"] default
+	// $MAIN:MAIL.sendmail["/usr/lib/sendmail -t -i  -f postmaster"] default
+
+	const String *sendmail_command;
+#ifdef PA_FORCED_SENDMAIL
+	sendmail_command=new(pool) String(pool, PA_FORCED_SENDMAIL);
+#else
+	const char *sendmailkey_cstr="sendmail";
 	if(mail_conf) {
-		char no_cstr[MAX_NUMBER];
-		for(int no=-2; ; no++) {
-			const String *prog_string;
-			switch(no) {
-			case -2: prog_string=new(pool) String(pool, "/usr/sbin/sendmail -t"); break;
-			case -1: prog_string=new(pool) String(pool, "/usr/lib/sendmail -t"); break;
-			default: 
-				{
-					String prog_key(pool, "prog");
-					snprintf(no_cstr, MAX_NUMBER, "%d", no);
-					prog_key << no_cstr;
-					if(Value *prog_value=static_cast<Value *>(mail_conf->get(prog_key)))
-						prog_string=&prog_value->as_string();
-					else
-						if(no==0)
-							continue;
-						else
-							PTHROW(0, 0,
-								&method_name,
-								"$"MAIN_CLASS_NAME":"MAIL_NAME".%s not defined", 
-								prog_key.cstr());
-				}
-			}
-			// we know prog_string here
-			Array argv(pool);
-			const String *file_spec;
-			int after_file_spec=prog_string->pos(" ", 1);
-			if(after_file_spec<=0)
-				file_spec=prog_string;
-			else {
-				size_t pos_after=after_file_spec;
-				file_spec=&prog_string->mid(0, pos_after);
-				prog_string->split(argv, &pos_after, " ", 1, String::UL_CLEAN);
-			}
+		if(Value *sendmail_value=static_cast<Value *>(mail_conf->get(String(pool, sendmailkey_cstr))))
+			sendmail_command=&sendmail_value->as_string();
+		else
+			throw Exception("parser.runtime",
+				&method_name,
+				"$"MAIN_CLASS_NAME":"MAIL_NAME".%s not defined", 
+				sendmailkey_cstr);
+	} else {
+		String *test=new(pool) String(pool, "/usr/sbin/sendmail");
+		if(!file_executable(*test))
+			test=new(pool) String(pool, "/usr/lib/sendmail");
+		test->APPEND_CONST(" -t -i -f postmaster");
+		sendmail_command=test;
+	}
+#endif
 
-			// skip unavailable default programs
-			if(no<0 && !file_executable(*file_spec))
-				continue;
-
-			String in(pool, letter_cstr); String out(pool); String err(pool);
-			int exit_status=pa_exec(*file_spec,
-				0/*default env*/,
-				&argv,
-				in, out, err);
-			if(exit_status || err.size())
-				PTHROW(0, 0,
-					&method_name,
-					"'%s' reported problem: %s (%d)",
-						file_spec->cstr(),
-						err.size()?err.cstr():"UNKNOWN", 
-						exit_status);
-			break;
-		}
-	} else
-		PTHROW(0, 0,
+	// we know sendmail_command here, should replace "postmaster" with "$from" from message
+	int at_postmaster=sendmail_command->pos("postmaster");
+	if(at_postmaster>0) {
+		String& reconstructed=sendmail_command->mid(0, at_postmaster);
+		reconstructed << *from;
+		reconstructed << sendmail_command->mid(at_postmaster+10/*postmaster*/, sendmail_command->size());
+		sendmail_command=&reconstructed;
+	}
+
+	// execute it
+	Array argv(pool);
+	const String *file_spec;
+	int after_file_spec=sendmail_command->pos(" ", 1);
+	if(after_file_spec<=0)
+		file_spec=sendmail_command;
+	else {
+		size_t pos_after=after_file_spec;
+		file_spec=&sendmail_command->mid(0, pos_after++);
+		sendmail_command->split(argv, &pos_after, " ", 1, String::UL_AS_IS);
+	}
+
+	if(!file_executable(*file_spec))
+		throw Exception("email.send",
+			file_spec, 
+			"is not executable."
+#ifdef PA_FORCED_SENDMAIL
+			" Use configure key \"--with-sendmail=appropriate sendmail command\""
+#else
+			" Set $"MAIN_CLASS_NAME":"MAIL_NAME".%s to appropriate sendmail command", 
+				sendmailkey_cstr
+#endif
+		);
+
+
+	String in(pool, message_cstr); String out(pool); String err(pool);
+	int exit_status=pa_exec(
+		// forced_allow
+#ifdef PA_FORCED_SENDMAIL
+		true
+#else
+		false
+#endif
+		, *file_spec,
+		0/*default env*/,
+		&argv,
+		in, out, err);
+	if(exit_status || err.size())
+		throw Exception("email.send",
 			&method_name,
-			"$" MAIN_CLASS_NAME ":" MAIL_NAME " not defined");
+			"'%s' reported problem: %s (%d)",
+				file_spec->cstr(),
+				err.size()?err.cstr():"UNKNOWN", 
+				exit_status);
 #endif
 }
 
@@ -421,28 +391,26 @@ static void _send(Request& r, const Stri
 	Pool& pool=r.pool();
 
 	Value& vhash=params->as_no_junction(0, "message must not be code");
-	Hash *hash=vhash.get_hash();
+	Hash *hash=vhash.get_hash(&method_name);
 	if(!hash)
-		PTHROW(0, 0,
+		throw Exception("parser.runtime",
 			&method_name,
 			"message must be hash");
 
 	const String *from, *to;
-	const String& letter=letter_hash_to_string(r, method_name, *hash, 0, &from, &to);
+	const String& message=hash->get(*body_name)/*old format*/?
+		message_hash_to_string(r, method_name, *hash, 0, &from, &to) : // old
+		static_cast<VMail *>(r.self)->message_hash_to_string(r, &method_name, hash, 0, &from, &to); // new
 
-//	r.write_assign_lang(*new(pool) VString(letter));
-	sendmail(r, method_name, letter, from, to);
+	//r.write_pass_lang(message);
+	sendmail(r, method_name, message, from, to);
 }
 
 // constructor & configurator
 
-MMail::MMail(Pool& apool) : Methoded(apool),
-	mail_name(apool, MAIL_NAME),
-	content_disposition_name(apool, CONTENT_DISPOSITION_NAME),
-	content_disposition_filename_name(apool, CONTENT_DISPOSITION_FILENAME_NAME)
+MMail::MMail(Pool& apool) : Methoded(apool, MAIL_CLASS_NAME),
+	mail_name(apool, MAIL_NAME)
 {
-	set_name(*NEW String(pool(), MAIL_CLASS_NAME));
-
 	// ^mail:send{hash}
 	add_native_method("send", Method::CT_STATIC, _send, 1, 1);
 }
@@ -451,17 +419,18 @@ void MMail::configure_user(Request& r) {
 	Pool& pool=r.pool();
 
 	// $MAIN:MAIL[$SMTP[mail.design.ru]]
-	if(Value *mail_element=r.main_class->get_element(mail_name))
-		if(Hash *mail_conf=mail_element->get_hash())
+	if(Value *mail_element=r.main_class->get_element(mail_name, r.main_class, false))
+		if(Hash *mail_conf=mail_element->get_hash(0))
 			r.classes_conf.put(name(), mail_conf);
 		else
-			PTHROW(0, 0,
-				0,
-				"$" MAIL_CLASS_NAME ":" MAIL_NAME " is not hash");
+			if( !mail_element->is_string() )
+				throw Exception("parser.runtime",
+					0,
+					"$" MAIL_CLASS_NAME ":" MAIL_NAME " is not hash");
 }
 
 // creator
 
 Methoded *MMail_create(Pool& pool) {
-	return mail_class=new(pool) MMail(pool);
+	return mail_base_class=new(pool) MMail(pool);
 }