--- parser3/src/main/untaint.C	2003/03/20 09:41:47	1.115.2.12.2.4
+++ parser3/src/main/untaint.C	2004/01/22 08:28:20	1.122.2.2
@@ -5,7 +5,7 @@
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char* IDENT_UNTAINT_C="$Date: 2003/03/20 09:41:47 $";
+static const char* IDENT_UNTAINT_C="$Date: 2004/01/22 08:28:20 $";
 
 
 #include "pa_string.h"
@@ -17,31 +17,63 @@ static const char* IDENT_UNTAINT_C="$Dat
 #include "pa_common.h"
 #include "pa_charset.h"
 #include "pa_request_charsets.h"
+#include "pa_sapi.h"
 
+extern "C" { // author forgot to do that
 #include "ec.h"
+}
 
-//#define PA_SQL
+#define PA_SQL
 
 #ifdef PA_SQL
 #include "pa_sql_connection.h"
 #endif
 
+// defines
+
+
+#undef CORD_ec_append
+// redefining to intercept flushes and implement whitespace optimization
+// of all consequent white space chars leaving only first one
+#define CORD_ec_append(x, c) \
+    {  \
+	bool skip=false; \
+	if(optimize) switch(c) { \
+	case ' ': case '\r': case '\n': case '\t': \
+		if(whitespace) \
+			skip=true; /*skipping subsequent*/ \
+		else \
+			whitespace=true; \
+		break; \
+	default: \
+		whitespace=false; \
+		break; \
+	} \
+	if(!skip) { \
+		if ((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ) { \
+	  		CORD_ec_flush_buf(x); \
+		} \
+		*((x)[0].ec_bufptr)++ = (c); \
+	} \
+    }
+
+
 #define escape(action) \
-	for(; fragment_size--; CORD_next(pos)) { \
-		char c=CORD_pos_fetch(pos); \
+	for(; fragment_length--; CORD_next(info->pos)) { \
+		char c=CORD_pos_fetch(info->pos); \
 		action \
 	}
-#define _default  default: CORD_ec_append(result, c); break
-#define encode(need_encode_func, prefix)  \
+#define _default  default: CORD_ec_append(info->result, c); break
+#define encode(need_encode_func, prefix, otherwise)  \
 	if(need_encode_func(c)) { \
 		static const char* hex="0123456789ABCDEF"; \
-		CORD_ec_append(result, prefix); \
-		CORD_ec_append(result, hex[((unsigned char)c)/0x10]); \
-		CORD_ec_append(result, hex[((unsigned char)c)%0x10]); \
+		CORD_ec_append(info->result, prefix); \
+		CORD_ec_append(info->result, hex[((unsigned char)c)/0x10]); \
+		CORD_ec_append(info->result, hex[((unsigned char)c)%0x10]); \
 	} else \
-		CORD_ec_append(result, c);
-#define to_char(c)  CORD_ec_append(result, c)
-#define to_string(s)  CORD_ec_append_cord(result, s)
+		CORD_ec_append(info->result, otherwise);
+#define to_char(c)  { CORD_ec_append(info->result, c); whitespace=false; }
+#define to_string(s)  { CORD_ec_append_cord(info->result, s); whitespace=false; }
 
 inline bool need_file_encode(unsigned char c){
 	// russian letters and space ENABLED
@@ -49,7 +81,7 @@ inline bool need_file_encode(unsigned ch
 	return strchr(
 			  "*?'\"<>|"
 #ifndef WIN32
-			  ":\\~"
+			  ":\\"
 #endif
 			  , c)!=0;
 }
@@ -135,6 +167,42 @@ inline bool need_quote_http_header(const
 	return false;
 }
 
+#ifndef DOXYGEN
+struct Append_fragment_info {
+	String::Language lang;
+	String::Languages* dest_languages;
+	size_t dest_body_plan_length;
+};
+#endif
+int append_fragment_optimizing(char alang, size_t asize, Append_fragment_info* info) {
+	const String::Language lang=(String::Language)(unsigned char)alang;
+	// main idea here:
+	// tainted piece would get OPTIMIZED bit from 'lang'
+	// clean piece would be marked OPTIMIZED manually
+	// pieces with determined languages [not tainted|clean] would retain theirs langs
+	info->dest_languages->append(info->dest_body_plan_length, 
+		lang==String::L_TAINTED?
+			info->lang
+			:lang==String::L_CLEAN?
+				(String::Language)(String::L_CLEAN|String::L_OPTIMIZE_BIT) // ORing with OPTIMIZED flag
+				:lang,
+		asize);
+	info->dest_body_plan_length+=asize;
+
+	return 0; // 0=continue
+}
+int append_fragment_nonoptimizing(char alang, size_t asize, Append_fragment_info* info) {
+	const String::Language lang=(String::Language)(unsigned char)alang;
+	// The core idea: tainted pieces got marked with context's lang
+	info->dest_languages->append(info->dest_body_plan_length, 
+		lang==String::L_TAINTED?
+			info->lang
+			:lang,
+		asize);
+	info->dest_body_plan_length+=asize;
+
+	return 0; // 0=continue
+}
 
 /** 
 	appends to other String,
@@ -142,43 +210,27 @@ inline bool need_quote_http_header(const
 	or marking ALL pieces of it with a @a lang when @a forced to,
 	and propagating OPTIMIZE language bit.
 */
-String& String::append_to(String& dest, Untaint_lang lang, bool forced) const {
-	if(!*this)
+String& String::append_to(String& dest, Language lang, bool forced) const {
+	if(is_empty())
 		return dest;
 
-	// first: letters
-	dest.body=CORD_cat(dest.body, body);
-
-	// next: fragment infos
+	// first: fragment infos
 	
-	if(lang==UL_PASS_APPENDED) // without language-chage string?
-		dest.fragments.append(fragments, 0, fragments.count());
+	if(lang==L_PASS_APPENDED) // without language-change?
+		dest.langs.append(dest.body, body.length(), langs);
 	else if(forced) //forcing passed lang?
-		dest.fragments+=Fragment(lang, size());
-	else if(lang&UL_OPTIMIZE_BIT) {
-		Array_iterator<ArrayFragment::element_type> i(fragments);
-		while(i.has_next()) {
-			const Fragment& fragment=i.next();
-			// main idea here:
-			// tainted piece would get OPTIMIZED bit from 'lang'
-			// clean piece would be marked OPTIMIZED manually
-			// pieces with determined languages [not tainted|clean] would retain theirs langs
-			dest.fragments+=Fragment(static_cast<Untaint_lang>(
-				fragment.lang==UL_TAINTED?lang:(
-					fragment.lang==UL_CLEAN?UL_CLEAN|UL_OPTIMIZE_BIT: // ORing with OPTIMIZED flag
-						fragment.lang)),
-				fragment.size);
-		}
-	} else { // The core idea: tainted pieces got marked with context's lang
-		Array_iterator<ArrayFragment::element_type> i(fragments);
-		while(i.has_next()) {
-			const Fragment& fragment=i.next();
-			dest.fragments+=Fragment(
-				fragment.lang==UL_TAINTED?lang:fragment.lang,
-				fragment.size);
-		}
+		dest.langs.append(dest.body, lang, length());
+	else { 
+		Append_fragment_info info={lang, &dest.langs, dest.body.length()};
+	    langs.for_each(body, lang&L_OPTIMIZE_BIT?
+			append_fragment_optimizing
+			:append_fragment_nonoptimizing, &info);
 	}
 
+	// next: letters
+	dest.body<<body;
+
+	ASSERT_STRING_INVARIANT(dest);
 	return dest;
 }
 
@@ -215,211 +267,252 @@ inline bool mail_header_char_valid_withi
 		|| c>='0' && c<='9'
 		|| strchr("!*+-/", c);
 }
-inline void ec_append(CORD_ec result, CORD_pos& pos, size_t size) {
+inline bool addr_spec_soon(const char *src) {
+	for(char c; c=*src; src++)
+		if(c=='<')
+			return true;
+		else if(!(c==' ' || c=='\t'))
+			return false;
+	return false;
+}
+/**
+	RFC 
+	Upper case should be used for hexadecimal digits "A" through "F"
+	The 8-bit hexadecimal value 20 (e.g., ISO-8859-1 SPACE) 
+	may be represented as "_" 
+*/
+inline bool mail_header_nonspace_char(char c) {
+	return c != 0x20;
+}
+inline void ec_append(CORD_ec& result, bool& optimize, bool& whitespace, CORD_pos pos, size_t size) {
 	while(size--) {
 		CORD_ec_append(result, CORD_pos_fetch(pos));
 		CORD_next(pos);
 	}
 }
-CORD String::cstr_to_cord(Untaint_lang lang, 
-		  SQL_Connection *connection,
-		  const Request_charsets *charsets) const {
-	CORD_ec result; CORD_ec_init(result);
-	CORD_pos pos; CORD_set_pos(pos, body, 0);
-
-	bool whitespace=true;
+inline void pa_CORD_pos_advance(CORD_pos pos, size_t n) {
+	while(true) {
+		size_t avail=CORD_pos_chars_left(pos);
+		if(avail==0) {
+			CORD_next(pos);
+			if(!--n)
+				break;
+		} else if(avail<n) {
+			CORD_pos_advance(pos, avail);
+			n-=avail;
+		} else { // avail>=n
+			CORD_pos_advance(pos, n);
+			break;
+		}
+	}
+}
 
-	size_t fragment_start=0;
-	size_t fragment_end;
-	for(Array_iterator<Fragment> i(fragments); i.has_next(); fragment_start=fragment_end) {
-		const Fragment& fragment=i.next();
-		size_t fragment_size=fragment.size;
-		fragment_end=fragment_start+fragment_size;
-
-		Untaint_lang to_lang=lang==UL_UNSPECIFIED?fragment.lang:lang;
-
-		switch(to_lang & ~UL_OPTIMIZE_BIT) {
-		case UL_CLEAN:
-		case UL_TAINTED:
-		case UL_AS_IS:
-			// clean piece
-
-			// tainted piece, but undefined untaint language
-			// for VString.as_double of tainted values
-			// for ^process{body} evaluation
+#ifndef DOXYGEN
+struct Cstr_to_string_body_block_info {
+	// input
+	String::Language lang;
+	SQL_Connection* connection;
+	const Request_charsets* charsets;
+	const String::Body* body;
+
+	// output
+	CORD_ec result;
+
+	// private
+	CORD_pos pos;
+	size_t fragment_begin;
+	bool whitespace;
+};
+#endif
+int cstr_to_string_body_block(char alang, size_t fragment_length, Cstr_to_string_body_block_info* info) {
+	const String::Language fragment_lang=(String::Language)(unsigned char)alang;
+	bool& whitespace=info->whitespace;
+	size_t fragment_end=info->fragment_begin+fragment_length;
+	//fprintf(stderr, "%d, %d\n", fragment.lang, fragment.length);
 
-			// tainted, untaint language: as-is
-			ec_append(result, pos, fragment_size);
-			break;
-		case UL_FILE_SPEC:
-			// tainted, untaint language: file [name]
-			escape(
-				// Macintosh has problems with small Russian letter 'r'
-				if( c=='\xF0' && charsets && charsets->source().name()=="windows-1251" ) {
-					// fixing that letter for most common charset
-					to_char('p');
-				} else // fallback to default
-					encode(need_file_encode, '_'); 
-			);
-			break;
-		case UL_URI:
-			// tainted, untaint language: uri
-			{
-				const char *substr=
-					CORD_to_const_char_star(
-						CORD_substr(body, fragment_start, fragment_size));
-				const void *client_ptr;
-				size_t client_size;
-				if(charsets) 
-					Charset::transcode(
-						charsets->source(), substr, fragment_size,
-						charsets->client(), client_ptr, client_size);
-				else {
-					client_ptr=substr; 
-					client_size=fragment_size;
+	
+	String::Language to_lang=info->lang==String::L_UNSPECIFIED?fragment_lang:info->lang;
+	bool optimize=(to_lang & String::L_OPTIMIZE_BIT)!=0;
+	if(!optimize)
+		whitespace=false;
+		
+	switch(to_lang & ~String::L_OPTIMIZE_BIT) {
+	case String::L_CLEAN:
+	case String::L_TAINTED:
+	case String::L_AS_IS:
+		// clean piece
+
+		// tainted piece, but undefined untaint language
+		// for VString.as_double of tainted values
+		// for ^process{body} evaluation
+
+		// tainted, untaint language: as-is
+		ec_append(info->result, optimize, whitespace, info->pos, fragment_length);
+		break;
+	case String::L_FILE_SPEC:
+		// tainted, untaint language: file [name]
+		escape(
+			// Macintosh has problems with small Russian letter 'r'
+			if( c=='\xF0' && info->charsets && info->charsets->source().NAME()=="WINDOWS-1251" ) {
+				// fixing that letter for most common charset
+				to_char('p');
+			} else // fallback to default
+				encode(need_file_encode, '_', c); 
+		);
+		break;
+	case String::L_URI:
+		// tainted, untaint language: uri
+		{
+			const char *fragment_str=info->body->mid(info->fragment_begin, fragment_length).cstr();
+			// skip source [we use recoded version]
+			pa_CORD_pos_advance(info->pos, fragment_length);
+			String::C output(fragment_str, fragment_length);
+			if(info->charsets) 
+				output=Charset::transcode(output, 
+					info->charsets->source(), 
+					info->charsets->client());
+
+			char c;
+			for(const char* src=output.str; c=*src++; ) 
+				encode(need_uri_encode, '%', c);
+		}
+		break;
+	case String::L_HTTP_HEADER:
+		// tainted, untaint language: http-field-content-text
+		escape(
+			encode(need_uri_encode, '%', c);
+		);
+		break;
+	case String::L_MAIL_HEADER:
+		// tainted, untaint language: mail-header
+		// http://www.ietf.org/rfc/rfc2047.txt
+		if(info->charsets) {
+			size_t mail_size;
+			const char *mail_ptr=
+				info->body->mid(info->fragment_begin, mail_size=fragment_length).cstr();
+			// skip source [we use recoded version]
+			pa_CORD_pos_advance(info->pos, mail_size);
+
+			const char* charset_name=info->charsets->mail().NAME().cstr();
+
+			// Subject: Re: parser3: =?koi8-r?Q?=D3=C5=CD=C9=CE=C1=D2?=
+			bool to_quoted_printable=false;
+
+			bool email=false;
+			uchar c;
+			for(const char* src=mail_ptr; c=(uchar)*src++; ) {
+				//RFC   + An 'encoded-word' MUST NOT appear in any portion of an 'addr-spec'.
+				if(to_quoted_printable && (c==',' || addr_spec_soon(src) || c == '"')) {
+					email=c=='<';
+					to_string("?=");
+					to_quoted_printable=false;
 				}
-
-				char c;
-				for(const char* src=(const char* )client_ptr; c=*src++; ) 
-					encode(need_uri_encode, '%');
-			}
-			break;
-		case UL_HTTP_HEADER:
-			// tainted, untaint language: http-field-content-text
-			escape(
-				encode(need_uri_encode, '%');
-			);
-			break;
-#ifdef LATER
-		case UL_MAIL_HEADER:
-			// tainted, untaint language: mail-header
-			// http://www.ietf.org/rfc/rfc2047.txt
-			if(charsets) {
-				const void *mail_ptr=fragment.ptr;
-				size_t mail_size=fragment_size;
-				const char* charset_name=charsets->mail().name()->cstr();
-
-				// Subject: Re: parser3: =?koi8-r?Q?=D3=C5=CD=C9=CE=C1=D2?=
-				const char* src=(const char* )mail_ptr;
-				bool to_quoted_printable=false;
-
-				bool email=false;
-				for(const char* end=src+mail_size; src<end; src++) {
-					//RFC   + An 'encoded-word' MUST NOT appear in any portion of an 'addr-spec'.
-					if(to_quoted_printable && (c==',' || c=='<')) {
-						email=c=='<';
-						dest+=sprintf(dest, "?=");
-						to_quoted_printable=false;
+				if(!email && (
+					!to_quoted_printable && (c & 0x80)  // starting quote-printable-encoding on first 8bit char
+					|| to_quoted_printable && !mail_header_char_valid_within_Qencoded(c)
+					)) {
+					if(!to_quoted_printable) {
+						to_string("=?");
+						to_string(charset_name);
+						to_string("?Q?");
+						to_quoted_printable=true;
 					}
-					if(!email && (
-						!to_quoted_printable && (c & 0x80)  // starting quote-printable-encoding on first 8bit char
-						|| to_quoted_printable && !mail_header_char_valid_within_Qencoded(c)
-						)) {
-						if(!to_quoted_printable) {
-							dest+=sprintf(dest, "=?%s?Q?", charset_name.get());
-							to_quoted_printable=true;
-						}
-						//RFC Upper case should be used for hexadecimal digits "A" through "F"
-						if(c == 0x20) // RFC The 8-bit hexadecimal value 20 (e.g., ISO-8859-1 SPACE) 
-							*dest++='_'; // RFC may be represented as "_" 
-						else
-							dest+=sprintf(dest, "=%02X", c & 0xFF);
-					} else
-						*dest++=c;
-					if(c=='>')
-						email=false;
-				}
-				if(to_quoted_printable) // close
-					dest+=sprintf(dest, "?=");
-			
-			} else {
-				memcpy(dest, fragment.ptr, fragment_size); 
-				dest+=fragment_size;
+					encode(mail_header_nonspace_char, '=', '_'); 
+				} else
+					to_char(c);
+				if(c=='>')
+					email=false;
 			}
-			break;
-#endif
-		case UL_TABLE: 
-			// tainted, untaint language: table
-			escape(switch(c) {
-				case '\t': to_char(' ');  break;
-				case '\n': to_char(' ');  break;
-				_default;
-			});
-			break;
+			if(to_quoted_printable) // close
+				to_string("?=");
+		
+		} else
+			ec_append(info->result, optimize, whitespace, info->pos, fragment_length);
+		break;
+	case String::L_TABLE: 
+		// tainted, untaint language: table
+		escape(switch(c) {
+			case '\t': to_char(' ');  break;
+			case '\n': to_char(' ');  break;
+			_default;
+		});
+		break;
 #ifdef PA_SQL
-		case UL_SQL:
-			// tainted, untaint language: sql
-			if(connection) {
-				dest+=connection->quote(0, 
-					CORD_substr(body, fragment_start, fragment_size), 
-					fragment_size);
-...^^^
-
-				dest+=connection->quote(dest, fragment.ptr, fragment_size);
-			else
-				throw Exception(0,
-					0,
-					"untaint in SQL language failed - no connection specified");
-			break;
-#endif
-		case UL_JS:
-			escape(switch(c) {
-				case '"': to_string("\\\"");  break;
-				case '\'': to_string("\\'");  break;
-				case '\n': to_string("\\n");  break;
-				case '\\': to_string("\\\\");  break;
-				case '\xFF': to_string("\\\xFF");  break;
-				_default;
-			});
-			break;
-		case UL_XML:
-			escape(switch(c) {
-				case '&': to_string("&amp;");  break;
-				case '>': to_string("&gt;");  break;
-				case '<': to_string("&lt;");  break;
-				case '"': to_string("&quot;");  break;
-				case '\'': to_string("&apos;");  break;
-				_default;
-			});
-			break;
-		case UL_HTML:
-			escape(switch(c) {
-				case '&': to_string("&amp;");  break;
-				case '>': to_string("&gt;");  break;
-				case '<': to_string("&lt;");  break;
-				case '"': to_string("&quot;");  break;
-				_default;
-			});
-			break;
-		default:
-			throw Exception(0, 
-				0, 
-				"unknown untaint language #%d", 
-					static_cast<int>(to_lang)); // should never
-			break; // never
-		}
-#ifdef LATER
-		if(to_lang & UL_OPTIMIZE_BIT) { 
-			// optimizing whitespace
-			char *stop=dest;  dest=start;
-			for(char c=start; src<stop; src++)
-				switch(c) {
-				// of all consequent white space chars leaving only first one
-				case ' ': case '\r': case '\n': case '\t':
-					if(!whitespace) {
-						*dest++=c;
-						whitespace=true;
-					}
-					break;
-				default:
-					whitespace=false;
-					*dest++=c;
-					break;
-				};
-		} else // piece without optimization
-			whitespace=false;
+	case String::L_SQL:
+		// tainted, untaint language: sql
+		if(info->connection) {
+			const char *fragment_str=info->body->mid(info->fragment_begin, fragment_length).cstr();
+			// skip source [we use recoded version]
+			pa_CORD_pos_advance(info->pos, fragment_length);
+
+			to_string(info->connection->quote(fragment_str, fragment_length));
+		} else
+			throw Exception(0,
+				0,
+				"untaint in SQL language failed - no connection specified");
+		break;
 #endif
+	case String::L_JS:
+		escape(switch(c) {
+			case '"': to_string("\\\"");  break;
+			case '\'': to_string("\\'");  break;
+			case '\n': to_string("\\n");  break;
+			case '\\': to_string("\\\\");  break;
+			case '\xFF': to_string("\\\xFF");  break;
+			_default;
+		});
+		break;
+	case String::L_XML:
+		escape(switch(c) {
+			case '&': to_string("&amp;");  break;
+			case '>': to_string("&gt;");  break;
+			case '<': to_string("&lt;");  break;
+			case '"': to_string("&quot;");  break;
+			case '\'': to_string("&apos;");  break;
+			_default;
+		});
+		break;
+	case String::L_HTML:
+		escape(switch(c) {
+			case '&': to_string("&amp;");  break;
+			case '>': to_string("&gt;");  break;
+			case '<': to_string("&lt;");  break;
+			case '"': to_string("&quot;");  break;
+			_default;
+		});
+		break;
+	default:
+		assert(!"should never");
+		SAPI::die("unknown untaint language #%d", 
+			static_cast<int>(to_lang)); // should never
+		break; // never
 	}
 
-	return CORD_ec_to_cord(result);
+	info->fragment_begin=fragment_end;
+
+	return 0; // 0=continue
+}
+
+
+String::Body String::cstr_to_string_body(Language lang, 
+		  SQL_Connection* connection,
+		  const Request_charsets *charsets) const {
+
+	Cstr_to_string_body_block_info info;
+	// input
+	info.lang=lang;
+	info.connection=connection;
+	info.charsets=charsets;
+	info.body=&body;
+	// output
+	CORD_ec_init(info.result);
+	// private
+	body.set_pos(info.pos, 0);
+	info.fragment_begin=0;
+	info.whitespace=true;
+
+	if(!is_empty())
+		langs.for_each(body, cstr_to_string_body_block, &info);
+
+	return String::Body(CORD_ec_to_cord(info.result));
 }