No longer call data_wrapper_repository_init.

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

	* camel.c (camel_init): No longer call
	data_wrapper_repository_init.

	* camel-medium.c (write_to_stream): Moved (back) to
	camel-mime-part.
	(add_header):
	(set_header):
	(remove_header):
	(get_header): Make all these abstract, and spit warnings if
	called.  I guess it could manage the list, but well, it doesn't.

	* camel-medium.h (struct _CamelMedium): Dont store headers here,
	the implementor is the only one who knows their format.
	(CamelMediumClass): Changed header values to be void *'s.  They
	need not be strings?

	* camel-simple-data-wrapper.c (construct_from_stream): And we're
	back.  Set the output stream.
	(construct_from_parser): Moved to camel-mime-part-utils.

	* camel-mime-part-utils.c
	(camel_mime_part_construct_content_from_parser): Create the
	contents of multipart and simple messages.

	* camel-multipart.c (construct_from_parser): Moved to
	camel-mime-part-utils.
	(separate_part): Removed.

	* camel-mime-part.c (construct_from_stream): Back again!  This now
	switches over to using a mime parser for any mime parts, only.
	(my_write_to_stream): Write our headers and so forth here.
	(add_header): Add header directly, parent class is abstract.
	(remove_header): Ditto.
	(set_header): Ditto.

	* camel-data-wrapper.c (camel_data_wrapper_construct_from_stream):
	Remade abstract.
	(camel_data_wrapper_construct_from_parser): Moved to
	camel_mime_part.

	* camel-data-wrapper.h: Put back construct_from_stream.

	* camel-mime-part.h: Put construct_from_parser in here, the
	data-wrapper shouldn't know about mime.  Ok, so now to undo half
	of the last hours changes ... duh.

2a51,93
	* providers/pop3/camel-pop3-folder.c (get_message_by_number): Use
	construct_from_stream instead of set_input_stream().

	* camel-simple-data-wrapper-stream.c
	(camel_simple_data_wrapper_stream_construct): REmoved the destroy
	callback code.
	(wrapper_destroy_cb): Removed.

	* camel-simple-data-wrapper.h: Add prototype for _construct()
	method.

	* camel.c: Include unicode.h to kill a warning.

	* camel-data-wrapper.h (CameldataWrapperClass): Removed
	construct_from_stream virtual method.
	Removed get/set input stream.

	* data-wrapper-repository.[ch]: Removed&from build.  Obsoleted?
	The justification as is follows: It is mixing storage
	protocol/format with message architecture.  It really just doesn't
	serve any purpose, as each medium implementor will have to have its
	own type->handler mapping, and the only current implementor,
	mimepart has a very simple structure and no need for this.

	* camel-medium.c (write_to_stream): Moved here from most of the
	stuff in camel-mime-part.  Well, the MEDIUM is the one that knows
	what the headers are, and the content is, let it write it out.

	* camel-mime-part-utils.c (camel_mime_part_construct_content):
	Copied from camel-mime-part.c, removed handling of message
	followon state (moved to camel-mime-message).
	(camel_mime_part_construct_content_from_parser): Renamed from
	construct_content.
	(camel_mime_part_construct_headers_from_stream):
	(camel_mime_part_construct_content_from_stream):
	(camel_mime_part_store_stream_in_buffer): Removed.  Replaced by
	the new construct from parser stuff.

	* camel-mime-message.c (construct_from_parser): Do
	construct_from_parser for mime-message.
	(_write_to_stream): Set the mime-version header for medium to
	write out, rather than writing it out ourselves.

4a96,102
	(construct_from_stream): Removed.
	(camel_data_wrapper_construct_from_stream): Changed to a helper
	function, creates a mime_parser, and constructs from that.
	(set_input_stream): Removed.
	(camel_data_wrapper_set_input_stream): Removed.
	(get_input_stream): Removed.
	(camel_data_wrapper_get_input_stream): Removed.
11a110,111
	(_get_message_by_uid): Use construct_from_stream() instead of
	creating our own parser.
