From 5fcb83b5fb1294a781e3f7139200aa3486650db4 Mon Sep 17 00:00:00 2001 From: NotZed Date: Sun, 23 Apr 2000 10:10:44 +0000 Subject: Whole swag of changes. Still lots of cleanup remaining ... 2000-04-23 NotZed * 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 * 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 --- camel/camel-simple-data-wrapper.c | 150 +++++++++++++++++++++++++++++++++++++- 1 file changed, 148 insertions(+), 2 deletions(-) (limited to 'camel/camel-simple-data-wrapper.c') 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 + * Authors: Bertrand Guiheneuf + * Michael Zucchi * * 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 +#include "camel-mime-utils.h" +#include +#include +#include +#include +#include + +#include + +#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 +} -- cgit v1.2.3