Whole swag of changes. Still lots of cleanup remaining ...

2000-04-23  NotZed  <NotZed@HelixCode.com>

	* camel-data-wrapper.c (set_mime_type_field): Ref the
	content_field when we get it?

	* camel-mime-parser.c (camel_mime_parser_unstep): New function.
	Cause a subsequent call to mime_parser_step() to return the same
	state over again.

	* providers/mbox/camel-mbox-folder.c (_get_message_by_uid):
	Initial test code using the mime parser to construct the message.

	* camel-mime-part.c (construct_from_parser): part constructor.
	(camel_mime_part_construct_content): Basically a simpler
	replacement for the datawrapper repository.
	(camel_mime_part_init): Set the default type to text/plain.

	* camel-simple-data-wrapper.c (construct_from_parser): Initial
	implementation of a content constructor.

	* camel-multipart.c (construct_from_parser): Multipart
	construction routine.
	(camel_multipart_init): Set the default multipart type to
	multipart/mixed.  Duh, no subtype is not allowed anyway.

2000-04-22  NotZed  <NotZed@HelixCode.com>

	* camel-mime-message.h (struct _CamelMimeMessage): Removed
	send_date, and received_date, and replaced it with a time_t
	'date' (this is what the header is called), and date_offset to
	store the GMT offset of the date.

	* camel-mime-message.c (camel_mime_message_set_from): Update raw
	header as we go.
	(_set_from): Removed.
	(_get_from): Removed.
	(camel_mime_message_get_from): Moved implementation here.
	(camel_mime_message_get_subject): Move implementation here.
	(_get_subject): Nuked.
	(camel_mime_message_set_subject): Handle utf-8 input, and also
	update raw header when changed.
	(_set_subject): Removed.
	(_set_received_date): Removed.
	(camel_mime_message_set_received_date): Removed.
	(_get_received_date): Removed.
	(camel_mime_message_get_received_date): Removed.
	(_get_sent_date): Removed.
	(camel_mime_message_get_sent_date): Removed.
	(camel_mime_message_get_date): New function to get the date as a
	time_t/offset.
	(camel_mime_message_set_date): Set the date as a time_t/offset.
	(camel_mime_message_get_date_string): Get the date as a string.
	(camel_mime_message_init): Initialise the current date as
	'CMAEL_MESSAGE_DATE_CURRENT'.
	(_set_reply_to): Removed.
	(camel_mime_message_set_reply_to): Moved implementation here.
	This is still broken, reply-to can have multiple addresses.
	(_get_reply_to): Removed.
	(_set_field): Removed, no longer used anywhere.
	(_get_field): Also removed.
	(_init_header_name_table): Add the Date header.
	(process_header): Also handle snooping of Date header here.

	* camel-stream-filter.c (finalise): Unref the source stream on
	finalise, and also call the parent class (oops).

	* camel-mime-parser.c (camel_mime_parser_state): New function to
	get the current parser state.
	(camel_mime_parser_stream): Allow you to get the stream back from
	the mime_parser.
	(camel_mime_parser_fd): Alternative to allow you to get the fd
	back from the mime_parser.
	(folder_scan_init_with_stream): Properly ref/unref the stream.
	(folder_scan_close): Properly unref the stream/close the fd on
	exit.
	(folder_scan_init_with_fd): Close the old fd if there is one.

	* camel-data-wrapper.c (camel_data_wrapper_construct_from_parser):
	New method, construct a data wrapper from an initialised parser.
	(construct_from_parser): Empty implementation.

	* providers/mbox/camel-mbox-summary.c (message_struct_new):
	Convert subject line to unicode, before storing in the summary.
	(strdup_trim): Removed, no longer needed.

	* providers/mbox/camel-mbox-folder.c (_get_message_by_uid): Ref
	the folder after setting it in the new message.

	* camel-mime-part.c (my_set_content_object): Have the headers
	follow the content-type change here too.
	(my_write_to_stream): Dont write content-type here, automatically
	stored in the headers ...
	(my_write_to_stream): Use header_disposition_format() to format
	the content-disposition header.
	(my_write_to_stream): Removed old code, all headers are now stored
	in the camel-medium level, always.  Need to do the same with
	camel-mime-message i suppose ...
	(my_write_to_stream): Write the content using the parent class,
	not some weird function.
	(camel_mime_part_class_init): Dont override get_output_stream.
	(camel_mime_part_encoding_from_string): Bleh, make it
	case-insensitive.

	* camel-mime-utils.c (header_content_type_is): Handle empty types.
	(header_encode_string): Start of an implementation of the rfc2047
	encoder.  It does iso-8859-1, and us-ascii, and utf-8 (others get
	tricky *sigh*)
	(rfc2047_encode_word): Convert a single word/string into rfc2047
	encoding.
	(quoted_encode): Different quoted-printable encoding for rfc2047
	encoding of headers.

	* gmime-content-field.c (gmime_content_field_write_to_stream): Use
	header_content_type_format() to format it.