16a117,131
	(camel_mime_part_construct_content): Removed to
	camel-mime-part-utils.c
	(my_get_output_stream): Removed.  The streeam is in the
	data-wrapper.
	(my_get_content_object): Removed.  The content object is stored in
	the medium.  If none is there, the object wasn't created properly.
	(my_write_content_to_stream): Removed.  The content object is the
	one that knows how to write itself out!!!!!!!!
	(my_write_to_stream): Remove the base header writing stuff - has
	been moved to camel-medium, where it belongs.  This can just be
	used to check for mandatory headers.
	(my_construct_from_stream): Removed.
	(my_set_input_stream): What the hell, i'll remove this too.
	Nobody seems to understand how it differs from create from stream,
	and they both seem to serve the same purpose ...
19a135,136
	(construct_from_stream): Removed!  Job taken over by
	construct_from_parser.
24a142
	(set_input_stream): REmoved.  Replaced by construct_from_parser.

svn path=/trunk/; revision=2577

1 files changed, 162 insertions, 117 deletions

diff --git a/camel/camel-mime-part-utils.c b/camel/camel-mime-part-utils.c
index a4392d5f88..460a6c7d03 100644
--- a/camel/camel-mime-part-utils.c
+++ b/camel/camel-mime-part-utils.c
@@ -1,11 +1,8 @@
 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/* camel-mime-part-utils : Utility for mime parsing and so on */
-
-
-/* 
+/* camel-mime-part-utils : Utility for mime parsing and so on
  *
- * 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)
  *
@@ -25,141 +22,189 @@
  * USA
  */
 #include <config.h>
+#include <string.h>
 #include "gmime-content-field.h"
 #include "string-utils.h"
 #include "gmime-utils.h"
 #include "camel-simple-data-wrapper.h"
-#include "data-wrapper-repository.h" 
  
 #include "camel-mime-part-utils.h"
 
+#include "camel-mime-message.h"
+#include "camel-multipart.h"
+#include "camel-mime-body-part.h"
 
+#include "camel-seekable-substream.h"
+#include "camel-stream-filter.h"
+#include "camel-stream-mem.h"
+#include "camel-mime-filter-basic.h"
+#include "camel-mime-filter-charset.h"
 
-/* declare this function because it is public
-   but it must not be called except here */
-void        camel_mime_part_set_content_type              (CamelMimePart *mime_part, 
-							   gchar *content_type);
-
+#define d(x)
 
-void
-camel_mime_part_construct_headers_from_stream (CamelMimePart *mime_part, 
-					       CamelStream *stream)
+/* simple data wrapper */
+static void
+simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser *mp)
 {
-	GArray *header_array;
-	Rfc822Header *cur_header;
-	int i;
-
-	g_assert (stream);
-	/* 
-	 * parse all header lines 
-	 */
-	header_array = get_header_array_from_stream (stream);
-	if (header_array) {
-		for (i=0; i<header_array->len; i++) {
-			cur_header = (Rfc822Header *)header_array->data + i;
-			camel_medium_add_header ( CAMEL_MEDIUM (mime_part), 
-						  cur_header->name, 
-						  cur_header->value);
-			g_free (cur_header->name);
-			g_free (cur_header->value);
+	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);
+	}
 
-		g_array_free (header_array, TRUE);
+	/* 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);
 
-void
-camel_mime_part_construct_content_from_stream (CamelMimePart *mime_part, 
-					       CamelStream *stream)
-{
-	GMimeContentField *content_type = NULL;
-	gchar *mime_type = NULL;
-	GtkType content_object_type;
-	CamelDataWrapper *content_object = NULL;
-	
-	
-	/* 
-	 * find content mime type 
-	 */
-	content_type = camel_mime_part_get_content_type (mime_part);
-	/* here we should have a mime type */
-	if (content_type)
-		mime_type = gmime_content_field_get_mime_type (content_type);
-
-	/* 
-	 * no mime type found for the content, 
-	 * using text/plain is the default 
-	 */
-	if (!mime_type) {
-		mime_type = g_strdup ("text/plain");
-		camel_mime_part_set_content_type (mime_part, mime_type);
-	}
-	
-	/* 
-	 * find in the repository what particular data wrapper is 
-	 * associated to this mime type 
-	 */
-	content_object_type = 
-		data_wrapper_repository_get_data_wrapper_type (mime_type);
-
-	g_free (mime_type);
-
-	/* 
-	 * create the content object data wrapper with the type 
-	 * returned by the data wrapper repository 
-	 */
-	content_object = CAMEL_DATA_WRAPPER (gtk_type_new (content_object_type));
-	camel_data_wrapper_set_mime_type_field (content_object, 
-						camel_mime_part_get_content_type (mime_part));
-	camel_medium_set_content_object ( CAMEL_MEDIUM (mime_part), content_object);
-
-	/* set the input stream for the content object */
-	camel_data_wrapper_set_input_stream (content_object, stream);
-
-	/* 
-	 * the object is referenced in the set_content_object method, 
-	 * so unref it here 
-	 */
-	gtk_object_unref (GTK_OBJECT (content_object));
 }
 
