Ripped out my code since it was never being used since the mime parser is

2001-07-11  Jeffrey Stedfast  <fejj@ximian.com>

	* camel-mime-part-utils.c
	(simple_data_wrapper_construct_from_parser): Ripped out my code
	since it was never being used since the mime parser is not using a
	seekable stream (ever?) which pretty much means my code needs to
	be done someplace else.

svn path=/trunk/; revision=11016

3 files changed, 77 insertions, 124 deletions

diff --git a/camel/ChangeLog b/camel/ChangeLog
index f585f3e4bd..762b025d04 100644
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,3 +1,11 @@
+2001-07-11  Jeffrey Stedfast  <fejj@ximian.com>
+
+	* camel-mime-part-utils.c
+	(simple_data_wrapper_construct_from_parser): Ripped out my code
+	since it was never being used since the mime parser is not using a
+	seekable stream (ever?) which pretty much means my code needs to
+	be done someplace else.
+
 2001-07-11  Peter Williams  <peterw@ximian.com>
 
 	* providers/imap/camel-imap-folder.c (camel_imap_folder_changed): 
diff --git a/camel/camel-mime-part-utils.c b/camel/camel-mime-part-utils.c
index 47d7795271..adf1e99dc8 100644
--- a/camel/camel-mime-part-utils.c
+++ b/camel/camel-mime-part-utils.c
@@ -26,12 +26,16 @@
 #include <config.h>
 #endif
 
+#include <stdio.h>
 #include <string.h>
+#include <unistd.h>
+
 #include "string-utils.h"
 #include "camel-mime-part-utils.h"
 #include "camel-mime-message.h"
 #include "camel-multipart.h"
 #include "camel-seekable-substream.h"
+#include "camel-stream-fs.h"
 #include "camel-stream-filter.h"
 #include "camel-stream-mem.h"
 #include "camel-mime-filter-basic.h"
@@ -42,54 +46,51 @@
 
 /* simple data wrapper */
 static void
-simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser *mp)
+simple_data_wrapper_construct_from_parser (CamelDataWrapper *dw, CamelMimeParser *mp)
 {
-	GByteArray *buffer;
-	char *buf;
-	int len;
-	off_t start = 0, end;
 	CamelMimeFilter *fdec = NULL, *fcrlf = NULL, *fch = NULL;
+	int len, decid = -1, crlfid = -1, chrid = -1;
 	struct _header_content_type *ct;
-	int decid=-1, crlfid=-1, chrid=-1;
-	CamelStream *source;
 	CamelSeekableStream *seekable_source = NULL;
-	char *encoding;
+	CamelStream *source;
+	GByteArray *buffer;
+	off_t start = 0, end;
+	char *encoding, *buf;
 	
 	d(printf("constructing 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);
+	source = camel_mime_parser_stream (mp);
 	if (source) {
-		camel_object_ref((CamelObject *)source);
+		camel_object_ref ((CamelObject *)source);
 		if (CAMEL_IS_SEEKABLE_STREAM (source)) {
 			seekable_source = CAMEL_SEEKABLE_STREAM (source);
 		}
 	}
 	
 	/* 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));
+	encoding = header_content_encoding_decode (camel_mime_parser_header (mp, "content-transfer-encoding", NULL));
 	if (encoding) {
-		if (!strcasecmp(encoding, "base64")) {
+		if (!g_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);
+			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);
+			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_free (encoding);
 	}
 	
 	/* If we're doing text, we also need to do CRLF->LF and may 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");
-		char *acharset; /* to be alloca'd if needed */
 		
 		if (fdec) {
 			d(printf("Adding CRLF conversion filter\n"));
@@ -98,65 +99,6 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser
 			crlfid = camel_mime_parser_filter_add (mp, fcrlf);
 		}
 		
-		/* Possible Lame Mailer Alert... check the META tag for a charset */
-		if (!charset && header_content_type_is (ct, "text", "html")) {
-			/* example: <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> */
-			const char *data, *slashhead;
-			CamelStream *mem;
-			
-			mem = camel_stream_mem_new ();
-			camel_data_wrapper_write_to_stream (dw, mem);
-			camel_stream_write (mem, "", 1);
-			
-			data = CAMEL_STREAM_MEM (mem)->buffer->data;
-			slashhead = strstrcase (data, "</head");
-			if (!slashhead)
-				slashhead = data + CAMEL_STREAM_MEM (mem)->buffer->len;
-			
-			/* Yea, this is ugly */
-			while (data < slashhead) {
-				struct _header_param *params;
-				char *meta, *metaend;
-				const char *val;
-				
-				meta = strstrcase (data, "<meta");
-				if (!meta)
-					break;
-				
-				metaend = strchr (meta, '>');
-				if (!metaend)
-					metaend = slashhead;
-				
-				params = html_meta_param_list_decode (meta, metaend - meta);
-				if (params) {
-					val = header_param (params, "http-equiv");
-					if (val && !g_strcasecmp (val, "Content-Type")) {
-						struct _header_content_type *content_type;
-						
-						content_type = header_content_type_decode (val);
-						charset = header_content_type_param (content_type, "charset");
-						if (charset) {
-							acharset = alloca (strlen (charset) + 1);
-							strcpy (acharset, charset);
-							charset = acharset;
-						}
-						
-						header_content_type_unref (content_type);
-					}
-					
-					header_param_list_free (params);
-					
-					/* break as soon as we find a charset */
-					if (charset)
-						break;
-				}
-				
-				data = metaend;
-			}
-			
-			camel_object_unref (CAMEL_OBJECT (mem));
-		}
-		
 		/* if the charset is not us-ascii or utf-8, then we need to convert to utf-8 */
 		if (charset && !(g_strcasecmp (charset, "us-ascii") == 0 || g_strcasecmp (charset, "utf-8") == 0)) {
 			d(printf("Adding conversion filter from %s to UTF-8\n", charset));
@@ -169,57 +111,58 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser
 		}
 	}
 	
-	buffer = g_byte_array_new();
-
+	buffer = g_byte_array_new ();
+	
 	if (seekable_source /* !cache */) {
-		start = camel_mime_parser_tell(mp) + seekable_source->bound_start;
+		start = camel_mime_parser_tell (mp) + seekable_source->bound_start;
 	}
+	
 	while (camel_mime_parser_step (mp, &buf, &len) != HSCAN_BODY_END) {
 		d(printf("appending o/p data: %d: %.*s\n", len, len, buf));
 		if (buffer) {
 			if (buffer->len > 20480 && seekable_source) {
-				/* 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);
+				/* 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);
+				g_byte_array_free (buffer, TRUE);
 				buffer = NULL;
 			} else {
-				g_byte_array_append(buffer, buf, len);
+				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);
+		
+		mem = camel_stream_mem_new_with_byte_array (buffer);
 		camel_data_wrapper_construct_from_stream (dw, mem);
 		camel_object_unref ((CamelObject *)mem);
 	} else {
 		CamelStream *sub;
 		CamelStreamFilter *filter;
-
+		
 		d(printf("Big message part, left on disk ...\n"));
-
-		end = camel_mime_parser_tell(mp) + seekable_source->bound_start;
+		
+		end = camel_mime_parser_tell (mp) + seekable_source->bound_start;
 		sub = camel_seekable_substream_new_with_seekable_stream_and_bounds (seekable_source, start, end);
 		if (fdec || fch) {
-			filter = camel_stream_filter_new_with_stream(sub);
+			filter = camel_stream_filter_new_with_stream (sub);
 			if (fdec) {
-				camel_mime_filter_reset(fdec);
-				camel_stream_filter_add(filter, fdec);
+				camel_mime_filter_reset (fdec);
+				camel_stream_filter_add (filter, fdec);
 			}
 			if (fcrlf) {
-				camel_mime_filter_reset(fcrlf);
-				camel_stream_filter_add(filter, fcrlf);
+				camel_mime_filter_reset (fcrlf);
+				camel_stream_filter_add (filter, fcrlf);
 			}
 			if (fch) {
-				camel_mime_filter_reset(fch);
-				camel_stream_filter_add(filter, fch);
+				camel_mime_filter_reset (fch);
+				camel_stream_filter_add (filter, fch);
 			}
 			camel_data_wrapper_construct_from_stream (dw, (CamelStream *)filter);
 			camel_object_unref ((CamelObject *)filter);
@@ -228,30 +171,31 @@ simple_data_wrapper_construct_from_parser(CamelDataWrapper *dw, CamelMimeParser
 		}
 		camel_object_unref ((CamelObject *)sub);
 	}
-
-	camel_mime_parser_filter_remove(mp, decid);
-	camel_mime_parser_filter_remove(mp, crlfid);
-	camel_mime_parser_filter_remove(mp, chrid);
-
+	
+	camel_mime_parser_filter_remove (mp, decid);
+	camel_mime_parser_filter_remove (mp, crlfid);
+	camel_mime_parser_filter_remove (mp, chrid);
+	
 	if (fdec)
-		camel_object_unref((CamelObject *)fdec);
+		camel_object_unref ((CamelObject *)fdec);
 	if (fcrlf)
-		camel_object_unref((CamelObject *)fcrlf);
+		camel_object_unref ((CamelObject *)fcrlf);
 	if (fch)
-		camel_object_unref((CamelObject *)fch);
+		camel_object_unref ((CamelObject *)fch);
 	if (source)
-		camel_object_unref((CamelObject *)source);
-
+		camel_object_unref ((CamelObject *)source);
 }
 
 /* This replaces the data wrapper repository ... and/or could be replaced by it? */
 void
-camel_mime_part_construct_content_from_parser(CamelMimePart *dw, CamelMimeParser *mp)
+camel_mime_part_construct_content_from_parser (CamelMimePart *dw, CamelMimeParser *mp)
 {
 	CamelDataWrapper *content = NULL;
 	char *buf;
 	int len;
 
+	printf ("camel_mime_part_construct_content_from_parser()\n");
+	
 	switch (camel_mime_parser_state(mp)) {
 	case HSCAN_HEADER:
 		d(printf("Creating body part\n"));
diff --git a/camel/camel-mime-utils.c b/camel/camel-mime-utils.c
index bf166faa4b..b87824e862 100644
--- a/camel/camel-mime-utils.c
+++ b/camel/camel-mime-utils.c
@@ -1905,7 +1905,7 @@ header_decode_rfc2184_param (const char **in, char **paramp, int *part, gboolean
 }
 
 static int
-header_decode_param(const char **in, char **paramp, char **valuep, int *is_rfc2184_param)
+header_decode_param (const char **in, char **paramp, char **valuep, int *is_rfc2184_param)
 {
 	gboolean is_rfc2184_encoded = FALSE;
 	gboolean is_rfc2184 = FALSE;
@@ -1970,9 +1970,9 @@ header_decode_param(const char **in, char **paramp, char **valuep, int *is_rfc21
 }
 
 char *
-header_param(struct _header_param *p, const char *name)
+header_param (struct _header_param *p, const char *name)
 {
-	while (p && strcasecmp(p->name, name) != 0)
+	while (p && g_strcasecmp (p->name, name) != 0)
 		p = p->next;
 	if (p)
 		return p->value;
@@ -1980,7 +1980,7 @@ header_param(struct _header_param *p, const char *name)
 }
 
 struct _header_param *
-header_set_param(struct _header_param **l, const char *name, const char *value)
+header_set_param (struct _header_param **l, const char *name, const char *value)
 {
 	struct _header_param *p = (struct _header_param *)l, *pn;
 
@@ -1989,12 +1989,12 @@ header_set_param(struct _header_param **l, const char *name, const char *value)
 		if (!g_strcasecmp (pn->name, name)) {
 			g_free (pn->value);
 			if (value) {
-				pn->value = g_strdup(value);
+				pn->value = g_strdup (value);
 				return pn;
 			} else {
 				p->next = pn->next;
 				g_free (pn->name);
-				g_free(pn);
+				g_free (pn);
 				return NULL;
 			}
 		}
@@ -2004,26 +2004,27 @@ header_set_param(struct _header_param **l, const char *name, const char *value)
 	if (value == NULL)
 		return NULL;
 
-	pn = g_malloc(sizeof(*pn));
+	pn = g_malloc (sizeof (*pn));
 	pn->next = 0;
-	pn->name = g_strdup(name);
-	pn->value = g_strdup(value);
+	pn->name = g_strdup (name);
+	pn->value = g_strdup (value);
 	p->next = pn;
 
 	return pn;
 }
 
 const char *
-header_content_type_param(struct _header_content_type *t, const char *name)
+header_content_type_param (struct _header_content_type *t, const char *name)
 {
 	if (t==NULL)
 		return NULL;
-	return header_param(t->params, name);
+	return header_param (t->params, name);
 }
 
-void header_content_type_set_param(struct _header_content_type *t, const char *name, const char *value)
+void
+header_content_type_set_param (struct _header_content_type *t, const char *name, const char *value)
 {
-	header_set_param(&t->params, name, value);
+	header_set_param (&t->params, name, value);
 }
 
 /**