svn path=/trunk/; revision=2560

1 files changed, 148 insertions, 2 deletions

diff --git a/camel/camel-simple-data-wrapper.c b/camel/camel-simple-data-wrapper.c
index 7f128116dc..d368a4ddfd 100644
--- a/camel/camel-simple-data-wrapper.c
+++ b/camel/camel-simple-data-wrapper.c
@@ -4,8 +4,8 @@
 
 /*
  *
- * Author :
- *  Bertrand Guiheneuf <bertrand@helixcode.com>
+ * Authors: Bertrand Guiheneuf <bertrand@helixcode.com>
+ *	    Michael Zucchi <notzed@helixcode.com>
  *
  * Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com)
  *
@@ -28,6 +28,17 @@
 
 #include "camel-simple-data-wrapper.h"
 #include "camel-simple-data-wrapper-stream.h"
+#include <camel/camel-stream-mem.h>
+#include "camel-mime-utils.h"
+#include <camel/camel-mime-filter.h>
+#include <camel/camel-mime-filter-basic.h>
+#include <camel/camel-mime-filter-charset.h>
+#include <camel/camel-stream-filter.h>
+#include <camel/camel-seekable-substream.h>
+
+#include <string.h>
+
+#define d(x)
 
 static CamelDataWrapperClass *parent_class = NULL;
 
@@ -40,6 +51,7 @@ static void            write_to_stream           (CamelDataWrapper *data_wrapper
 						     CamelStream *stream);
 static void            finalize                  (GtkObject *object);
 static CamelStream *   get_output_stream         (CamelDataWrapper *data_wrapper);
+static void construct_from_parser(CamelDataWrapper *dw, CamelMimeParser *mp);
 
 
 
@@ -59,6 +71,8 @@ camel_simple_data_wrapper_class_init (CamelSimpleDataWrapperClass *camel_simple_
 	camel_data_wrapper_class->construct_from_stream = construct_from_stream;
 	camel_data_wrapper_class->get_output_stream = get_output_stream;
 
+	camel_data_wrapper_class->construct_from_parser = construct_from_parser;
+
 	gtk_object_class->finalize = finalize;
 }
 
@@ -210,3 +224,135 @@ get_output_stream (CamelDataWrapper *data_wrapper)
 
 	return parent_class->get_output_stream (data_wrapper);
 }
+
+/* simple data wrapper */
+static void
+construct_from_parser(CamelDataWrapper *dw, CamelMimeParser *mp)
+{
+	GByteArray *buffer;
+	char *buf;
+	int len;
+	off_t start, end;
+	CamelMimeFilter *fdec = NULL, *fch = NULL;
+	struct _header_content_type *ct;
+	int decid=-1, chrid=-1, cache=FALSE;
+	CamelStream *source;
+	char *encoding;
+
+	d(printf("constructing simple-data-wrapper\n"));
+
+		/* Ok, try and be smart.  If we're storing a small message (typical) convert it,
+		   and store it in memory as we parse it ... if not, throw away the conversion
+		   and scan till the end ... */
+
+		/* if we can't seek, dont have a stream/etc, then we must cache it */
+	source = camel_mime_parser_stream(mp);
+	gtk_object_ref((GtkObject *)source);
+	if (source == NULL
+	    || !CAMEL_IS_SEEKABLE_STREAM(source))
+		cache = TRUE;
+
+	/* first, work out conversion, if any, required, we dont care about what we dont know about */
+	encoding = header_content_encoding_decode(camel_mime_parser_header(mp, "content-transfer-encoding", NULL));
+	if (encoding) {
+		if (!strcasecmp(encoding, "base64")) {
+			d(printf("Adding base64 decoder ...\n"));
+			fdec = (CamelMimeFilter *)camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_BASE64_DEC);
+			decid = camel_mime_parser_filter_add(mp, fdec);
+		} else if (!strcasecmp(encoding, "quoted-printable")) {
+			d(printf("Adding quoted-printable decoder ...\n"));
+			fdec = (CamelMimeFilter *)camel_mime_filter_basic_new_type(CAMEL_MIME_FILTER_BASIC_QP_DEC);
+			decid = camel_mime_parser_filter_add(mp, fdec);
+		}
+		g_free(encoding);
+	}
+
+	/* if we're doing text, then see if we have to convert it to UTF8 as well */
+	ct = camel_mime_parser_content_type(mp);
+	if (header_content_type_is(ct, "text", "*")) {
+		const char *charset = header_content_type_param(ct, "charset");
+		if (charset!=NULL
+		    && !(strcasecmp(charset, "us-ascii")==0
+			 || strcasecmp(charset, "utf-8")==0)) {
+			d(printf("Adding conversion filter from %s to utf-8\n", charset));
+			fch = (CamelMimeFilter *)camel_mime_filter_charset_new_convert(charset, "utf-8");
+			if (fch) {
+				chrid = camel_mime_parser_filter_add(mp, (CamelMimeFilter *)fch);
+			} else {
+				g_warning("Cannot convert '%s' to 'utf-8', message display may be corrupt", charset);
+			}
+		}
+
+	}
+
+	buffer = g_byte_array_new();
+
+		/* write to a memory buffer or something??? */
+	start = camel_mime_parser_tell(mp);
+	while ( camel_mime_parser_step(mp, &buf, &len) != HSCAN_BODY_END ) {
+		if (buffer) {
+			if (buffer->len > 20480 && !cache) {
+				/* is this a 'big' message?  Yes?  We dont want to convert it all then.*/
+				camel_mime_parser_filter_remove(mp, decid);
+				camel_mime_parser_filter_remove(mp, chrid);
+				decid = -1;
+				chrid = -1;
+				g_byte_array_free(buffer, TRUE);
+				buffer = NULL;
+			} else {
+				g_byte_array_append(buffer, buf, len);
+			}
+		}
+	}
+
+	if (buffer) {
+		CamelStream *mem;
+		d(printf("Small message part, kept in memory!\n"));
+		mem = camel_stream_mem_new_with_byte_array(buffer, CAMEL_STREAM_MEM_READ);
+		camel_data_wrapper_set_output_stream (dw, mem);
+	} else {
+		CamelSeekableSubstream *sub;
+		CamelStreamFilter *filter;
+
+		d(printf("Big message part, left on disk ...\n"));
+
+		end = camel_mime_parser_tell(mp);
+		sub = (CamelSeekableSubstream *)camel_seekable_substream_new_with_seekable_stream_and_bounds ((CamelSeekableStream *)source, start, end);
+		if (fdec || fch) {
+			filter = camel_stream_filter_new_with_stream((CamelStream *)sub);
+			if (fdec) {
+				camel_mime_filter_reset(fdec);
+				camel_stream_filter_add(filter, fdec);
+			}
+			if (fch) {
+				camel_mime_filter_reset(fdec);
+				camel_stream_filter_add(filter, fch);
+			}
+			camel_data_wrapper_set_output_stream (dw, (CamelStream *)filter);
+		} else {
+			camel_data_wrapper_set_output_stream (dw, (CamelStream *)sub);
+		}
+	}
+
+	camel_mime_parser_filter_remove(mp, decid);
+	camel_mime_parser_filter_remove(mp, chrid);
+
+	if (fdec)
+		gtk_object_unref((GtkObject *)fdec);
+	if (fch)
+		gtk_object_unref((GtkObject *)fch);
+	gtk_object_unref((GtkObject *)source);
+
+	/* FIXME: lookup in headers for content-type/encoding */
+#if 0
+	/* trivial, mem-based ... */
+	buffer = g_byte_array_new();
+	start = camel_mime_parser_tell(mp);
+	while ( camel_mime_parser_step(mp, &buf, &len) != HSCAN_BODY_END ) {
+		g_byte_array_append(buffer, buf, len);
+	}
+	end = camel_mime_parser_tell(mp);
+	mem = camel_stream_mem_new_with_byte_array(buffer, CAMEL_STREAM_MEM_READ);
+	camel_data_wrapper_set_output_stream (dw, mem);
+#endif
+}