-
-
+/* This replaces the data wrapper repository ... and/or could be replaced by it? */
 void
-camel_mime_part_store_stream_in_buffer (CamelMimePart *mime_part, 
-					CamelStream *stream)
+camel_mime_part_construct_content_from_parser(CamelMimePart *dw, CamelMimeParser *mp)
 {
-	gint nb_bytes_read_total = 0;
-	gint nb_bytes_read_chunk;
-	GByteArray *buffer;
-#define STREAM_READ_CHUNK_SZ  100
-
-	if (mime_part->temp_message_buffer == NULL)
-		mime_part->temp_message_buffer = g_byte_array_new ();
-	
-	buffer = mime_part->temp_message_buffer;
-
-	g_byte_array_set_size (buffer, nb_bytes_read_total + STREAM_READ_CHUNK_SZ);
-	nb_bytes_read_chunk = camel_stream_read (stream,
-						 buffer->data + nb_bytes_read_total, 
-						 STREAM_READ_CHUNK_SZ);
-
-	if (nb_bytes_read_chunk>0) {
-		nb_bytes_read_total += nb_bytes_read_chunk;
-		
-		while (nb_bytes_read_chunk >0) {
-			g_byte_array_set_size (buffer, nb_bytes_read_total + STREAM_READ_CHUNK_SZ);
-			nb_bytes_read_chunk = camel_stream_read (stream,
-								 buffer->data + nb_bytes_read_total, 
-								 STREAM_READ_CHUNK_SZ);
-			nb_bytes_read_total += nb_bytes_read_chunk;
+	CamelDataWrapper *content = NULL;
+	char *buf;
+	int len;
+
+	switch (camel_mime_parser_state(mp)) {
+	case HSCAN_HEADER:
+		d(printf("Creating body part\n"));
+		content = (CamelDataWrapper *)camel_simple_data_wrapper_new();
+		break;
+	case HSCAN_MESSAGE:
+		d(printf("Creating message part\n"));
+		content = (CamelDataWrapper *)camel_mime_message_new();
+		simple_data_wrapper_construct_from_parser(content, mp);
+		break;
+	case HSCAN_MULTIPART: {
+		CamelDataWrapper *bodypart;
+
+#warning This should use a camel-mime-multipart
+		d(printf("Creating multi-part\n"));
+		content = (CamelDataWrapper *)camel_multipart_new();
+
+		/* get/set boundary? */
+
+		while (camel_mime_parser_step(mp, &buf, &len) != HSCAN_MULTIPART_END) {
+			camel_mime_parser_unstep(mp);
+			bodypart = (CamelDataWrapper *)camel_mime_body_part_new();
+			camel_mime_part_construct_from_parser((CamelMimePart *)bodypart, mp);
+			camel_multipart_add_part((CamelMultipart *)dw, (CamelMimeBodyPart *)bodypart);
 		}
+		break; }
+	default:
+		g_warning("Invalid state encountered???: %d", camel_mime_parser_state(mp));
+	}
+	if (content) {
+#warning there just has got to be a better way ... to transfer the mime-type to the datawrapper
+		/* would you believe you have to set this BEFORE you set the content object???  oh my god !!!! */
+		camel_data_wrapper_set_mime_type_field (content, 
+							camel_mime_part_get_content_type ((CamelMimePart *)dw));
+		camel_medium_set_content_object((CamelMedium *)dw, content);
 	}
-
-	g_byte_array_set_size (buffer, nb_bytes_read_total);
 }
+