From 6d2c382788a4042d53f49a080acd11b499aa52f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dan=20Vr=C3=A1til?= Date: Wed, 28 Mar 2012 18:38:11 +0200 Subject: WebKit port - port formatter and mail module --- em-format/Makefile.am | 6 +- em-format/em-format-quote.c | 792 ++++----- em-format/em-format-quote.h | 3 + em-format/em-format.c | 3928 ++++++++++++++++++++++--------------------- em-format/em-format.h | 566 +++---- 5 files changed, 2685 insertions(+), 2610 deletions(-) (limited to 'em-format') diff --git a/em-format/Makefile.am b/em-format/Makefile.am index 278bcb2527..392a195044 100644 --- a/em-format/Makefile.am +++ b/em-format/Makefile.am @@ -13,7 +13,8 @@ libemformat_la_CPPFLAGS = \ -I$(top_srcdir) \ -I$(top_srcdir)/widgets \ $(EVOLUTION_DATA_SERVER_CFLAGS) \ - $(GNOME_PLATFORM_CFLAGS) + $(GNOME_PLATFORM_CFLAGS) \ + $(LIBSOUP_CFLAGS) libemformat_la_SOURCES = \ $(emformatinclude_HEADERS) \ @@ -28,6 +29,7 @@ libemformat_la_LIBADD = \ $(top_builddir)/e-util/libeutil.la \ $(top_builddir)/shell/libeshell.la \ $(EVOLUTION_DATA_SERVER_LIBS) \ - $(GNOME_PLATFORM_LIBS) + $(GNOME_PLATFORM_LIBS) \ + $(LIBSOUP_LIBS) -include $(top_srcdir)/git.mk diff --git a/em-format/em-format-quote.c b/em-format/em-format-quote.c index c3f75ec14d..4822f115d7 100644 --- a/em-format/em-format-quote.c +++ b/em-format/em-format-quote.c @@ -39,237 +39,73 @@ struct _EMFormatQuotePrivate { gchar *credits; - CamelStream *stream; EMFormatQuoteFlags flags; guint32 text_html_flags; }; static void emfq_builtin_init (EMFormatQuoteClass *efhc); -static gpointer parent_class; - -static void -emfq_dispose (GObject *object) -{ - EMFormatQuotePrivate *priv; - - priv = EM_FORMAT_QUOTE_GET_PRIVATE (object); - - if (priv->stream != NULL) { - g_object_unref (priv->stream); - priv->stream = NULL; - } - - /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (parent_class)->dispose (object); -} - -static void -emfq_finalize (GObject *object) -{ - EMFormatQuotePrivate *priv; - - priv = EM_FORMAT_QUOTE_GET_PRIVATE (object); - - g_free (priv->credits); - - /* Chain up to parent's finalize() method. */ - G_OBJECT_CLASS (parent_class)->finalize (object); -} +static CamelMimePart * decode_inline_parts (CamelMimePart *part, GCancellable *cancellable); -static void -emfq_format_clone (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *msg, - EMFormat *src, - GCancellable *cancellable) -{ - EMFormatQuote *emfq = (EMFormatQuote *) emf; - const EMFormatHandler *handle; - GSettings *settings; +static void emfq_parse_text_plain (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emfq_parse_text_enriched (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emfq_parse_text_html (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emfq_parse_attachment (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); - /* Chain up to parent's format_clone() method. */ - EM_FORMAT_CLASS (parent_class)->format_clone ( - emf, folder, uid, msg, src, cancellable); +static void emfq_write_text_plain (EMFormat *emf, EMFormatPURI *puri, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable); +static void emfq_write_text_enriched (EMFormat *emf, EMFormatPURI *puri, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable); +static void emfq_write_text_html (EMFormat *emf, EMFormatPURI *puri, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable); - g_seekable_seek ( - G_SEEKABLE (emfq->priv->stream), - 0, G_SEEK_SET, NULL, NULL); - - settings = g_settings_new ("org.gnome.evolution.mail"); - if (g_settings_get_boolean ( - settings, "composer-top-signature")) - camel_stream_write_string ( - emfq->priv->stream, "
\n", cancellable, NULL); - g_object_unref (settings); - handle = em_format_find_handler(emf, "x-evolution/message/prefix"); - if (handle) - handle->handler ( - emf, emfq->priv->stream, - CAMEL_MIME_PART (msg), - handle, cancellable, FALSE); - handle = em_format_find_handler(emf, "x-evolution/message/rfc822"); - if (handle) - handle->handler ( - emf, emfq->priv->stream, - CAMEL_MIME_PART (msg), - handle, cancellable, FALSE); - - camel_stream_flush (emfq->priv->stream, cancellable, NULL); - - g_signal_emit_by_name(emf, "complete"); -} - -static void -emfq_format_error (EMFormat *emf, - CamelStream *stream, - const gchar *errmsg) -{ - /* Nothing to do. */ -} +static gpointer parent_class; -static void -emfq_format_source (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - GCancellable *cancellable) +/* Decodes inline encoded parts of 'part'. The returned pointer, + * if not NULL, should be unreffed with g_object_unref(). */ +static CamelMimePart * +decode_inline_parts (CamelMimePart *part, + GCancellable *cancellable) { + CamelMultipart *mp; + CamelStream *null; CamelStream *filtered_stream; - CamelMimeFilter *html_filter; + EMInlineFilter *inline_filter; - filtered_stream = camel_stream_filter_new (stream); - html_filter = camel_mime_filter_tohtml_new ( - CAMEL_MIME_FILTER_TOHTML_CONVERT_NL | - CAMEL_MIME_FILTER_TOHTML_CONVERT_SPACES | - CAMEL_MIME_FILTER_TOHTML_ESCAPE_8BIT, 0); - camel_stream_filter_add ( - CAMEL_STREAM_FILTER (filtered_stream), html_filter); - g_object_unref (html_filter); + g_return_val_if_fail (part != NULL, NULL); - em_format_format_text ( - emf, filtered_stream, - CAMEL_DATA_WRAPPER (part), cancellable); + null = camel_stream_null_new (); + filtered_stream = camel_stream_filter_new (null); + g_object_unref (null); + inline_filter = em_inline_filter_new ( + camel_mime_part_get_encoding (part), + camel_mime_part_get_content_type (part)); + camel_stream_filter_add ( + CAMEL_STREAM_FILTER (filtered_stream), + CAMEL_MIME_FILTER (inline_filter)); + camel_data_wrapper_decode_to_stream_sync ( + camel_medium_get_content (CAMEL_MEDIUM (part)), + filtered_stream, cancellable, NULL); + camel_stream_close (filtered_stream, cancellable, NULL); g_object_unref (filtered_stream); -} - -static void -emfq_format_attachment (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const gchar *mime_type, - const EMFormatHandler *handle, - GCancellable *cancellable) -{ - EMFormatQuote *emfq = EM_FORMAT_QUOTE (emf); - gchar *text, *html; - - if (!em_format_is_inline (emf, emf->part_id->str, part, handle)) - return; - - camel_stream_write_string ( - stream, "" - "
\n", cancellable, NULL); - - /* output some info about it */ - text = em_format_describe_part (part, mime_type); - html = camel_text_to_html ( - text, emfq->priv->text_html_flags & - CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS, 0); - camel_stream_write_string (stream, html, cancellable, NULL); - g_free (html); - g_free (text); - - camel_stream_write_string ( - stream, "
", cancellable, NULL); - - handle->handler (emf, stream, part, handle, cancellable, FALSE); -} - -static void -emfq_base_init (EMFormatQuoteClass *class) -{ - emfq_builtin_init (class); -} - -static void -emfq_class_init (EMFormatQuoteClass *class) -{ - GObjectClass *object_class; - EMFormatClass *format_class; - - parent_class = g_type_class_peek_parent (class); - g_type_class_add_private (class, sizeof (EMFormatQuotePrivate)); - - object_class = G_OBJECT_CLASS (class); - object_class->dispose = emfq_dispose; - object_class->finalize = emfq_finalize; - - format_class = EM_FORMAT_CLASS (class); - format_class->format_clone = emfq_format_clone; - format_class->format_error = emfq_format_error; - format_class->format_source = emfq_format_source; - format_class->format_attachment = emfq_format_attachment; -} - -static void -emfq_init (EMFormatQuote *emfq) -{ - emfq->priv = EM_FORMAT_QUOTE_GET_PRIVATE (emfq); - - /* we want to convert url's etc */ - emfq->priv->text_html_flags = - CAMEL_MIME_FILTER_TOHTML_PRE | - CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS | - CAMEL_MIME_FILTER_TOHTML_CONVERT_ADDRESSES; -} -GType -em_format_quote_get_type (void) -{ - static GType type = 0; - - if (G_UNLIKELY (type == 0)) { - static const GTypeInfo type_info = { - sizeof (EMFormatQuoteClass), - (GBaseInitFunc) emfq_base_init, - (GBaseFinalizeFunc) NULL, - (GClassInitFunc) emfq_class_init, - (GClassFinalizeFunc) NULL, - NULL, /* class_data */ - sizeof (EMFormatQuote), - 0, /* n_preallocs */ - (GInstanceInitFunc) emfq_init, - NULL /* value_table */ - }; - - type = g_type_register_static ( - EM_TYPE_FORMAT, "EMFormatQuote", &type_info, 0); + if (!em_inline_filter_found_any (inline_filter)) { + g_object_unref (inline_filter); + return NULL; } - return type; -} - -EMFormatQuote * -em_format_quote_new (const gchar *credits, - CamelStream *stream, - EMFormatQuoteFlags flags) -{ - EMFormatQuote *emfq; - - g_return_val_if_fail (CAMEL_IS_STREAM (stream), NULL); - - /* Steam must also be seekable so we can reset its position. */ - g_return_val_if_fail (G_IS_SEEKABLE (stream), NULL); + mp = em_inline_filter_get_multipart (inline_filter); - emfq = g_object_new (EM_TYPE_FORMAT_QUOTE, NULL); + g_object_unref (inline_filter); - emfq->priv->credits = g_strdup (credits); - emfq->priv->stream = g_object_ref (stream); - emfq->priv->flags = flags; + if (mp) { + part = camel_mime_part_new (); + camel_medium_set_content ( + CAMEL_MEDIUM (part), CAMEL_DATA_WRAPPER (mp)); + g_object_unref (mp); + } else { + g_object_ref (part); + } - return emfq; + return part; } static void @@ -296,18 +132,18 @@ emfq_format_text_header (EMFormatQuote *emfq, if (flags & EM_FORMAT_HEADER_BOLD) g_string_append_printf ( - buffer, "%s: %s
", label, html); + buffer, "%s: %s
", label, html); else g_string_append_printf ( - buffer, "%s: %s
", label, html); + buffer, "%s: %s
", label, html); g_free (mhtml); } static const gchar *addrspec_hdrs[] = { - "Sender", "From", "Reply-To", "To", "Cc", "Bcc", - "Resent-Sender", "Resent-from", "Resent-Reply-To", - "Resent-To", "Resent-cc", "Resent-Bcc", NULL + "Sender", "From", "Reply-To", "To", "Cc", "Bcc", + "Resent-Sender", "Resent-from", "Resent-Reply-To", + "Resent-To", "Resent-cc", "Resent-Bcc", NULL }; #if 0 @@ -315,7 +151,7 @@ static const gchar *addrspec_hdrs[] = { /* For Translators only: The following strings are * used in the header table in the preview pane. */ static gchar *i18n_hdrs[] = { - N_("From"), N_("Reply-To"), N_("To"), N_("Cc"), N_("Bcc") + N_("From"), N_("Reply-To"), N_("To"), N_("Cc"), N_("Bcc") }; #endif @@ -337,18 +173,18 @@ emfq_format_address (GString *out, if (name && *name) { gchar *real, *mailaddr; - g_string_append_printf (out, "%s <", name); - /* rfc2368 for mailto syntax and url encoding extras */ + g_string_append_printf (out, "%s <", name); + /* rfc2368 for mailto syntax and url encoding extras */ if ((real = camel_header_encode_phrase ((guchar *) a->name))) { - mailaddr = g_strdup_printf ("%s <%s>", real, a->v.addr); + mailaddr = g_strdup_printf ("%s <%s>", real, a->v.addr); g_free (real); - mailto = camel_url_encode (mailaddr, "?=&()"); + mailto = camel_url_encode (mailaddr, "?=&()"); g_free (mailaddr); } else { - mailto = camel_url_encode (a->v.addr, "?=&()"); + mailto = camel_url_encode (a->v.addr, "?=&()"); } } else { - mailto = camel_url_encode (a->v.addr, "?=&()"); + mailto = camel_url_encode (a->v.addr, "?=&()"); } addr = camel_text_to_html (a->v.addr, flags, 0); g_string_append_printf ( @@ -358,15 +194,15 @@ emfq_format_address (GString *out, g_free (addr); if (name && *name) - g_string_append (out, ">"); + g_string_append (out, ">"); break; case CAMEL_HEADER_ADDRESS_GROUP: - g_string_append_printf (out, "%s: ", name); + g_string_append_printf (out, "%s: ", name); emfq_format_address (out, a->v.members); - g_string_append_printf (out, ";"); + g_string_append_printf (out, ";"); break; default: - g_warning ("Invalid address type"); + g_warning ("Invalid address type"); break; } @@ -374,7 +210,7 @@ emfq_format_address (GString *out, a = a->next; if (a) - g_string_append (out, ", "); + g_string_append (out, ", "); } } @@ -383,20 +219,20 @@ canon_header_name (gchar *name) { gchar *inptr = name; - /* canonicalise the header name... first letter is - * capitalised and any letter following a '-' also gets - * capitalised */ + /* canonicalise the header name... first letter is + * capitalised and any letter following a '-' also gets + * capitalised */ if (g_ascii_islower (*inptr)) - *inptr = g_ascii_toupper (*inptr); + *inptr = g_ascii_toupper (*inptr); inptr++; while (*inptr) { if (inptr[-1] == '-' && g_ascii_islower (*inptr)) - *inptr = g_ascii_toupper (*inptr); + *inptr = g_ascii_toupper (*inptr); else if (g_ascii_isupper (*inptr)) - *inptr = g_ascii_tolower (*inptr); + *inptr = g_ascii_tolower (*inptr); inptr++; } @@ -422,8 +258,8 @@ emfq_format_header (EMFormat *emf, strcpy (name, namein); canon_header_name (name); - /* Never quote Bcc headers */ - if (g_str_equal (name, "Bcc") || g_str_equal (name, "Resent-Bcc")) + /* Never quote Bcc headers */ + if (g_str_equal (name, "Bcc") || g_str_equal (name, "Resent-Bcc")) return; for (i = 0; addrspec_hdrs[i]; i++) { @@ -444,8 +280,8 @@ emfq_format_header (EMFormat *emf, buf = camel_header_unfold (txt); addrs = camel_header_address_decode ( - txt, emf->charset ? - emf->charset : emf->default_charset); + txt, em_format_get_charset (emf) ? + em_format_get_charset (emf) : em_format_get_default_charset (emf)); if (addrs == NULL) { g_free (buf); return; @@ -453,29 +289,29 @@ emfq_format_header (EMFormat *emf, g_free (buf); - html = g_string_new (""); + html = g_string_new (""); emfq_format_address (html, addrs); camel_header_address_unref (addrs); txt = value = html->str; g_string_free (html, FALSE); flags |= EM_FORMAT_HEADER_BOLD; is_html = TRUE; - } else if (!strcmp (name, "Subject")) { + } else if (!strcmp (name, "Subject")) { txt = camel_mime_message_get_subject (msg); - label = _("Subject"); + label = _("Subject"); flags |= EM_FORMAT_HEADER_BOLD; - } else if (!strcmp (name, "X-Evolution-Mailer")) { /* pseudo-header */ - if (!(txt = camel_medium_get_header (part, "x-mailer"))) - if (!(txt = camel_medium_get_header (part, "user-agent"))) - if (!(txt = camel_medium_get_header (part, "x-newsreader"))) - if (!(txt = camel_medium_get_header (part, "x-mimeole"))) + } else if (!strcmp (name, "X-Evolution-Mailer")) { /* pseudo-header */ + if (!(txt = camel_medium_get_header (part, "x-mailer"))) + if (!(txt = camel_medium_get_header (part, "user-agent"))) + if (!(txt = camel_medium_get_header (part, "x-newsreader"))) + if (!(txt = camel_medium_get_header (part, "x-mimeole"))) return; txt = value = camel_header_format_ctext (txt, charset); - label = _("Mailer"); + label = _("Mailer"); flags |= EM_FORMAT_HEADER_BOLD; - } else if (!strcmp (name, "Date") || !strcmp (name, "Resent-Date")) { + } else if (!strcmp (name, "Date") || !strcmp (name, "Resent-Date")) { if (!(txt = camel_medium_get_header (part, name))) return; @@ -506,10 +342,10 @@ emfq_format_headers (EMFormatQuote *emfq, return; ct = camel_mime_part_get_content_type ((CamelMimePart *) part); - charset = camel_content_type_param (ct, "charset"); + charset = camel_content_type_param (ct, "charset"); charset = camel_iconv_charset_name (charset); - /* dump selected headers */ + /* dump selected headers */ link = g_queue_peek_head_link (&emf->header_list); while (link != NULL) { EMFormatHeader *h = link->data; @@ -518,154 +354,335 @@ emfq_format_headers (EMFormatQuote *emfq, link = g_list_next (link); } - g_string_append (buffer, "
\n"); + g_string_append (buffer, "
\n"); } static void -emfq_format_message_prefix (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +emfq_dispose (GObject *object) { - EMFormatQuote *emfq = (EMFormatQuote *) emf; + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (parent_class)->dispose (object); +} - if (emfq->priv->credits != NULL) { - camel_stream_write_string ( - stream, emfq->priv->credits, NULL, NULL); - camel_stream_write_string ( - stream, "
\n", NULL, NULL); - } +static void +emfq_finalize (GObject *object) +{ + EMFormatQuotePrivate *priv; + + priv = EM_FORMAT_QUOTE_GET_PRIVATE (object); + + g_free (priv->credits); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (parent_class)->finalize (object); } +/******************************************************************************/ static void -emfq_format_message (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +emfq_parse_text_plain (EMFormat * emf, + CamelMimePart * part, + GString * part_id, + EMFormatParserInfo * info, + GCancellable * cancellable) { - EMFormatQuote *emfq = (EMFormatQuote *) emf; - GString *buffer; + EMFormatPURI *puri; + CamelMimePart *mp; + gint len; - buffer = g_string_sized_new (1024); + len = part_id->len; + g_string_append (part_id, ".text_plain"); - if (emfq->priv->flags & EM_FORMAT_QUOTE_CITE) - g_string_append ( - buffer, - "\n" - "
\n"); + mp = decode_inline_parts (part, cancellable); + if (mp) { - if (((CamelMimePart *) emf->message) != part) { - g_string_append_printf ( - buffer, - "%s
\n", - _("-------- Forwarded Message --------")); - emfq_format_headers (emfq, buffer, (CamelMedium *) part); - } else if (emfq->priv->flags & EM_FORMAT_QUOTE_HEADERS) - emfq_format_headers (emfq, buffer, (CamelMedium *) part); + if (CAMEL_IS_MULTIPART (camel_medium_get_content (CAMEL_MEDIUM (mp)))) { + em_format_parse_part (emf, mp, part_id, info, cancellable); + } - camel_stream_write ( - stream, buffer->str, buffer->len, cancellable, NULL); + g_object_unref (mp); + } - em_format_part (emf, stream, part, cancellable); + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = emfq_write_text_plain; + puri->mime_type = g_strdup ("text/html"); + em_format_add_puri (emf, puri); - if (emfq->priv->flags & EM_FORMAT_QUOTE_CITE) - camel_stream_write_string ( - stream, "
", - cancellable, NULL); + g_string_truncate (part_id, len); } -/* Decodes inline encoded parts of 'part'. The returned pointer, - * if not NULL, should be unreffed with g_object_unref(). */ -static CamelMimePart * -decode_inline_parts (CamelMimePart *part, - GCancellable *cancellable) +static void +emfq_parse_text_html (EMFormat * emf, + CamelMimePart * part, + GString * part_id, + EMFormatParserInfo * info, + GCancellable * cancellable) { - CamelMultipart *mp; - CamelStream *null; - CamelStream *filtered_stream; - EMInlineFilter *inline_filter; + EMFormatPURI *puri; + gint len; - g_return_val_if_fail (part != NULL, NULL); + len = part_id->len; + g_string_append (part_id, ".text_html"); - null = camel_stream_null_new (); - filtered_stream = camel_stream_filter_new (null); - g_object_unref (null); + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = emfq_write_text_html; + puri->mime_type = g_strdup ("text/html"); + em_format_add_puri (emf, puri); - inline_filter = em_inline_filter_new ( - camel_mime_part_get_encoding (part), - camel_mime_part_get_content_type (part)); - camel_stream_filter_add ( - CAMEL_STREAM_FILTER (filtered_stream), - CAMEL_MIME_FILTER (inline_filter)); - camel_data_wrapper_decode_to_stream_sync ( - camel_medium_get_content (CAMEL_MEDIUM (part)), - filtered_stream, cancellable, NULL); - camel_stream_close (filtered_stream, cancellable, NULL); - g_object_unref (filtered_stream); + g_string_truncate (part_id, len); +} - if (!em_inline_filter_found_any (inline_filter)) { - g_object_unref (inline_filter); - return NULL; +static void +emfq_parse_text_enriched (EMFormat * emf, + CamelMimePart * part, + GString * part_id, + EMFormatParserInfo * info, + GCancellable * cancellable) +{ + EMFormatPURI *puri; + gint len; + + len = part_id->len; + g_string_append (part_id, ".text_enriched"); + + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = emfq_write_text_enriched; + puri->mime_type = g_strdup ("text/html"); + em_format_add_puri (emf, puri); + + g_string_truncate (part_id, len); +} + +static void +emfq_parse_attachment (EMFormat * emf, + CamelMimePart * part, + GString * part_id, + EMFormatParserInfo * info, + GCancellable * cancellable) +{ + EMFormatPURI *puri; + gint len; + + len = part_id->len; + g_string_append (part_id, ".attachment"); + + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = emfq_write_text_html; + puri->mime_type = g_strdup ("text/html"); + puri->is_attachment = TRUE; + em_format_add_puri (emf, puri); + + g_string_truncate (part_id, len); +} + +/******************************************************************************/ + +static void +emfq_write_attachment (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) +{ + EMFormatQuote *emfq = EM_FORMAT_QUOTE (emf); + const EMFormatHandler *handler; + gchar *text, *html; + CamelContentType *ct; + const gchar *mime_type; + + ct = camel_mime_part_get_content_type (puri->part); + if (ct) { + mime_type = camel_content_type_simple (ct); + camel_content_type_unref (ct); + } else { + mime_type = "application/octet-stream"; } - mp = em_inline_filter_get_multipart (inline_filter); + handler = em_format_find_handler (emf, mime_type); - g_object_unref (inline_filter); + if (!em_format_is_inline (emf, puri->uri, puri->part, handler)) + return; - if (mp) { - part = camel_mime_part_new (); - camel_medium_set_content ( - CAMEL_MEDIUM (part), CAMEL_DATA_WRAPPER (mp)); - g_object_unref (mp); + camel_stream_write_string ( + stream, "" + "
\n", cancellable, NULL); + + /* output some info about it */ + text = em_format_describe_part (puri->part, mime_type); + html = camel_text_to_html ( + text, emfq->priv->text_html_flags & + CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS, 0); + camel_stream_write_string (stream, html, cancellable, NULL); + g_free (html); + g_free (text); + + camel_stream_write_string ( + stream, "
", cancellable, NULL); + + if (handler && handler->write_func) + handler->write_func (emf, puri, stream, info, cancellable); +} + +static void +emfq_base_init (EMFormatQuoteClass *klass) +{ + emfq_builtin_init (klass); +} + +static void +emfq_class_init (EMFormatQuoteClass *klass) +{ + GObjectClass *object_class; + + parent_class = g_type_class_peek_parent (klass); + g_type_class_add_private (klass, sizeof (EMFormatQuotePrivate)); + + object_class = G_OBJECT_CLASS (klass); + object_class->dispose = emfq_dispose; + object_class->finalize = emfq_finalize; +} + +static void +emfq_init (EMFormatQuote *emfq) +{ + emfq->priv = EM_FORMAT_QUOTE_GET_PRIVATE (emfq); + + /* we want to convert url's etc */ + emfq->priv->text_html_flags = + CAMEL_MIME_FILTER_TOHTML_PRE | + CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS | + CAMEL_MIME_FILTER_TOHTML_CONVERT_ADDRESSES; +} + +GType +em_format_quote_get_type (void) +{ + static GType type = 0; + + if (G_UNLIKELY (type == 0)) { + static const GTypeInfo type_info = { + sizeof (EMFormatQuoteClass), + (GBaseInitFunc) emfq_base_init, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) emfq_class_init, + (GClassFinalizeFunc) NULL, + NULL, /* class_data */ + sizeof (EMFormatQuote), + 0, /* n_preallocs */ + (GInstanceInitFunc) emfq_init, + NULL /* value_table */ + }; + + type = g_type_register_static ( + EM_TYPE_FORMAT, "EMFormatQuote", &type_info, 0); + } + + return type; +} + +EMFormatQuote * +em_format_quote_new (const gchar *credits, + CamelStream *stream, + EMFormatQuoteFlags flags) +{ + EMFormatQuote *emfq; + + g_return_val_if_fail (CAMEL_IS_STREAM (stream), NULL); + + /* Steam must also be seekable so we can reset its position. */ + g_return_val_if_fail (G_IS_SEEKABLE (stream), NULL); + + emfq = g_object_new (EM_TYPE_FORMAT_QUOTE, NULL); + + emfq->priv->credits = g_strdup (credits); + emfq->priv->flags = flags; + + return emfq; +} + +void +em_format_quote_write (EMFormatQuote * emfq, + CamelStream * stream, + GCancellable * cancellable) +{ + EMFormat *emf; + GSettings *settings; + GList *iter; + EMFormatWriterInfo info = { 0 }; + + emf = (EMFormat *) emfq; + + g_seekable_seek ( + G_SEEKABLE (stream), + 0, G_SEEK_SET, NULL, NULL); + + settings = g_settings_new ("org.gnome.evolution.mail"); + if (g_settings_get_boolean ( + settings, "composer-top-signature")) + camel_stream_write_string ( + stream, "
\n", cancellable, NULL); + g_object_unref (settings); + + if (emfq->priv->credits && *emfq->priv->credits) { + gchar *credits = g_strdup_printf ("%s
", emfq->priv->credits); + camel_stream_write_string (stream, credits, cancellable, NULL); + g_free (credits); } else { - g_object_ref (part); + camel_stream_write_string (stream, "
", cancellable, NULL); } - return part; + if (emfq->priv->flags & EM_FORMAT_QUOTE_CITE) + camel_stream_write_string (stream, + "\n" + "
\n", cancellable, NULL); + + for (iter = emf->mail_part_list; iter; iter = iter->next) { + EMFormatPURI *puri = iter->data; + + if (puri->is_attachment || !puri->write_func) + continue; + + puri = iter->data; + + if (emfq->priv->flags & EM_FORMAT_QUOTE_HEADERS) { + GString *buffer = g_string_new (""); + emfq_format_headers (emfq, buffer, (CamelMedium *) puri->part); + camel_stream_write_string (stream, buffer->str, cancellable, NULL); + g_string_free (buffer, TRUE); + } + + puri->write_func (emf, puri, stream, &info, cancellable); + } + + if (emfq->priv->flags & EM_FORMAT_QUOTE_CITE) + camel_stream_write_string ( + stream, "
", + cancellable, NULL); } static void -emfq_text_plain (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +emfq_write_text_plain (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) { EMFormatQuote *emfq = EM_FORMAT_QUOTE (emf); CamelStream *filtered_stream; CamelMimeFilter *html_filter; CamelMimeFilter *sig_strip; - CamelMimePart *mp; CamelContentType *type; const gchar *format; guint32 rgb = 0x737373, flags; - if (!part) + if (!puri->part) return; - mp = decode_inline_parts (part, cancellable); - if (mp) { - if (CAMEL_IS_MULTIPART (camel_medium_get_content (CAMEL_MEDIUM (mp)))) { - em_format_part (emf, stream, mp, cancellable); - g_object_unref (mp); - - return; - } - - g_object_unref (mp); - } - flags = emfq->priv->text_html_flags; /* Check for RFC 2646 flowed text. */ - type = camel_mime_part_get_content_type (part); + type = camel_mime_part_get_content_type (puri->part); if (camel_content_type_is(type, "text", "plain") && (format = camel_content_type_param(type, "format")) && !g_ascii_strcasecmp(format, "flowed")) @@ -687,25 +704,32 @@ emfq_text_plain (EMFormat *emf, em_format_format_text ( EM_FORMAT (emfq), filtered_stream, - CAMEL_DATA_WRAPPER (part), cancellable); + CAMEL_DATA_WRAPPER (puri->part), cancellable); camel_stream_flush (filtered_stream, cancellable, NULL); g_object_unref (filtered_stream); } static void -emfq_text_enriched (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +emfq_write_text_enriched (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) { CamelStream *filtered_stream; CamelMimeFilter *enriched; guint32 flags = 0; + CamelContentType *ct; + const gchar *mime_type = NULL; + + ct = camel_mime_part_get_content_type (puri->part); + if (ct) { + mime_type = camel_content_type_simple (ct); + camel_content_type_unref (ct); + } - if (g_strcmp0 (info->mime_type, "text/richtext") == 0) { + if (g_strcmp0 (mime_type, "text/richtext") == 0) { flags = CAMEL_MIME_FILTER_ENRICHED_IS_RICHTEXT; camel_stream_write_string ( stream, "\n\n", @@ -724,18 +748,17 @@ emfq_text_enriched (EMFormat *emf, camel_stream_write_string (stream, "

", cancellable, NULL); em_format_format_text ( - emf, filtered_stream, CAMEL_DATA_WRAPPER (part), cancellable); + emf, filtered_stream, CAMEL_DATA_WRAPPER (puri->part), cancellable); camel_stream_flush (filtered_stream, cancellable, NULL); g_object_unref (filtered_stream); } static void -emfq_text_html (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +emfq_write_text_html (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) { EMFormatQuotePrivate *priv; @@ -757,40 +780,29 @@ emfq_text_html (EMFormat *emf, em_format_format_text ( emf, filtered_stream, - (CamelDataWrapper *) part, cancellable); + (CamelDataWrapper *) puri->part, cancellable); camel_stream_flush (filtered_stream, cancellable, NULL); g_object_unref (filtered_stream); } else { em_format_format_text ( emf, stream, - (CamelDataWrapper *) part, cancellable); + (CamelDataWrapper *) puri->part, cancellable); } } -static void -emfq_ignore (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) -{ - /* NOOP */ -} - +/****************************************************************************/ static EMFormatHandler type_builtin_table[] = { - { (gchar *) "text/plain", emfq_text_plain }, - { (gchar *) "text/enriched", emfq_text_enriched }, - { (gchar *) "text/richtext", emfq_text_enriched }, - { (gchar *) "text/html", emfq_text_html }, - { (gchar *) "text/*", emfq_text_plain }, - { (gchar *) "message/external-body", emfq_ignore }, - { (gchar *) "multipart/appledouble", emfq_ignore }, + { (gchar *) "text/plain", emfq_parse_text_plain, emfq_write_text_plain, }, + { (gchar *) "text/enriched", emfq_parse_text_enriched, emfq_write_text_enriched, }, + { (gchar *) "text/richtext", emfq_parse_text_enriched, emfq_write_text_enriched, }, + { (gchar *) "text/html", emfq_parse_text_html, emfq_write_text_html, }, + { (gchar *) "text/*", emfq_parse_text_plain, emfq_write_text_plain, }, + { (gchar *) "message/external-body", em_format_empty_parser, em_format_empty_writer, }, + { (gchar *) "multipart/appledouble", em_format_empty_parser, em_format_empty_writer, }, /* internal evolution types */ - { (gchar *) "x-evolution/evolution-rss-feed", emfq_text_html }, - { (gchar *) "x-evolution/message/rfc822", emfq_format_message }, - { (gchar *) "x-evolution/message/prefix", emfq_format_message_prefix }, + { (gchar *) "x-evolution/evolution-rss-feed", 0, emfq_write_text_html, }, + { (gchar *) "x-evolution/message/attachment", emfq_parse_attachment, emfq_write_attachment, }, }; static void @@ -798,7 +810,9 @@ emfq_builtin_init (EMFormatQuoteClass *efhc) { gint ii; + EMFormatClass *emfc = (EMFormatClass *) efhc; + for (ii = 0; ii < G_N_ELEMENTS (type_builtin_table); ii++) em_format_class_add_handler ( - EM_FORMAT_CLASS (efhc), &type_builtin_table[ii]); + emfc, &type_builtin_table[ii]); } diff --git a/em-format/em-format-quote.h b/em-format/em-format-quote.h index 5c1882eb32..be3640735a 100644 --- a/em-format/em-format-quote.h +++ b/em-format/em-format-quote.h @@ -69,6 +69,9 @@ GType em_format_quote_get_type (void); EMFormatQuote * em_format_quote_new (const gchar *credits, CamelStream *stream, EMFormatQuoteFlags flags); +void em_format_quote_write (EMFormatQuote *emfq, + CamelStream *stream, + GCancellable *cancellable); G_END_DECLS diff --git a/em-format/em-format.c b/em-format/em-format.c index d476036f77..4abe35482c 100644 --- a/em-format/em-format.c +++ b/em-format/em-format.c @@ -25,1036 +25,1197 @@ #include #endif -#include #include - #include #include +#include #include "em-format.h" #include "e-util/e-util.h" #include "shell/e-shell.h" #include "shell/e-shell-settings.h" +#define d(x) + #define EM_FORMAT_GET_PRIVATE(obj) \ (G_TYPE_INSTANCE_GET_PRIVATE \ ((obj), EM_TYPE_FORMAT, EMFormatPrivate)) -#define d(x) - -typedef struct _EMFormatCache EMFormatCache; - struct _EMFormatPrivate { - guint redraw_idle_id; -}; - -/* Used to cache various data/info for redraws - * The validity stuff could be cached at a higher level but this is easier - * This absolutely relies on the partid being _globally unique_ - * This is still kind of yucky, we should maintain a full tree of all this data, - * along with/as part of the puri tree */ -struct _EMFormatCache { - CamelCipherValidity *valid; /* validity copy */ - CamelMimePart *secured; /* encrypted subpart */ + GNode *current_node; - guint state:2; /* inline state */ + CamelSession *session; - gchar partid[1]; -}; + CamelURL *base_url; -#define INLINE_UNSET (0) -#define INLINE_ON (1) -#define INLINE_OFF (2) + gchar *charset; + gchar *default_charset; + gboolean composer; -static void emf_builtin_init (EMFormatClass *); + gint last_error; +}; enum { - EMF_COMPLETE, - EMF_LAST_SIGNAL + PROP_0, + PROP_CHARSET, + PROP_DEFAULT_CHARSET, + PROP_COMPOSER, + PROP_BASE_URL }; -static gpointer parent_class; -static guint signals[EMF_LAST_SIGNAL]; - -static void -emf_free_cache (EMFormatCache *efc) -{ - if (efc->valid) - camel_cipher_validity_free (efc->valid); - if (efc->secured) - g_object_unref (efc->secured); - g_free (efc); -} - -static EMFormatCache * -emf_insert_cache (EMFormat *emf, - const gchar *partid) -{ - EMFormatCache *new; - - new = g_malloc0 (sizeof (*new) + strlen (partid)); - strcpy (new->partid, partid); - g_hash_table_insert (emf->inline_table, new->partid, new); +enum { + REDRAW_REQUESTED, + LAST_SIGNAL +}; - return new; -} +gint signals[LAST_SIGNAL]; -static void -emf_clone_inlines (gpointer key, - gpointer val, - gpointer data) -{ - EMFormatCache *emfc = val, *new; +static gpointer parent_class; - new = emf_insert_cache ((EMFormat *) data, emfc->partid); - new->state = emfc->state; - if (emfc->valid) - new->valid = camel_cipher_validity_clone (emfc->valid); - if (emfc->secured) - g_object_ref ((new->secured = emfc->secured)); -} +/* PARSERS */ +static void emf_parse_application_xpkcs7mime (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_application_mbox (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_alternative (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_appledouble (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_encrypted (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_mixed (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_signed (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_related (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_multipart_digest (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_message_deliverystatus (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_inlinepgp_signed (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_inlinepgp_encrypted (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_message (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_headers (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_post_headers (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); +static void emf_parse_source (EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable); + +/* WRITERS */ +static void emf_write_text (EMFormat *emf, EMFormatPURI *puri, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable); +static void emf_write_source (EMFormat *emf, EMFormatPURI *puri, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable); +static void emf_write_error (EMFormat *emf, EMFormatPURI *puri, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable); + +/**************************************************************************/ static gboolean -emf_clear_puri_node (GNode *node) +is_secured (CamelMimePart *part) { - GQueue *queue = node->data; - EMFormatPURI *pn; - - while ((pn = g_queue_pop_head (queue)) != NULL) { - if (pn->free != NULL) - pn->free (pn); - g_free (pn->uri); - g_free (pn->cid); - g_free (pn->part_id); - if (pn->part != NULL) - g_object_unref (pn->part); - g_free (pn); - } - - g_queue_free (queue); + CamelContentType *ct = camel_mime_part_get_content_type (part); - return FALSE; + return (camel_content_type_is (ct, "multipart", "signed") || + camel_content_type_is (ct, "multipart", "encrypted") || + camel_content_type_is (ct, "application", "x-inlinepgp-signed") || + camel_content_type_is (ct, "application", "x-inlinepgp-encrypted") || + camel_content_type_is (ct, "application", "x-pkcs7-mime") || + camel_content_type_is (ct, "application", "pkcs7-mime")); } static void -emf_finalize (GObject *object) +preserve_charset_in_content_type (CamelMimePart *ipart, + CamelMimePart *opart) { - EMFormat *emf = EM_FORMAT (object); - - if (emf->priv->redraw_idle_id > 0) - g_source_remove (emf->priv->redraw_idle_id); - - if (emf->session) - g_object_unref (emf->session); + CamelDataWrapper *data_wrapper; + CamelContentType *content_type; + const gchar *charset; - if (emf->message) - g_object_unref (emf->message); + g_return_if_fail (ipart != NULL); + g_return_if_fail (opart != NULL); - g_hash_table_destroy (emf->inline_table); + data_wrapper = camel_medium_get_content (CAMEL_MEDIUM (ipart)); + content_type = camel_data_wrapper_get_mime_type_field (data_wrapper); - em_format_clear_headers (emf); - camel_cipher_validity_free (emf->valid); - g_free (emf->charset); - g_free (emf->default_charset); - g_string_free (emf->part_id, TRUE); - g_free (emf->current_message_part_id); - g_free (emf->uid); + if (content_type == NULL) + return; - if (emf->pending_uri_table != NULL) - g_hash_table_destroy (emf->pending_uri_table); + charset = camel_content_type_param (content_type, "charset"); - if (emf->pending_uri_tree != NULL) { - g_node_traverse ( - emf->pending_uri_tree, - G_IN_ORDER, G_TRAVERSE_ALL, -1, - (GNodeTraverseFunc) emf_clear_puri_node, NULL); - g_node_destroy (emf->pending_uri_tree); - } + if (charset == NULL || *charset == '\0') + return; - /* FIXME: check pending jobs */ + data_wrapper = camel_medium_get_content (CAMEL_MEDIUM (opart)); + content_type = camel_data_wrapper_get_mime_type_field (data_wrapper); - /* Chain up to parent's finalize() method. */ - G_OBJECT_CLASS (parent_class)->finalize (object); + camel_content_type_set_param (content_type, "charset", charset); } -static const EMFormatHandler * -emf_find_handler (EMFormat *emf, - const gchar *mime_type) +static CamelMimePart * +get_related_display_part (CamelMimePart *part, + gint *out_displayid) { - EMFormatClass *emfc = (EMFormatClass *) G_OBJECT_GET_CLASS (emf); - - return g_hash_table_lookup (emfc->type_handlers, mime_type); -} + CamelMultipart *mp; + CamelMimePart *body_part, *display_part = NULL; + CamelContentType *content_type; + const gchar *start; + gint i, nparts, displayid = 0; -static void -emf_format_clone (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *msg, - EMFormat *emfsource, - GCancellable *cancellable) -{ - /* Cancel any pending redraws. */ - if (emf->priv->redraw_idle_id > 0) { - g_source_remove (emf->priv->redraw_idle_id); - emf->priv->redraw_idle_id = 0; - } + mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); - em_format_clear_puri_tree (emf); + if (!CAMEL_IS_MULTIPART (mp)) + return NULL; - if (emf != emfsource) { - g_hash_table_remove_all (emf->inline_table); - if (emfsource) { - GList *link; + nparts = camel_multipart_get_number (mp); + content_type = camel_mime_part_get_content_type (part); + start = camel_content_type_param (content_type, "start"); + if (start && strlen (start) > 2) { + gint len; + const gchar *cid; - /* We clone the current state here */ - g_hash_table_foreach (emfsource->inline_table, emf_clone_inlines, emf); - emf->mode = emfsource->mode; - g_free (emf->charset); - emf->charset = g_strdup (emfsource->charset); - g_free (emf->default_charset); - emf->default_charset = g_strdup (emfsource->default_charset); + /* strip <>'s from CID */ + len = strlen (start) - 2; + start++; - em_format_clear_headers (emf); + for (i = 0; i < nparts; i++) { + body_part = camel_multipart_get_part (mp, i); + cid = camel_mime_part_get_content_id (body_part); - link = g_queue_peek_head_link (&emfsource->header_list); - while (link != NULL) { - struct _EMFormatHeader *h = link->data; - em_format_add_header (emf, h->name, h->flags); - link = g_list_next (link); + if (cid && !strncmp (cid, start, len) && strlen (cid) == len) { + display_part = body_part; + displayid = i; + break; } } + } else { + display_part = camel_multipart_get_part (mp, 0); } - /* what a mess */ - if (folder != emf->folder) { - if (emf->folder) - g_object_unref (emf->folder); - if (folder) - g_object_ref (folder); - emf->folder = folder; - } - - if (uid != emf->uid) { - g_free (emf->uid); - emf->uid = g_strdup (uid); - } - - if (msg != emf->message) { - if (emf->message) - g_object_unref (emf->message); - if (msg) - g_object_ref (msg); - emf->message = msg; - } + if (out_displayid) + *out_displayid = displayid; - g_free (emf->current_message_part_id); - emf->current_message_part_id = g_strdup ("root-message"); - g_string_truncate (emf->part_id, 0); - if (folder != NULL) - /* TODO build some string based on the folder name/location? */ - g_string_append_printf(emf->part_id, ".%p", (gpointer) folder); - if (uid != NULL) - g_string_append_printf(emf->part_id, ".%s", uid); + return display_part; } -static void -emf_format_secure (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - CamelCipherValidity *valid, - GCancellable *cancellable) +static gboolean +related_display_part_is_attachment (EMFormat *emf, + CamelMimePart *part) { - CamelCipherValidity *save = emf->valid_parent; - gint len; - - /* Note that this also requires support from higher up in the class chain - * - validity needs to be cleared when you start output - * - also needs to be cleared (but saved) whenever you start a new message. */ - - if (emf->valid == NULL) { - emf->valid = valid; - } else { - g_queue_push_tail (&emf->valid_parent->children, valid); - camel_cipher_validity_envelope (emf->valid_parent, valid); - } - - emf->valid_parent = valid; - - len = emf->part_id->len; - g_string_append_printf(emf->part_id, ".secured"); - em_format_part (emf, stream, part, cancellable); - g_string_truncate (emf->part_id, len); + CamelMimePart *display_part; - emf->valid_parent = save; + display_part = get_related_display_part (part, NULL); + return display_part && em_format_is_attachment (emf, display_part); } -static gboolean -emf_busy (EMFormat *emf) +/**************************************************************************/ +void +em_format_empty_parser (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - return FALSE; + /* DO NOTHING */ } -static gboolean -emf_is_inline (EMFormat *emf, - const gchar *part_id, - CamelMimePart *mime_part, - const EMFormatHandler *handle) +#ifdef ENABLE_SMIME +static void +emf_parse_application_xpkcs7mime (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - EMFormatCache *emfc; - const gchar *disposition; + CamelCipherContext *context; + CamelMimePart *opart; + CamelCipherValidity *valid; + GError *local_error = NULL; - if (handle == NULL) - return FALSE; + if (g_cancellable_is_cancelled (cancellable)) + return; - emfc = g_hash_table_lookup (emf->inline_table, part_id); - if (emfc && emfc->state != INLINE_UNSET) - return emfc->state & 1; + context = camel_smime_context_new (emf->priv->session); - /* Some types need to override the disposition. - * e.g. application/x-pkcs7-mime */ - if (handle->flags & EM_FORMAT_HANDLER_INLINE_DISPOSITION) - return TRUE; + opart = camel_mime_part_new (); + valid = camel_cipher_context_decrypt_sync ( + context, part, opart, cancellable, &local_error); + preserve_charset_in_content_type (part, opart); + if (valid == NULL) { + em_format_format_error ( + emf, "%s", + local_error->message ? local_error->message : + _("Could not parse S/MIME message: Unknown error")); + g_clear_error (&local_error); + } else { + EMFormatParserInfo encinfo = { + info->handler, + info->validity_type | EM_FORMAT_VALIDITY_FOUND_ENCRYPTED | EM_FORMAT_VALIDITY_FOUND_SMIME, + valid + }; + gint len = part_id->len; + + g_string_append (part_id, ".encrypted"); + em_format_parse_part (emf, opart, part_id, &encinfo, cancellable); + g_string_truncate (part_id, len); + + /* Add a widget with details about the encryption, but only when + * the encrypted isn't itself secured, in that case it has created + * the button itself */ + if (!is_secured (opart)) { + g_string_append (part_id, ".encrypted.button"); + em_format_parse_part_as (emf, part, part_id, &encinfo, + "x-evolution/message/x-secure-button", cancellable); + g_string_truncate (part_id, len); + } - disposition = camel_mime_part_get_disposition (mime_part); - if (disposition != NULL) - return g_ascii_strcasecmp (disposition, "inline") == 0; + camel_cipher_validity_free (valid); + } - /* Otherwise, use the default for this handler type. */ - return (handle->flags & EM_FORMAT_HANDLER_INLINE) != 0; + g_object_unref (opart); + g_object_unref (context); } +#endif +/* RFC 4155 */ static void -emf_base_init (EMFormatClass *class) +emf_parse_application_mbox (EMFormat *emf, + CamelMimePart *mime_part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - class->type_handlers = g_hash_table_new (g_str_hash, g_str_equal); - emf_builtin_init (class); -} + CamelMimeParser *parser; + CamelStream *mem_stream; + camel_mime_parser_state_t state; + gint old_len; + gint messages; -static void -emf_class_init (EMFormatClass *class) -{ - GObjectClass *object_class; + if (g_cancellable_is_cancelled (cancellable)) + return; - parent_class = g_type_class_peek_parent (class); - g_type_class_add_private (class, sizeof (EMFormatPrivate)); + /* Extract messages from the application/mbox part and + * render them as a flat list of messages. */ - object_class = G_OBJECT_CLASS (class); - object_class->finalize = emf_finalize; + /* XXX If the mbox has multiple messages, maybe render them + * as a multipart/digest so each message can be expanded + * or collapsed individually. + * + * See attachment_handler_mail_x_uid_list() for example. */ - class->find_handler = emf_find_handler; - class->format_clone = emf_format_clone; - class->format_secure = emf_format_secure; - class->busy = emf_busy; - class->is_inline = emf_is_inline; + /* XXX This is based on em_utils_read_messages_from_stream(). + * Perhaps refactor that function to return an array of + * messages instead of assuming we want to append them + * to a folder? */ - signals[EMF_COMPLETE] = g_signal_new ( - "complete", - G_OBJECT_CLASS_TYPE (class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (EMFormatClass, complete), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); -} + parser = camel_mime_parser_new (); + camel_mime_parser_scan_from (parser, TRUE); -static void -emf_init (EMFormat *emf) -{ - EShell *shell; - EShellSettings *shell_settings; + mem_stream = camel_stream_mem_new (); + camel_data_wrapper_decode_to_stream_sync ( + camel_medium_get_content (CAMEL_MEDIUM (mime_part)), + mem_stream, NULL, NULL); + g_seekable_seek (G_SEEKABLE (mem_stream), 0, G_SEEK_SET, NULL, NULL); + camel_mime_parser_init_with_stream (parser, mem_stream, NULL); + g_object_unref (mem_stream); - emf->priv = EM_FORMAT_GET_PRIVATE (emf); + old_len = part_id->len; - emf->inline_table = g_hash_table_new_full ( - g_str_hash, g_str_equal, - (GDestroyNotify) NULL, - (GDestroyNotify) emf_free_cache); - emf->composer = FALSE; - emf->print = FALSE; - g_queue_init (&emf->header_list); - em_format_default_headers (emf); - emf->part_id = g_string_new(""); - emf->current_message_part_id = NULL; - emf->validity_found = 0; + /* Extract messages from the mbox. */ + messages = 0; + state = camel_mime_parser_step (parser, NULL, NULL); - shell = e_shell_get_default (); - shell_settings = e_shell_get_shell_settings (shell); + while (state == CAMEL_MIME_PARSER_STATE_FROM) { + CamelMimeMessage *message; - emf->session = e_shell_settings_get_pointer (shell_settings, "mail-session"); - g_return_if_fail (emf->session != NULL); + message = camel_mime_message_new (); + mime_part = CAMEL_MIME_PART (message); - g_object_ref (emf->session); -} + if (!camel_mime_part_construct_from_parser_sync ( + mime_part, parser, NULL, NULL)) { + g_object_unref (message); + break; + } -GType -em_format_get_type (void) -{ - static GType type = 0; + g_string_append_printf (part_id, ".mbox.%d", messages); + em_format_parse_part_as (emf, CAMEL_MIME_PART (message), + part_id, info, "message/rfc822", cancellable); + g_string_truncate (part_id, old_len); - if (G_UNLIKELY (type == 0)) { - static const GTypeInfo type_info = { - sizeof (EMFormatClass), - (GBaseInitFunc) emf_base_init, - (GBaseFinalizeFunc) NULL, - (GClassInitFunc) emf_class_init, - (GClassFinalizeFunc) NULL, - NULL, /* class_data */ - sizeof (EMFormat), - 0, /* n_preallocs */ - (GInstanceInitFunc) emf_init, - NULL /* value_table */ - }; + g_object_unref (message); - type = g_type_register_static ( - G_TYPE_OBJECT, "EMFormat", &type_info, 0); + /* Skip past CAMEL_MIME_PARSER_STATE_FROM_END. */ + camel_mime_parser_step (parser, NULL, NULL); + + state = camel_mime_parser_step (parser, NULL, NULL); + + messages++; } - return type; + g_object_unref (parser); } -/** - * em_format_class_add_handler: - * @emfc: EMFormatClass - * @info: Callback information. - * - * Add a mime type handler to this class. This is only used by - * implementing classes. The @info.old pointer will automatically be - * setup to point to the old handler if one was already set. This can - * be used for overrides a fallback. - * - * When a mime type described by @info is encountered, the callback will - * be invoked. Note that @info may be extended by sub-classes if - * they require additional context information. - * - * Use a mime type of "foo/ *" to insert a fallback handler for type "foo". - **/ -void -em_format_class_add_handler (EMFormatClass *emfc, - EMFormatHandler *info) +/* RFC 1740 */ +static void +emf_parse_multipart_alternative (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - info->old = g_hash_table_lookup (emfc->type_handlers, info->mime_type); - g_hash_table_insert (emfc->type_handlers, (gpointer) info->mime_type, info); -} + CamelMultipart *mp; + gint i, nparts, bestid = 0; + CamelMimePart *best = NULL; -struct _class_handlers { - EMFormatClass *old; - EMFormatClass *new; -}; + if (g_cancellable_is_cancelled (cancellable)) + return; -static void -merge_missing (gpointer key, - gpointer value, - gpointer userdata) -{ - struct _class_handlers *classes = (struct _class_handlers *) userdata; - EMFormatHandler *info; + mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); - info = g_hash_table_lookup (classes->new->type_handlers, key); - if (!info) { - /* Might be from a plugin */ - g_hash_table_insert (classes->new->type_handlers, key, value); + if (!CAMEL_IS_MULTIPART (mp)) { + emf_parse_source (emf, part, part_id, info, cancellable); + return; } -} + /* as per rfc, find the last part we know how to display */ + nparts = camel_multipart_get_number (mp); + for (i = 0; i < nparts; i++) { + CamelMimePart *mpart; + CamelDataWrapper *data_wrapper; + CamelContentType *type; + CamelStream *null_stream; + gchar *mime_type; + gsize content_size; -void -em_format_merge_handler (EMFormat *new, - EMFormat *old) -{ - EMFormatClass *oldc = (EMFormatClass *) G_OBJECT_GET_CLASS (old); - EMFormatClass *newc = (EMFormatClass *) G_OBJECT_GET_CLASS (new); - struct _class_handlers fclasses; + if (g_cancellable_is_cancelled (cancellable)) + return; - fclasses.old = oldc; - fclasses.new = newc; + /* is it correct to use the passed in *part here? */ + mpart = camel_multipart_get_part (mp, i); - g_hash_table_foreach (oldc->type_handlers, merge_missing, &fclasses); + if (mpart == NULL) + continue; -} + /* This may block even though the stream does not. + * XXX Pretty inefficient way to test if the MIME part + * is empty. Surely there's a quicker way? */ + null_stream = camel_stream_null_new (); + data_wrapper = camel_medium_get_content (CAMEL_MEDIUM (mpart)); + camel_data_wrapper_decode_to_stream_sync ( + data_wrapper, null_stream, cancellable, NULL); + content_size = CAMEL_STREAM_NULL (null_stream)->written; + g_object_unref (null_stream); -/** - * em_format_class_remove_handler: - * @emfc: - * @info: - * - * Remove a handler. @info must be a value which was previously - * added. - **/ -void -em_format_class_remove_handler (EMFormatClass *emfc, - EMFormatHandler *info) -{ - EMFormatHandler *current; + if (content_size == 0) + continue; - /* TODO: thread issues? */ + type = camel_mime_part_get_content_type (mpart); + mime_type = camel_content_type_simple (type); - current = g_hash_table_lookup (emfc->type_handlers, info->mime_type); - if (current == info) { - current = info->old; - if (current) - g_hash_table_insert ( - emfc->type_handlers, - (gpointer) current->mime_type, current); - else - g_hash_table_remove ( - emfc->type_handlers, info->mime_type); - } else { - while (current && current->old != info) - current = current->old; - g_return_if_fail (current != NULL); - current->old = info->old; - } -} + camel_strdown (mime_type); -/** - * em_format_find_handler: - * @emf: - * @mime_type: - * - * Find a format handler by @mime_type. - * - * Return value: NULL if no handler is available. - **/ -const EMFormatHandler * -em_format_find_handler (EMFormat *emf, - const gchar *mime_type) -{ - EMFormatClass *class; + if (!em_format_is_attachment (emf, mpart) && + ((camel_content_type_is (type, "multipart", "related") == 0) || + !related_display_part_is_attachment (emf, mpart)) && + (em_format_find_handler (emf, mime_type) + || (best == NULL && em_format_fallback_handler (emf, mime_type)))) { + best = mpart; + bestid = i; + } - g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); - g_return_val_if_fail (mime_type != NULL, NULL); + g_free (mime_type); + } - class = EM_FORMAT_GET_CLASS (emf); - g_return_val_if_fail (class->find_handler != NULL, NULL); + if (best) { + gint len = part_id->len; - return class->find_handler (emf, mime_type); + g_string_append_printf(part_id, ".alternative.%d", bestid); + em_format_parse_part (emf, best, part_id, info, cancellable); + g_string_truncate (part_id, len); + } else + emf_parse_multipart_mixed (emf, part, part_id, info, cancellable); } -/** - * em_format_fallback_handler: - * @emf: - * @mime_type: - * - * Try to find a format handler based on the major type of the @mime_type. - * - * The subtype is replaced with "*" and a lookup performed. - * - * Return value: - **/ -const EMFormatHandler * -em_format_fallback_handler (EMFormat *emf, - const gchar *mime_type) +/* RFC 1740 */ +static void +emf_parse_multipart_appledouble (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - gchar *mime, *s; + CamelMultipart *mp; + CamelMimePart *mime_part; - s = strchr (mime_type, '/'); - if (s == NULL) - mime = (gchar *) mime_type; - else { - gsize len = (s - mime_type) + 1; + if (g_cancellable_is_cancelled (cancellable)) + return; - mime = g_alloca (len + 2); - strncpy (mime, mime_type, len); - strcpy(mime+len, "*"); + mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); + + if (!CAMEL_IS_MULTIPART (mp)) { + emf_parse_source (emf, part, part_id, info, cancellable); + return; } - return em_format_find_handler (emf, mime); + mime_part = camel_multipart_get_part (mp, 1); + if (mime_part) { + gint len; + /* try the data fork for something useful, doubtful but who knows */ + len = part_id->len; + g_string_append_printf(part_id, ".appledouble.1"); + em_format_parse_part (emf, mime_part, part_id, info, cancellable); + g_string_truncate (part_id, len); + } else { + emf_parse_source (emf, part, part_id, info, cancellable); + } } -/** - * em_format_add_puri: - * @emf: - * @size: - * @cid: Override the autogenerated content id. - * @part: - * @func: - * - * Add a pending-uri handler. When formatting parts that reference - * other parts, a pending-uri (PURI) can be used to track the reference. - * - * @size is used to allocate the structure, so that it can be directly - * subclassed by implementors. - * - * @cid can be used to override the key used to retreive the PURI, if NULL, - * then the content-location and the content-id of the @part are stored - * as lookup keys for the part. - * - * FIXME: This may need a free callback. - * - * Return value: A new PURI, with a referenced copy of @part, and the cid - * always set. The uri will be set if one is available. Clashes - * are resolved by forgetting the old PURI in the global index. - **/ -EMFormatPURI * -em_format_add_puri (EMFormat *emf, - gsize size, - const gchar *cid, - CamelMimePart *part, - EMFormatPURIFunc func) +static void +emf_parse_multipart_encrypted (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - EMFormatPURI *puri; - const gchar *tmp; + CamelCipherContext *context; + const gchar *protocol; + CamelMimePart *opart; + CamelCipherValidity *valid; + CamelMultipartEncrypted *mpe; + GError *local_error = NULL; - d(printf("adding puri for part: %s\n", emf->part_id->str)); + if (g_cancellable_is_cancelled (cancellable)) + return; - if (size < sizeof (*puri)) { - g_warning ( - "size (%" G_GSIZE_FORMAT - ") less than size of puri\n", size); - size = sizeof (*puri); + mpe = (CamelMultipartEncrypted *) camel_medium_get_content ((CamelMedium *) part); + if (!CAMEL_IS_MULTIPART_ENCRYPTED (mpe)) { + em_format_format_error ( + emf, _("Could not parse MIME message. " + "Displaying as source.")); + emf_parse_source (emf, part, part_id, info, cancellable); + return; } - puri = g_malloc0 (size); - - puri->format = emf; - puri->func = func; - puri->use_count = 0; - puri->cid = g_strdup (cid); - puri->part_id = g_strdup (emf->part_id->str); - - if (part) { - g_object_ref (part); - puri->part = part; + /* Currently we only handle RFC2015-style PGP encryption. */ + protocol = camel_content_type_param ( + ((CamelDataWrapper *)mpe)->mime_type, "protocol"); + if (!protocol || g_ascii_strcasecmp (protocol, "application/pgp-encrypted") != 0) { + em_format_format_error (emf, _("Unsupported encryption type for multipart/encrypted")); + emf_parse_multipart_mixed (emf, part, part_id, info, cancellable); + return; } - if (part != NULL && cid == NULL) { - tmp = camel_mime_part_get_content_id (part); - if (tmp) - puri->cid = g_strdup_printf("cid:%s", tmp); - else - puri->cid = g_strdup_printf("em-no-cid:%s", emf->part_id->str); + context = camel_gpg_context_new (emf->priv->session); + opart = camel_mime_part_new (); + valid = camel_cipher_context_decrypt_sync ( + context, part, opart, cancellable, &local_error); + preserve_charset_in_content_type (part, opart); + if (valid == NULL) { + em_format_format_error ( + emf, local_error->message ? + _("Could not parse PGP/MIME message") : + _("Could not parse PGP/MIME message: Unknown error")); + if (local_error->message != NULL) + em_format_format_error ( + emf, "%s", local_error->message); + g_clear_error (&local_error); + emf_parse_multipart_mixed (emf, part, part_id, info, cancellable); + } else { + gint len = part_id->len; - d(printf("built cid '%s'\n", puri->cid)); + EMFormatParserInfo encinfo = { + info->handler, + info->validity_type | EM_FORMAT_VALIDITY_FOUND_ENCRYPTED | EM_FORMAT_VALIDITY_FOUND_PGP, + }; - /* Not quite same as old behaviour, it also put in the - * relative uri and a fallback for no parent uri. */ - tmp = camel_mime_part_get_content_location (part); - puri->uri = NULL; - if (tmp == NULL) { - /* No location, don't set a uri at all, - * html parts do this themselves. */ - } else { - if (strchr (tmp, ':') == NULL && emf->base != NULL) { - CamelURL *uri; - - uri = camel_url_new_with_base (emf->base, tmp); - puri->uri = camel_url_to_string (uri, 0); - camel_url_free (uri); - } else { - puri->uri = g_strdup (tmp); - } - } - } + if (info->validity) + camel_cipher_validity_envelope (valid, info->validity); - g_return_val_if_fail (puri->cid != NULL, NULL); - g_return_val_if_fail (emf->pending_uri_level != NULL, NULL); - g_return_val_if_fail (emf->pending_uri_table != NULL, NULL); + encinfo.validity = valid; - g_queue_push_tail (emf->pending_uri_level->data, puri); + g_string_append (part_id, ".encrypted"); + em_format_parse_part (emf, opart, part_id, &encinfo, cancellable); + g_string_truncate (part_id, len); - if (puri->uri) - g_hash_table_insert (emf->pending_uri_table, puri->uri, puri); - g_hash_table_insert (emf->pending_uri_table, puri->cid, puri); + /* Add a widget with details about the encryption, but only when + * the encrypted isn't itself secured, in that case it has created + * the button itself */ + if (!is_secured (opart)) { + g_string_append (part_id, ".encrypted.button"); + em_format_parse_part_as (emf, part, part_id, &encinfo, + "x-evolution/message/x-secure-button", cancellable); + g_string_truncate (part_id, len); + } - return puri; + camel_cipher_validity_free (valid); + } + + /* TODO: Make sure when we finalize this part, it is zero'd out */ + g_object_unref (opart); + g_object_unref (context); } -/** - * em_format_push_level: - * @emf: - * - * This is used to build a hierarchy of visible PURI objects based on - * the structure of the message. Used by multipart/alternative formatter. - * - * FIXME: This could probably also take a uri so it can automatically update - * the base location. - **/ -void -em_format_push_level (EMFormat *emf) +/* RFC 2046 */ +static void +emf_parse_multipart_mixed (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - GNode *node; + CamelMultipart *mp; + gint i, nparts, len; - g_return_if_fail (EM_IS_FORMAT (emf)); + if (g_cancellable_is_cancelled (cancellable)) + return; - node = g_node_new (g_queue_new ()); + mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); - if (emf->pending_uri_tree == NULL) - emf->pending_uri_tree = node; - else - g_node_append (emf->pending_uri_tree, node); + if (!CAMEL_IS_MULTIPART (mp)) { + emf_parse_source (emf, part, part_id, info, cancellable); + return; + } - emf->pending_uri_level = node; -} + len = part_id->len; + nparts = camel_multipart_get_number (mp); + for (i = 0; i < nparts; i++) { + CamelMimePart *subpart; -/** - * em_format_pull_level: - * @emf: - * - * Drop a level of visibility back to the parent. Note that - * no PURI values are actually freed. - **/ -void -em_format_pull_level (EMFormat *emf) -{ - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (emf->pending_uri_level != NULL); + subpart = camel_multipart_get_part (mp, i); - emf->pending_uri_level = emf->pending_uri_level->parent; + g_string_append_printf(part_id, ".mixed.%d", i); + em_format_parse_part (emf, subpart, part_id, info, cancellable); + g_string_truncate (part_id, len); + } } -/** - * em_format_find_visible_puri: - * @emf: - * @uri: - * - * Search for a PURI based on the visibility defined by :push_level() - * and :pull_level(). - * - * Return value: - **/ -EMFormatPURI * -em_format_find_visible_puri (EMFormat *emf, - const gchar *uri) +static void +emf_parse_multipart_signed (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - GNode *node; - - g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); - g_return_val_if_fail (uri != NULL, NULL); + CamelMimePart *cpart; + CamelMultipartSigned *mps; + CamelCipherContext *cipher = NULL; + guint32 validity_type; - node = emf->pending_uri_level; + if (g_cancellable_is_cancelled (cancellable)) + return; - while (node != NULL) { - GQueue *queue = node->data; - GList *link; + mps = (CamelMultipartSigned *) camel_medium_get_content ((CamelMedium *) part); + if (!CAMEL_IS_MULTIPART_SIGNED (mps) + || (cpart = camel_multipart_get_part ((CamelMultipart *) mps, + CAMEL_MULTIPART_SIGNED_CONTENT)) == NULL) { + em_format_format_error ( + emf, _("Could not parse MIME message. " + "Displaying as source.")); + emf_parse_source (emf, part, part_id, info, cancellable); + return; + } - link = g_queue_peek_head_link (queue); + /* FIXME: Should be done via a plugin interface */ + /* FIXME: duplicated in em-format-html-display.c */ + if (mps->protocol) { +#ifdef ENABLE_SMIME + if (g_ascii_strcasecmp("application/x-pkcs7-signature", mps->protocol) == 0 + || g_ascii_strcasecmp("application/pkcs7-signature", mps->protocol) == 0) { + cipher = camel_smime_context_new (emf->priv->session); + validity_type = EM_FORMAT_VALIDITY_FOUND_SMIME; + } else +#endif + if (g_ascii_strcasecmp("application/pgp-signature", mps->protocol) == 0) { + cipher = camel_gpg_context_new (emf->priv->session); + validity_type = EM_FORMAT_VALIDITY_FOUND_PGP; + } + } - while (link != NULL) { - EMFormatPURI *pw = link->data; + if (cipher == NULL) { + em_format_format_error(emf, _("Unsupported signature format")); + emf_parse_multipart_mixed (emf, part, part_id, info, cancellable); + } else { + CamelCipherValidity *valid; + GError *local_error = NULL; - if (g_strcmp0 (pw->uri, uri) == 0) - return pw; + valid = camel_cipher_context_verify_sync ( + cipher, part, cancellable, &local_error); + if (valid == NULL) { + em_format_format_error ( + emf, local_error->message ? + _("Error verifying signature") : + _("Unknown error verifying signature")); + if (local_error->message != NULL) + em_format_format_error ( + emf, "%s", + local_error->message); + g_clear_error (&local_error); + emf_parse_multipart_mixed (emf, part, part_id,info, cancellable); + } else { + gint i, nparts, len = part_id->len; + gboolean secured; + + EMFormatParserInfo signinfo = { + info->handler, + info->validity_type | validity_type | EM_FORMAT_VALIDITY_FOUND_SIGNED, + }; + + if (info->validity) + camel_cipher_validity_envelope (valid, info->validity); + signinfo.validity = valid; + + nparts = camel_multipart_get_number (CAMEL_MULTIPART (mps)); + secured = FALSE; + for (i = 0; i < nparts; i++) { + CamelMimePart *subpart; + subpart = camel_multipart_get_part (CAMEL_MULTIPART (mps), i); + + g_string_append_printf(part_id, ".signed.%d", i); + em_format_parse_part (emf, subpart, part_id, &signinfo, cancellable); + g_string_truncate (part_id, len); + + if (!secured) + secured = is_secured (subpart); + } - if (g_strcmp0 (pw->cid, uri) == 0) - return pw; + /* Add a widget with details about the encryption, but only when + * the encrypted isn't itself secured, in that case it has created + * the button itself */ + if (!secured) { + g_string_append (part_id, ".signed.button"); + em_format_parse_part_as (emf, part, part_id, &signinfo, + "x-evolution/message/x-secure-button", cancellable); + g_string_truncate (part_id, len); + } - link = g_list_next (link); + camel_cipher_validity_free (valid); } - - node = node->parent; } - return NULL; -} - -/** - * em_format_find_puri: - * @emf: - * @uri: - * - * Search for a PURI based on a uri. Both the content-id - * and content-location are checked. - * - * Return value: - **/ -EMFormatPURI * -em_format_find_puri (EMFormat *emf, - const gchar *uri) -{ - g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); - g_return_val_if_fail (uri != NULL, NULL); - - g_return_val_if_fail (emf->pending_uri_table != NULL, NULL); - - return g_hash_table_lookup (emf->pending_uri_table, uri); + g_object_unref (cipher); } -/** - * em_format_clear_puri_tree: - * @emf: - * - * For use by implementors to clear out the message structure - * data. - **/ -void -em_format_clear_puri_tree (EMFormat *emf) +/* RFC 2046 */ +static void +emf_parse_multipart_digest (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - if (emf->pending_uri_table == NULL) - emf->pending_uri_table = - g_hash_table_new (g_str_hash, g_str_equal); + CamelMultipart *mp; + gint i, nparts, len; - else { - g_hash_table_remove_all (emf->pending_uri_table); + if (g_cancellable_is_cancelled (cancellable)) + return; - g_node_traverse ( - emf->pending_uri_tree, - G_IN_ORDER, G_TRAVERSE_ALL, -1, - (GNodeTraverseFunc) emf_clear_puri_node, NULL); - g_node_destroy (emf->pending_uri_tree); + mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); - emf->pending_uri_tree = NULL; - emf->pending_uri_level = NULL; + if (!CAMEL_IS_MULTIPART (mp)) { + emf_parse_source (emf, part, part_id, info, cancellable); + return; } - em_format_push_level (emf); -} + len = part_id->len; + nparts = camel_multipart_get_number (mp); + for (i = 0; i < nparts; i++) { + CamelMimePart *subpart; + CamelContentType *ct; + gchar *cts; + const EMFormatHandler *handler; -/* use mime_type == NULL to force showing as application/octet-stream */ -void -em_format_part_as (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const gchar *mime_type, - GCancellable *cancellable) -{ - const EMFormatHandler *handle = NULL; - const gchar *snoop_save = emf->snoop_mime_type, *tmp; - CamelURL *base_save = emf->base, *base = NULL; - gchar *basestr = NULL; + subpart = camel_multipart_get_part (mp, i); - d(printf("format_part_as()\n")); + if (!subpart) + continue; - emf->snoop_mime_type = NULL; + g_string_append_printf(part_id, ".digest.%d", i); - /* RFC 2110, we keep track of content-base, and absolute content-location headers - * This is actually only required for html, but, *shrug * */ - tmp = camel_medium_get_header((CamelMedium *)part, "Content-Base"); - if (tmp == NULL) { - tmp = camel_mime_part_get_content_location (part); - if (tmp && strchr (tmp, ':') == NULL) - tmp = NULL; - } else { - tmp = basestr = camel_header_location_decode (tmp); - } - d(printf("content-base is '%s'\n", tmp?tmp:"")); - if (tmp - && (base = camel_url_new (tmp, NULL))) { - emf->base = base; - d(printf("Setting content base '%s'\n", tmp)); - } - g_free (basestr); - - if (mime_type != NULL) { - gboolean is_fallback = FALSE; - if (g_ascii_strcasecmp(mime_type, "application/octet-stream") == 0) { - emf->snoop_mime_type = mime_type = em_format_snoop_type (part); - if (mime_type == NULL) - mime_type = "application/octet-stream"; + ct = camel_mime_part_get_content_type (subpart); + /* According to RFC this shouldn't happen, but who knows... */ + if (ct && !camel_content_type_is (ct, "message", "rfc822")) { + cts = camel_content_type_simple (ct); + em_format_parse_part_as (emf, part, part_id, info, cts, cancellable); + g_free (cts); + g_string_truncate (part_id, len); + continue; } - handle = em_format_find_handler (emf, mime_type); - if (handle == NULL) { - handle = em_format_fallback_handler (emf, mime_type); - is_fallback = TRUE; - } + handler = em_format_find_handler (emf, "message/rfc822"); + if (handler && handler->parse_func) + handler->parse_func (emf, subpart, part_id, info, cancellable); - if (handle != NULL - && !em_format_is_attachment (emf, part)) { - d(printf("running handler for type '%s'\n", mime_type)); - handle->handler ( - emf, stream, part, handle, - cancellable, is_fallback); - goto finish; - } - d(printf("this type is an attachment? '%s'\n", mime_type)); - } else { - mime_type = "application/octet-stream"; + g_string_truncate (part_id, len); } +} - EM_FORMAT_GET_CLASS (emf)->format_attachment ( - emf, stream, part, mime_type, handle, cancellable); +/* RFC 2387 */ +static void +emf_parse_multipart_related (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) +{ + CamelMultipart *mp; + CamelMimePart *body_part, *display_part = NULL; + gint i, nparts, partidlen, displayid = 0; + + if (g_cancellable_is_cancelled (cancellable)) + return; + + mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); + + if (!CAMEL_IS_MULTIPART (mp)) { + emf_parse_source (emf, part, part_id, info, cancellable); + return; + } + + display_part = get_related_display_part (part, &displayid); + + if (display_part == NULL) { + emf_parse_multipart_mixed ( + emf, part, part_id, info, cancellable); + return; + } -finish: - emf->base = base_save; - emf->snoop_mime_type = snoop_save; + /* The to-be-displayed part goes first */ + partidlen = part_id->len; + g_string_append_printf(part_id, ".related.%d", displayid); + em_format_parse_part (emf, display_part, part_id, info, cancellable); + g_string_truncate (part_id, partidlen); - if (base) - camel_url_free (base); + /* Process the related parts */ + nparts = camel_multipart_get_number (mp); + for (i = 0; i < nparts; i++) { + body_part = camel_multipart_get_part (mp, i); + if (body_part != display_part) { + g_string_append_printf(part_id, ".related.%d", i); + em_format_parse_part (emf, body_part, part_id, info, cancellable); + g_string_truncate (part_id, partidlen); + } + } } -void -em_format_part (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - GCancellable *cancellable) +static void +emf_parse_message_deliverystatus (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - gchar *mime_type; - CamelDataWrapper *dw; + EMFormatPURI *puri; + gint len; - dw = camel_medium_get_content (CAMEL_MEDIUM (mime_part)); - mime_type = camel_data_wrapper_get_mime_type (dw); - if (mime_type != NULL) { - camel_strdown (mime_type); - em_format_part_as ( - emf, stream, mime_part, mime_type, cancellable); - g_free (mime_type); - } else - em_format_part_as ( - emf, stream, mime_part, "text/plain", cancellable); + if (g_cancellable_is_cancelled (cancellable)) + return; + + len = part_id->len; + g_string_append (part_id, ".deliverystatus"); + + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = emf_write_text; + puri->mime_type = g_strdup ("text/html"); + puri->validity = info->validity ? camel_cipher_validity_clone (info->validity) : NULL; + puri->validity_type = info->validity_type; + + g_string_truncate (part_id, len); + + em_format_add_puri (emf, puri); } -/** - * em_format_format_clone: - * @emf: an #EMFormat - * @folder: a #CamelFolder or %NULL - * @uid: Message UID or %NULL - * @msg: a #CamelMimeMessage or %NULL - * @emfsource: Used as a basis for user-altered layout, e.g. inline viewed - * attachments. - * @cancellable: a #GCancellable, or %NULL - * - * Format a message @msg. If @emfsource is non NULL, then the status of - * inlined expansion and so forth is copied direction from @emfsource. - * - * By passing the same value for @emf and @emfsource, you can perform - * a display refresh, or it can be used to generate an identical layout, - * e.g. to print what the user has shown inline. - **/ -void -em_format_format_clone (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *message, - EMFormat *source, - GCancellable *cancellable) +static void +emf_parse_inlinepgp_signed (EMFormat *emf, + CamelMimePart *ipart, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - EMFormatClass *class; + CamelStream *filtered_stream; + CamelMimeFilterPgp *pgp_filter; + CamelContentType *content_type; + CamelCipherContext *cipher; + CamelCipherValidity *valid; + CamelDataWrapper *dw; + CamelMimePart *opart; + CamelStream *ostream; + gchar *type; + gint len; + GError *local_error = NULL; + EMFormatParserInfo signinfo; + GByteArray *ba; - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (folder == NULL || CAMEL_IS_FOLDER (folder)); - g_return_if_fail (message == NULL || CAMEL_IS_MIME_MESSAGE (message)); - g_return_if_fail (source == NULL || EM_IS_FORMAT (source)); + if (g_cancellable_is_cancelled (cancellable)) + return; - class = EM_FORMAT_GET_CLASS (emf); - g_return_if_fail (class->format_clone != NULL); + if (!ipart) { + em_format_format_error(emf, _("Unknown error verifying signature")); + return; + } - class->format_clone (emf, folder, uid, message, source, cancellable); + cipher = camel_gpg_context_new (emf->priv->session); + /* Verify the signature of the message */ + valid = camel_cipher_context_verify_sync ( + cipher, ipart, cancellable, &local_error); + if (!valid) { + em_format_format_error ( + emf, local_error->message ? + _("Error verifying signature") : + _("Unknown error verifying signature")); + if (local_error->message) + em_format_format_error ( + emf, "%s", local_error->message); + emf_parse_source (emf, ipart, part_id, info, cancellable); + /* XXX I think this will loop: + * em_format_part_as(emf, stream, part, "text/plain"); */ + g_clear_error (&local_error); + g_object_unref (cipher); + return; + } + + /* Setup output stream */ + ostream = camel_stream_mem_new (); + filtered_stream = camel_stream_filter_new (ostream); + + /* Add PGP header / footer filter */ + pgp_filter = (CamelMimeFilterPgp *) camel_mime_filter_pgp_new (); + camel_stream_filter_add ( + CAMEL_STREAM_FILTER (filtered_stream), + CAMEL_MIME_FILTER (pgp_filter)); + g_object_unref (pgp_filter); + + /* Pass through the filters that have been setup */ + dw = camel_medium_get_content ((CamelMedium *) ipart); + camel_data_wrapper_decode_to_stream_sync ( + dw, (CamelStream *) filtered_stream, cancellable, NULL); + camel_stream_flush ((CamelStream *) filtered_stream, cancellable, NULL); + g_object_unref (filtered_stream); + + /* Create a new text/plain MIME part containing the signed + * content preserving the original part's Content-Type params. */ + content_type = camel_mime_part_get_content_type (ipart); + type = camel_content_type_format (content_type); + content_type = camel_content_type_decode (type); + g_free (type); + + g_free (content_type->type); + content_type->type = g_strdup ("text"); + g_free (content_type->subtype); + content_type->subtype = g_strdup ("plain"); + type = camel_content_type_format (content_type); + camel_content_type_unref (content_type); + + ba = camel_stream_mem_get_byte_array ((CamelStreamMem *) ostream); + opart = camel_mime_part_new (); + camel_mime_part_set_content (opart, (gchar *) ba->data, ba->len, type); + g_free (type); + + if (info->validity) + camel_cipher_validity_envelope (valid, info->validity); + + /* Pass it off to the real formatter */ + len = part_id->len; + g_string_append (part_id, ".inlinepgp_signed"); + signinfo.handler = info->handler; + signinfo.validity_type = info->validity_type | EM_FORMAT_VALIDITY_FOUND_SIGNED | EM_FORMAT_VALIDITY_FOUND_PGP; + signinfo.validity = valid; + em_format_parse_part (emf, opart, part_id, &signinfo, cancellable); + g_string_truncate (part_id, len); + + /* Add a widget with details about the encryption, but only when + * the encrypted isn't itself secured, in that case it has created + * the button itself */ + if (!is_secured (opart)) { + g_string_append (part_id, ".inlinepgp_signed.button"); + em_format_parse_part_as (emf, opart, part_id, &signinfo, + "x-evolution/message/x-secure-button", cancellable); + g_string_truncate (part_id, len); + } + + /* Clean Up */ + camel_cipher_validity_free (valid); + g_object_unref (dw); + g_object_unref (opart); + g_object_unref (ostream); + g_object_unref (cipher); } -void -em_format_format (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *message, - GCancellable *cancellable) +static void +emf_parse_inlinepgp_encrypted (EMFormat *emf, + CamelMimePart *ipart, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - /* em_format_format_clone() will check the arguments. */ - em_format_format_clone (emf, folder, uid, message, NULL, cancellable); + CamelCipherContext *cipher; + CamelCipherValidity *valid; + CamelMimePart *opart; + CamelDataWrapper *dw; + gchar *mime_type; + gint len; + GError *local_error = NULL; + EMFormatParserInfo encinfo; + + if (g_cancellable_is_cancelled (cancellable)) + return; + + cipher = camel_gpg_context_new (emf->priv->session); + opart = camel_mime_part_new (); + + /* Decrypt the message */ + valid = camel_cipher_context_decrypt_sync ( + cipher, ipart, opart, cancellable, &local_error); + + if (!valid) { + em_format_format_error ( + emf, _("Could not parse PGP message: ")); + if (local_error->message != NULL) + em_format_format_error ( + emf, "%s", local_error->message); + else + em_format_format_error ( + emf, _("Unknown error")); + emf_parse_source (emf, ipart, part_id, info, cancellable); + /* XXX I think this will loop: + * em_format_part_as(emf, stream, part, "text/plain"); */ + + g_clear_error (&local_error); + g_object_unref (cipher); + g_object_unref (opart); + return; + } + + dw = camel_medium_get_content ((CamelMedium *) opart); + mime_type = camel_data_wrapper_get_mime_type (dw); + + /* this ensures to show the 'opart' as inlined, if possible */ + if (mime_type && g_ascii_strcasecmp (mime_type, "application/octet-stream") == 0) { + const gchar *snoop = em_format_snoop_type (opart); + + if (snoop) + camel_data_wrapper_set_mime_type (dw, snoop); + } + + preserve_charset_in_content_type (ipart, opart); + g_free (mime_type); + + if (info->validity) + camel_cipher_validity_envelope (valid, info->validity); + + /* Pass it off to the real formatter */ + len = part_id->len; + g_string_append (part_id, ".inlinepgp_encrypted"); + encinfo.handler = info->handler; + encinfo.validity_type = info->validity_type | EM_FORMAT_VALIDITY_FOUND_ENCRYPTED | EM_FORMAT_VALIDITY_FOUND_PGP; + encinfo.validity = valid; + em_format_parse_part (emf, opart, part_id, &encinfo, cancellable); + g_string_truncate (part_id, len); + + /* Add a widget with details about the encryption, but only when + * the encrypted isn't itself secured, in that case it has created + * the button itself */ + if (!is_secured (opart)) { + g_string_append (part_id, ".inlinepgp_encrypted.button"); + em_format_parse_part_as (emf, opart, part_id, &encinfo, + "x-evolution/message/x-secure-button", cancellable); + g_string_truncate (part_id, len); + } + + /* Clean Up */ + camel_cipher_validity_free (valid); + g_object_unref (opart); + g_object_unref (cipher); } -static gboolean -format_redraw_idle_cb (EMFormat *emf) +static void +emf_parse_message (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - emf->priv->redraw_idle_id = 0; + /* Headers */ + info->force_handler = TRUE; + em_format_parse_part_as (emf, part, part_id, info, + "x-evolution/message/headers", cancellable); - /* FIXME Not passing a GCancellable here. */ - em_format_format_clone ( - emf, emf->folder, emf->uid, emf->message, emf, NULL); + /* Anything that comes between headers and message body */ + info->force_handler = TRUE; + em_format_parse_part_as (emf, part, part_id, info, + "x-evolution/message/post-headers", cancellable); - return FALSE; + /* Begin parsing the message */ + info->force_handler = FALSE; + em_format_parse_part (emf, part, part_id, info, cancellable); } -void -em_format_queue_redraw (EMFormat *emf) +static void +emf_parse_headers (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - g_return_if_fail (EM_IS_FORMAT (emf)); + EMFormatPURI *puri; + gint len; + + len = part_id->len; + g_string_append (part_id, ".headers"); + + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = info->handler->write_func; + puri->mime_type = g_strdup ("text/html"); + em_format_add_puri (emf, puri); - if (emf->priv->redraw_idle_id == 0) - emf->priv->redraw_idle_id = g_idle_add ( - (GSourceFunc) format_redraw_idle_cb, emf); + g_string_truncate (part_id, len); } -/** - * em_format_set_mode: - * @emf: - * @type: - * - * Set display mode, EM_FORMAT_MODE_SOURCE, EM_FORMAT_MODE_ALLHEADERS, - * or EM_FORMAT_MODE_NORMAL. - **/ -void -em_format_set_mode (EMFormat *emf, - EMFormatMode mode) +static void +emf_parse_post_headers (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) { - g_return_if_fail (EM_IS_FORMAT (emf)); + /* Add attachment bar */ + info->force_handler = TRUE; + em_format_parse_part_as (emf, part, part_id, info, + "x-evolution/message/attachment-bar", cancellable); +} + +static void +emf_parse_source (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) +{ + EMFormatPURI *puri; + gint len; - if (emf->mode == mode) + if (g_cancellable_is_cancelled (cancellable)) return; - emf->mode = mode; + len = part_id->len; + g_string_append (part_id, ".source"); + + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, part_id->str); + puri->write_func = info->handler->write_func; + puri->mime_type = g_strdup ("text/html"); + g_string_truncate (part_id, len); - /* force redraw if type changed afterwards */ - if (emf->message != NULL) - em_format_queue_redraw (emf); + em_format_add_puri (emf, puri); } -/** - * em_format_set_charset: - * @emf: - * @charset: - * - * set override charset on formatter. message will be redisplayed if - * required. - **/ +/**************************************************************************/ + void -em_format_set_charset (EMFormat *emf, - const gchar *charset) +em_format_empty_writer (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) { - if ((emf->charset && charset && g_ascii_strcasecmp (emf->charset, charset) == 0) - || (emf->charset == NULL && charset == NULL) - || (emf->charset == charset)) - return; - - g_free (emf->charset); - emf->charset = g_strdup (charset); + /* DO NOTHING */ +} - if (emf->message) - em_format_queue_redraw (emf); +static void +emf_write_error (EMFormat * emf, + EMFormatPURI * puri, + CamelStream * stream, + EMFormatWriterInfo * info, + GCancellable * cancellable) +{ + camel_data_wrapper_decode_to_stream_sync ((CamelDataWrapper *) puri->part, + stream, cancellable, NULL); } -/** - * em_format_set_default_charset: - * @emf: - * @charset: - * - * Set the fallback, default system charset to use when no other charsets - * are present. Message will be redisplayed if required (and sometimes - * redisplayed when it isn't). - **/ -void -em_format_set_default_charset (EMFormat *emf, - const gchar *charset) +static void +emf_write_text (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) { - if ((emf->default_charset && charset && - g_ascii_strcasecmp (emf->default_charset, charset) == 0) - || (emf->default_charset == NULL && charset == NULL) - || (emf->default_charset == charset)) + CamelContentType *ct; + + ct = camel_mime_part_get_content_type (puri->part); + if (!camel_content_type_is (ct, "text", "plain")) { + camel_stream_write_string (stream, _("Cannot proccess non-text mime/part"), + cancellable, NULL); return; + } - g_free (emf->default_charset); - emf->default_charset = g_strdup (charset); + camel_data_wrapper_decode_to_stream_sync ((CamelDataWrapper *) puri->part, + stream, cancellable, NULL); +} - if (emf->message && emf->charset == NULL) - em_format_queue_redraw (emf); +static void +emf_write_source (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) +{ + GByteArray *ba; + gchar *data; + + g_return_if_fail (EM_IS_FORMAT (emf)); + + ba = camel_data_wrapper_get_byte_array ((CamelDataWrapper *) puri->part); + + data = g_strndup ((gchar *) ba->data, ba->len); + camel_stream_write_string (stream, data, cancellable, NULL); + g_free (data); } -/** - * em_format_clear_headers: - * @emf: - * - * Clear the list of headers to be displayed. This will force all headers to - * be shown. - **/ -void -em_format_clear_headers (EMFormat *emf) +/**************************************************************************/ + +static gboolean +emf_is_inline (EMFormat *emf, + const gchar *part_id, + CamelMimePart *mime_part, + const EMFormatHandler *handle) { - EMFormatHeader *eh; + //EMFormatCache *emfc; + const gchar *disposition; + + if (handle == NULL) + return FALSE; + + /* Some types need to override the disposition. + * e.g. application/x-pkcs7-mime */ + if (handle->flags & EM_FORMAT_HANDLER_INLINE_DISPOSITION) + return TRUE; + + disposition = camel_mime_part_get_disposition (mime_part); + if (disposition != NULL) + return g_ascii_strcasecmp (disposition, "inline") == 0; - while ((eh = g_queue_pop_head (&emf->header_list)) != NULL) - g_free (eh); + /* Otherwise, use the default for this handler type. */ + return (handle->flags & EM_FORMAT_HANDLER_INLINE) != 0; } +/**************************************************************************/ + +static EMFormatHandler type_handlers[] = { +#ifdef ENABLE_SMIME + { (gchar *) "application/x-pkcs7-mime", emf_parse_application_xpkcs7mime, 0, EM_FORMAT_HANDLER_INLINE_DISPOSITION }, +#endif + { (gchar *) "application/mbox", emf_parse_application_mbox, 0, EM_FORMAT_HANDLER_INLINE | EM_FORMAT_HANDLER_COMPOUND_TYPE }, + { (gchar *) "multipart/alternative", emf_parse_multipart_alternative, }, + { (gchar *) "multipart/appledouble", emf_parse_multipart_appledouble, }, + { (gchar *) "multipart/encrypted", emf_parse_multipart_encrypted, }, + { (gchar *) "multipart/mixed", emf_parse_multipart_mixed, }, + { (gchar *) "multipart/signed", emf_parse_multipart_signed, }, + { (gchar *) "multipart/related", emf_parse_multipart_related, }, + { (gchar *) "multipart/digest", emf_parse_multipart_digest, 0, EM_FORMAT_HANDLER_COMPOUND_TYPE }, + { (gchar *) "multipart/*", emf_parse_multipart_mixed, 0, EM_FORMAT_HANDLER_COMPOUND_TYPE }, + { (gchar *) "message/deliverystatus", emf_parse_message_deliverystatus, 0, }, + + /* Ignore PGP signature part */ + { (gchar *) "application/pgp-signature", em_format_empty_parser, }, + + /* Insert brokenly-named parts here */ +#ifdef ENABLE_SMIME + { (gchar *) "application/pkcs7-mime", emf_parse_application_xpkcs7mime, 0, EM_FORMAT_HANDLER_INLINE_DISPOSITION }, +#endif + + /* internal types */ + { (gchar *) "application/x-inlinepgp-signed", emf_parse_inlinepgp_signed, }, + { (gchar *) "application/x-inlinepgp-encrypted", emf_parse_inlinepgp_encrypted, }, + { (gchar *) "x-evolution/message", emf_parse_message, 0, EM_FORMAT_HANDLER_COMPOUND_TYPE }, + { (gchar *) "x-evolution/message/headers", emf_parse_headers, }, + { (gchar *) "x-evolution/message/post-headers", emf_parse_post_headers, }, + { (gchar *) "x-evolution/message/source", emf_parse_source, emf_write_source }, +}; + /* note: also copied in em-mailer-prefs.c */ static const struct { const gchar *name; @@ -1071,1338 +1232,1085 @@ static const struct { { N_("Face"), 0 }, }; -/** - * em_format_default_headers: - * @emf: - * - * Set the headers to show to the default list. - * - * From, Reply-To, To, Cc, Bcc, Subject and Date. - **/ -void -em_format_default_headers (EMFormat *emf) +static void +em_format_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) { - gint ii; + EMFormat *emf = EM_FORMAT (object); - em_format_clear_headers (emf); + switch (property_id) { + case PROP_CHARSET: + g_value_set_string ( + value, em_format_get_charset (emf)); + return; + case PROP_DEFAULT_CHARSET: + g_value_set_string ( + value, em_format_get_default_charset (emf)); + return; + case PROP_COMPOSER: + g_value_set_boolean ( + value, em_format_get_composer (emf)); + return; + case PROP_BASE_URL: + g_value_set_object ( + value, em_format_get_base_url (emf)); + return; + } - for (ii = 0; ii < G_N_ELEMENTS (default_headers); ii++) - em_format_add_header ( - emf, default_headers[ii].name, - default_headers[ii].flags); + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } -/** - * em_format_add_header: - * @emf: - * @name: The name of the header, as it will appear during output. - * @flags: EM_FORMAT_HEAD_* defines to control display attributes. - * - * Add a specific header to show. If any headers are set, they will - * be displayed in the order set by this function. Certain known - * headers included in this list will be shown using special - * formatting routines. - **/ -void -em_format_add_header (EMFormat *emf, - const gchar *name, - guint32 flags) +static void +em_format_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) { - EMFormatHeader *h; + EMFormat *emf = EM_FORMAT (object); + + switch (property_id) { + case PROP_CHARSET: + em_format_set_charset (emf, + g_value_get_string (value)); + return; + case PROP_DEFAULT_CHARSET: + em_format_set_default_charset (emf, + g_value_get_string (value)); + return; + case PROP_COMPOSER: + em_format_set_composer (emf, + g_value_get_boolean (value)); + return; + case PROP_BASE_URL: + em_format_set_base_url (emf, + g_value_get_object (value)); + return; + } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); - h = g_malloc (sizeof (*h) + strlen (name)); - h->flags = flags; - strcpy (h->name, name); - g_queue_push_tail (&emf->header_list, h); } -/** - * em_format_is_attachment: - * @emf: - * @part: Part to check. - * - * Returns true if the part is an attachment. - * - * A part is not considered an attachment if it is a - * multipart, or a text part with no filename. It is used - * to determine if an attachment header should be displayed for - * the part. - * - * Content-Disposition is not checked. - * - * Return value: TRUE/FALSE - **/ -gint -em_format_is_attachment (EMFormat *emf, - CamelMimePart *part) +static void +em_format_finalize (GObject *object) { - /*CamelContentType *ct = camel_mime_part_get_content_type(part);*/ - CamelDataWrapper *dw = camel_medium_get_content ((CamelMedium *) part); + EMFormat *emf = EM_FORMAT (object); - if (!dw) - return 0; + if (emf->message_uid) { + g_free (emf->message_uid); + emf->message_uid = NULL; + } - /*printf("checking is attachment %s/%s\n", ct->type, ct->subtype);*/ - return !(camel_content_type_is (dw->mime_type, "multipart", "*") - || camel_content_type_is ( - dw->mime_type, "application", "x-pkcs7-mime") - || camel_content_type_is ( - dw->mime_type, "application", "pkcs7-mime") - || camel_content_type_is ( - dw->mime_type, "application", "x-inlinepgp-signed") - || camel_content_type_is ( - dw->mime_type, "application", "x-inlinepgp-encrypted") - || camel_content_type_is ( - dw->mime_type, "x-evolution", "evolution-rss-feed") - || camel_content_type_is (dw->mime_type, "text", "calendar") - || camel_content_type_is (dw->mime_type, "text", "x-calendar") - || (camel_content_type_is (dw->mime_type, "text", "*") - && camel_mime_part_get_filename (part) == NULL)); + if (emf->uri_base) { + g_free (emf->uri_base); + emf->uri_base = NULL; + } + + if (emf->message) { + g_object_unref (emf->message); + emf->message = NULL; + } + + if (emf->folder) { + g_object_unref (emf->folder); + emf->folder = NULL; + } + + if (emf->mail_part_table) { + /* This will destroy all the EMFormatPURI objects stored + * inside!!!! */ + g_hash_table_destroy (emf->mail_part_table); + emf->mail_part_table = NULL; + } + + if (emf->mail_part_list) { + g_list_free (emf->mail_part_list); + emf->mail_part_list = NULL; + } + + if (emf->priv->base_url) { + camel_url_free (emf->priv->base_url); + emf->priv->base_url = NULL; + } + + if (emf->priv->session) { + g_object_unref (emf->priv->session); + emf->priv->session = NULL; + } + + if (emf->priv->charset) { + g_free (emf->priv->charset); + emf->priv->charset = NULL; + } + + em_format_clear_headers (emf); + + /* Chain up to parent's finalize() method */ + G_OBJECT_CLASS (parent_class)->finalize (object); } -/** - * em_format_is_inline: - * @emf: - * @part: - * @part_id: format->part_id part id of this part. - * @handle: handler for this part - * - * Returns true if the part should be displayed inline. Any part with - * a Content-Disposition of inline, or if the @handle has a default - * inline set, will be shown inline. - * - * :set_inline() called on the same part will override any calculated - * value. - * - * Return value: - **/ -gboolean -em_format_is_inline (EMFormat *emf, - const gchar *part_id, - CamelMimePart *mime_part, - const EMFormatHandler *handle) +static void +em_format_base_init (EMFormatClass *klass) { - EMFormatClass *class; + gint i; - g_return_val_if_fail (EM_IS_FORMAT (emf), FALSE); - g_return_val_if_fail (part_id != NULL, FALSE); - g_return_val_if_fail (CAMEL_IS_MIME_PART (mime_part), FALSE); + klass->type_handlers = g_hash_table_new (g_str_hash, g_str_equal); - class = EM_FORMAT_GET_CLASS (emf); - g_return_val_if_fail (class->is_inline != NULL, FALSE); + for (i = 0; i < G_N_ELEMENTS (type_handlers); i++) { + g_hash_table_insert (klass->type_handlers, + type_handlers[i].mime_type, + &type_handlers[i]); + } +} + +static void +em_format_class_init (EMFormatClass *klass) +{ + GObjectClass *object_class; + + parent_class = g_type_class_peek_parent (klass); + + g_type_class_add_private (klass, sizeof (EMFormatPrivate)); + + klass->is_inline = emf_is_inline; + + object_class = G_OBJECT_CLASS (klass); + object_class->finalize = em_format_finalize; + object_class->get_property = em_format_get_property; + object_class->set_property = em_format_set_property; + + g_object_class_install_property (object_class, + PROP_CHARSET, + g_param_spec_string ("charset", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_DEFAULT_CHARSET, + g_param_spec_string ("default-charset", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_COMPOSER, + g_param_spec_boolean ("composer", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_BASE_URL, + g_param_spec_pointer ("base-url", + NULL, + NULL, + G_PARAM_READWRITE)); + + signals[REDRAW_REQUESTED] = g_signal_new ( + "redraw-requested", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EMFormatClass, redraw_requested), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE,0); +} + +static void +mail_part_table_item_free (gpointer data) +{ + GList *iter = data; + EMFormatPURI *puri = iter->data; - return class->is_inline (emf, part_id, mime_part, handle); + em_format_puri_free (puri); } -/** - * em_format_set_inline: - * @emf: - * @part_id: id of part - * @state: - * - * Force the attachment @part to be expanded or hidden explictly to match - * @state. This is used only to record the change for a redraw or - * cloned layout render and does not force a redraw. - **/ -void -em_format_set_inline (EMFormat *emf, - const gchar *part_id, - gint state) +static void +em_format_init (EMFormat *emf) { - EMFormatCache *emfc; + EShell *shell; + EShellSettings *shell_settings; - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (part_id != NULL); + emf->priv = G_TYPE_INSTANCE_GET_PRIVATE (emf, + EM_TYPE_FORMAT, EMFormatPrivate); - emfc = g_hash_table_lookup (emf->inline_table, part_id); - if (emfc == NULL) { - emfc = emf_insert_cache (emf, part_id); - } else if (emfc->state != INLINE_UNSET && (emfc->state & 1) == state) - return; + emf->message = NULL; + emf->folder = NULL; + emf->mail_part_list = NULL; + emf->mail_part_table = g_hash_table_new_full (g_str_hash, g_str_equal, + NULL, (GDestroyNotify) mail_part_table_item_free); + /* No need to free the key, because it's owned and free'd by the PURI */ - emfc->state = state ? INLINE_ON : INLINE_OFF; + shell = e_shell_get_default (); + shell_settings = e_shell_get_shell_settings (shell); - if (emf->message) - em_format_queue_redraw (emf); -} + emf->priv->last_error = 0; -void -em_format_format_attachment (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - const gchar *mime_type, - const EMFormatHandler *info, - GCancellable *cancellable) -{ - EMFormatClass *class; + emf->priv->session = e_shell_settings_get_pointer (shell_settings, "mail-session"); + g_return_if_fail (emf->priv->session); - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (CAMEL_IS_STREAM (stream)); - g_return_if_fail (CAMEL_IS_MIME_PART (mime_part)); - g_return_if_fail (mime_type != NULL); - g_return_if_fail (info != NULL); + g_object_ref (emf->priv->session); + + em_format_default_headers (emf); +} - class = EM_FORMAT_GET_CLASS (emf); - g_return_if_fail (class->format_attachment != NULL); +EMFormat * +em_format_new (void) +{ + EMFormat *emf = g_object_new (EM_TYPE_FORMAT, NULL); - class->format_attachment ( - emf, stream, mime_part, mime_type, info, cancellable); + return emf; } -void -em_format_format_error (EMFormat *emf, - CamelStream *stream, - const gchar *format, - ...) +GType +em_format_get_type (void) { - EMFormatClass *class; - gchar *errmsg; - va_list ap; + static GType type = 0; - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (CAMEL_IS_STREAM (stream)); - g_return_if_fail (format != NULL); + if (G_UNLIKELY (type == 0)) { + static const GTypeInfo type_info = { + sizeof (EMFormatClass), + (GBaseInitFunc) em_format_base_init, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) em_format_class_init, + (GClassFinalizeFunc) NULL, + NULL, /* class_data */ + sizeof (EMFormat), + 0, /* n_preallocs */ + (GInstanceInitFunc) em_format_init, + NULL /* value_table */ + }; - class = EM_FORMAT_GET_CLASS (emf); - g_return_if_fail (class->format_error != NULL); + type = g_type_register_static ( + G_TYPE_OBJECT, "EMFormat", &type_info, 0); + } - va_start (ap, format); - errmsg = g_strdup_vprintf (format, ap); - class->format_error (emf, stream, errmsg); - g_free (errmsg); - va_end (ap); + return type; } void -em_format_format_secure (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - CamelCipherValidity *valid, - GCancellable *cancellable) +em_format_set_charset (EMFormat *emf, + const gchar *charset) { - EMFormatClass *class; - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (CAMEL_IS_STREAM (stream)); - g_return_if_fail (CAMEL_IS_MIME_PART (mime_part)); - g_return_if_fail (valid != NULL); - class = EM_FORMAT_GET_CLASS (emf); - g_return_if_fail (class->format_secure != NULL); + if (emf->priv->charset) + g_free (emf->priv->charset); - class->format_secure (emf, stream, mime_part, valid, cancellable); + emf->priv->charset = g_strdup (charset); - if (emf->valid_parent == NULL && emf->valid != NULL) { - camel_cipher_validity_free (emf->valid); - emf->valid = NULL; - } + g_object_notify (G_OBJECT (emf), "charset"); } -void -em_format_format_source (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - GCancellable *cancellable) +const gchar * +em_format_get_charset (EMFormat *emf) { - EMFormatClass *class; - - g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_if_fail (CAMEL_IS_STREAM (stream)); - g_return_if_fail (CAMEL_IS_MIME_PART (mime_part)); - - class = EM_FORMAT_GET_CLASS (emf); - g_return_if_fail (class->format_source != NULL); + g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); - class->format_source (emf, stream, mime_part, cancellable); + return emf->priv->charset; } -gboolean -em_format_busy (EMFormat *emf) +void +em_format_set_default_charset (EMFormat *emf, + const gchar *charset) { - EMFormatClass *class; + g_return_if_fail (EM_IS_FORMAT (emf)); - g_return_val_if_fail (EM_IS_FORMAT (emf), FALSE); + if (emf->priv->default_charset) + g_free (emf->priv->default_charset); - class = EM_FORMAT_GET_CLASS (emf); - g_return_val_if_fail (class->busy != NULL, FALSE); + emf->priv->default_charset = g_strdup (charset); - return class->busy (emf); + g_object_notify (G_OBJECT (emf), "default-charset"); } -/* should this be virtual? */ -void -em_format_format_content (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - GCancellable *cancellable) +const gchar * +em_format_get_default_charset (EMFormat *emf) { - CamelDataWrapper *dw = camel_medium_get_content ((CamelMedium *) part); + g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); - if (camel_content_type_is (dw->mime_type, "text", "*")) - em_format_format_text ( - emf, stream, (CamelDataWrapper *) part, cancellable); - else - camel_data_wrapper_decode_to_stream_sync ( - dw, stream, cancellable, NULL); + return emf->priv->default_charset; } -/** - * em_format_format_content: - * @emf: - * @stream: Where to write the converted text - * @part: Part whose container is to be formatted - * @cancellable: optional #GCancellable object, or %NULL - * - * Decode/output a part's content to @stream. - **/ void -em_format_format_text (EMFormat *emf, - CamelStream *stream, - CamelDataWrapper *dw, - GCancellable *cancellable) +em_format_set_composer (EMFormat *emf, + gboolean composer) { - CamelStream *filter_stream; - CamelMimeFilter *filter; - const gchar *charset = NULL; - CamelMimeFilterWindows *windows = NULL; - CamelStream *mem_stream = NULL; - gsize size; - gsize max; - GSettings *settings; + g_return_if_fail (EM_IS_FORMAT (emf)); - if (emf->charset) { - charset = emf->charset; - } else if (dw->mime_type - && (charset = camel_content_type_param (dw->mime_type, "charset")) - && g_ascii_strncasecmp(charset, "iso-8859-", 9) == 0) { - CamelStream *null; + if (emf->priv->composer && composer) + return; - /* Since a few Windows mailers like to claim they sent - * out iso-8859-# encoded text when they really sent - * out windows-cp125#, do some simple sanity checking - * before we move on... */ + emf->priv->composer = composer; - null = camel_stream_null_new (); - filter_stream = camel_stream_filter_new (null); - g_object_unref (null); + g_object_notify (G_OBJECT (emf), "composer"); +} - windows = (CamelMimeFilterWindows *) camel_mime_filter_windows_new (charset); - camel_stream_filter_add ( - CAMEL_STREAM_FILTER (filter_stream), - CAMEL_MIME_FILTER (windows)); +gboolean +em_format_get_composer (EMFormat *emf) +{ + g_return_val_if_fail (EM_IS_FORMAT (emf), FALSE); - camel_data_wrapper_decode_to_stream_sync ( - dw, (CamelStream *) filter_stream, cancellable, NULL); - camel_stream_flush ((CamelStream *) filter_stream, cancellable, NULL); - g_object_unref (filter_stream); + return emf->priv->composer; +} - charset = camel_mime_filter_windows_real_charset (windows); - } else if (charset == NULL) { - charset = emf->default_charset; - } +void +em_format_set_base_url (EMFormat *emf, + CamelURL *url) +{ + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (url); - mem_stream = (CamelStream *) camel_stream_mem_new (); - filter_stream = camel_stream_filter_new (mem_stream); + if (emf->priv->base_url) + camel_url_free (emf->priv->base_url); - if ((filter = camel_mime_filter_charset_new (charset, "UTF-8"))) { - camel_stream_filter_add ( - CAMEL_STREAM_FILTER (filter_stream), - CAMEL_MIME_FILTER (filter)); - g_object_unref (filter); - } + emf->priv->base_url = camel_url_copy (url); - max = -1; + g_object_notify (G_OBJECT (emf), "base-url"); +} - settings = g_settings_new ("org.gnome.evolution.mail"); - if (g_settings_get_boolean (settings, "force-message-limit")) { - max = g_settings_get_int (settings, "message-text-part-limit"); - if (max == 0) - max = -1; - } - g_object_unref (settings); +void +em_format_set_base_url_string (EMFormat *emf, + const gchar *url_string) +{ + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (url_string && *url_string); - size = camel_data_wrapper_decode_to_stream_sync ( - emf->mode == EM_FORMAT_MODE_SOURCE ? - (CamelDataWrapper *) dw : - camel_medium_get_content ((CamelMedium *) dw), - (CamelStream *) filter_stream, cancellable, NULL); - camel_stream_flush ((CamelStream *) filter_stream, cancellable, NULL); - g_object_unref (filter_stream); + if (emf->priv->base_url) + camel_url_free (emf->priv->base_url); - g_seekable_seek (G_SEEKABLE (mem_stream), 0, G_SEEK_SET, NULL, NULL); + emf->priv->base_url = camel_url_new (url_string, NULL); - if (max == -1 || size == -1 || size < (max * 1024) || emf->composer) { - camel_stream_write_to_stream ( - mem_stream, (CamelStream *) stream, cancellable, NULL); - camel_stream_flush ((CamelStream *) stream, cancellable, NULL); - } else { - EM_FORMAT_GET_CLASS (emf)->format_optional ( - emf, stream, (CamelMimePart *) dw, - mem_stream, cancellable); - } + g_object_notify (G_OBJECT (emf), "base-url"); +} - if (windows) - g_object_unref (windows); +CamelURL * +em_format_get_base_url (EMFormat *emf) +{ + g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); - g_object_unref (mem_stream); + return emf->priv->base_url; } /** - * em_format_describe_part: - * @part: - * @mimetype: - * - * Generate a simple textual description of a part, @mime_type represents the - * the content. + * em_format_clear_headers: + * @emf: * - * Return value: + * Clear the list of headers to be displayed. This will force all headers to + * be shown. **/ -gchar * -em_format_describe_part (CamelMimePart *part, - const gchar *mime_type) +void +em_format_clear_headers (EMFormat *emf) { - GString *stext; - const gchar *filename, *description; - gchar *content_type, *desc; - - stext = g_string_new(""); - content_type = g_content_type_from_mime_type (mime_type); - desc = g_content_type_get_description ( - content_type != NULL ? content_type : mime_type); - g_free (content_type); - g_string_append_printf ( - stext, _("%s attachment"), desc ? desc : mime_type); - g_free (desc); - - filename = camel_mime_part_get_filename (part); - description = camel_mime_part_get_description (part); - - if (!filename || !*filename) { - CamelDataWrapper *content; - - content = camel_medium_get_content (CAMEL_MEDIUM (part)); + EMFormatHeader *eh; - if (CAMEL_IS_MIME_MESSAGE (content)) - filename = camel_mime_message_get_subject ( - CAMEL_MIME_MESSAGE (content)); - } + g_return_if_fail (EM_IS_FORMAT (emf)); - if (filename != NULL && *filename != '\0') { - gchar *basename = g_path_get_basename (filename); - g_string_append_printf (stext, " (%s)", basename); - g_free (basename); + while ((eh = g_queue_pop_head (&emf->header_list)) != NULL) { + em_format_header_free (eh); } - if (description != NULL && *description != '\0' && - g_strcmp0 (filename, description) != 0) - g_string_append_printf (stext, ", \"%s\"", description); - - return g_string_free (stext, FALSE); } -static void -add_validity_found (EMFormat *emf, - CamelCipherValidity *valid) +void +em_format_default_headers (EMFormat *emf) { - g_return_if_fail (emf != NULL); - - if (!valid) - return; + gint ii; - if (valid->sign.status != CAMEL_CIPHER_VALIDITY_SIGN_NONE) - emf->validity_found |= EM_FORMAT_VALIDITY_FOUND_SIGNED; + g_return_if_fail (EM_IS_FORMAT (emf)); - if (valid->encrypt.status != CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE) - emf->validity_found |= EM_FORMAT_VALIDITY_FOUND_ENCRYPTED; + /* Set the default headers */ + em_format_clear_headers (emf); + for (ii = 0; ii < G_N_ELEMENTS (default_headers); ii++) + em_format_add_header ( + emf, default_headers[ii].name, NULL, + default_headers[ii].flags); } -/* ********************************************************************** */ - -static void -preserve_charset_in_content_type (CamelMimePart *ipart, - CamelMimePart *opart) -{ - CamelDataWrapper *data_wrapper; - CamelContentType *content_type; - const gchar *charset; - - g_return_if_fail (ipart != NULL); - g_return_if_fail (opart != NULL); - - data_wrapper = camel_medium_get_content (CAMEL_MEDIUM (ipart)); - content_type = camel_data_wrapper_get_mime_type_field (data_wrapper); - - if (content_type == NULL) - return; - - charset = camel_content_type_param (content_type, "charset"); - - if (charset == NULL || *charset == '\0') - return; +/** + * em_format_add_header: + * @emf: + * @name: The name of the header, as it will appear during output. + * @value: Value of the header. Can be NULL. + * @flags: EM_FORMAT_HEAD_* defines to control display attributes. + * + * Add a specific header to show. If any headers are set, they will + * be displayed in the order set by this function. Certain known + * headers included in this list will be shown using special + * formatting routines. + **/ +void +em_format_add_header (EMFormat *emf, + const gchar *name, + const gchar *value, + guint32 flags) +{ + EMFormatHeader *h; - data_wrapper = camel_medium_get_content (CAMEL_MEDIUM (opart)); - content_type = camel_data_wrapper_get_mime_type_field (data_wrapper); + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (name && *name); - camel_content_type_set_param (content_type, "charset", charset); + h = em_format_header_new (name, value); + h->flags = flags; + g_queue_push_tail (&emf->header_list, h); } -#ifdef ENABLE_SMIME -static void -emf_application_xpkcs7mime (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +void +em_format_add_header_struct (EMFormat *emf, + EMFormatHeader *header) { - CamelCipherContext *context; - CamelMimePart *opart; - CamelCipherValidity *valid; - EMFormatCache *emfc; - GError *local_error = NULL; + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (header && header->name); - /* should this perhaps run off a key of ".secured" ? */ - emfc = g_hash_table_lookup (emf->inline_table, emf->part_id->str); - if (emfc && emfc->valid) { - em_format_format_secure ( - emf, stream, emfc->secured, - camel_cipher_validity_clone (emfc->valid), - cancellable); - return; - } + em_format_add_header (emf, header->name, header->value, header->flags); +} - context = camel_smime_context_new (emf->session); +void +em_format_remove_header (EMFormat * emf, + const gchar *name, + const gchar *value) +{ + GList *iter = NULL; - emf->validity_found |= - EM_FORMAT_VALIDITY_FOUND_ENCRYPTED | - EM_FORMAT_VALIDITY_FOUND_SMIME; + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (name && *name); - opart = camel_mime_part_new (); - valid = camel_cipher_context_decrypt_sync ( - context, part, opart, cancellable, &local_error); - preserve_charset_in_content_type (part, opart); - if (valid == NULL) { - em_format_format_error ( - emf, stream, "%s", - local_error->message ? local_error->message : - _("Could not parse S/MIME message: Unknown error")); - g_clear_error (&local_error); + iter = g_queue_peek_head_link (&emf->header_list); + while (iter) { + EMFormatHeader *header = iter->data; - em_format_part_as (emf, stream, part, NULL, cancellable); - } else { - if (emfc == NULL) - emfc = emf_insert_cache (emf, emf->part_id->str); + if (!header->value || !*header->value) { + GList *next = iter->next; + if (g_strcmp0 (name, header->name) == 0) + g_queue_delete_link (&emf->header_list, iter); - emfc->valid = camel_cipher_validity_clone (valid); - g_object_ref ((emfc->secured = opart)); + iter = next; + continue; + } + + if (value && *value) { + if ((g_strcmp0 (name, header->name) == 0) && + (g_strcmp0 (value, header->value) == 0)) + break; + } else { + if (g_strcmp0 (name, header->name) == 0) + break; + } - add_validity_found (emf, valid); - em_format_format_secure ( - emf, stream, opart, valid, cancellable); + iter = iter->next; } - g_object_unref (opart); - g_object_unref (context); + if (iter) { + em_format_header_free (iter->data); + g_queue_delete_link (&emf->header_list, iter); + } } -#endif -/* RFC 1740 */ -static void -emf_multipart_appledouble (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +void +em_format_remove_header_struct (EMFormat * emf, + const EMFormatHeader * header) { - CamelMultipart *mp; - CamelMimePart *mime_part; - gint len; - - mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); - - if (!CAMEL_IS_MULTIPART (mp)) { - em_format_format_source (emf, stream, part, cancellable); - return; - } - - mime_part = camel_multipart_get_part (mp, 1); - if (mime_part) { - /* try the data fork for something useful, doubtful but who knows */ - len = emf->part_id->len; - g_string_append_printf(emf->part_id, ".appledouble.1"); - em_format_part (emf, stream, mime_part, cancellable); - g_string_truncate (emf->part_id, len); - } else - em_format_format_source (emf, stream, part, cancellable); + g_return_if_fail (header); + em_format_remove_header (emf, header->name, header->value); } -/* RFC ??? */ -static void -emf_multipart_mixed (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +void +em_format_add_puri (EMFormat *emf, + EMFormatPURI *puri) { - CamelMultipart *mp; - gint i, nparts, len; + GList *item; - mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (puri != NULL); - if (!CAMEL_IS_MULTIPART (mp)) { - em_format_format_source (emf, stream, part, cancellable); - return; - } + emf->mail_part_list = g_list_append (emf->mail_part_list, puri); + item = g_list_last (emf->mail_part_list); - len = emf->part_id->len; - nparts = camel_multipart_get_number (mp); - for (i = 0; i < nparts; i++) { - part = camel_multipart_get_part (mp, i); - g_string_append_printf(emf->part_id, ".mixed.%d", i); - em_format_part (emf, stream, part, cancellable); - g_string_truncate (emf->part_id, len); - } -} + g_hash_table_insert (emf->mail_part_table, + puri->uri, item); -static gboolean related_display_part_is_attachment - (EMFormat *emf, - CamelMimePart *part); + d(printf("Added PURI %s\n", puri->uri)); +} -/* RFC 1740 */ -static void -emf_multipart_alternative (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +EMFormatPURI * +em_format_find_puri (EMFormat *emf, + const gchar *id) { - CamelMultipart *mp; - gint i, nparts, bestid = 0; - CamelMimePart *best = NULL; - - mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); + GList *list_iter; - if (!CAMEL_IS_MULTIPART (mp)) { - em_format_format_source (emf, stream, part, cancellable); - return; - } + /* First handle CIDs... */ + if (g_str_has_prefix (id, "CID:") || g_str_has_prefix (id, "cid:")) { + GHashTableIter iter; + gpointer key, value; - /* as per rfc, find the last part we know how to display */ - nparts = camel_multipart_get_number (mp); - for (i = 0; i < nparts; i++) { - CamelDataWrapper *data_wrapper; - CamelContentType *type; - CamelStream *null_stream; - gchar *mime_type; - gsize content_size; + g_hash_table_iter_init (&iter, emf->mail_part_table); + while (g_hash_table_iter_next (&iter, &key, &value)) { + EMFormatPURI *puri = ((GList *) value)->data; + if (g_strcmp0 (puri->cid, id) == 0) + return puri; + } - /* is it correct to use the passed in *part here? */ - part = camel_multipart_get_part (mp, i); + return NULL; + } - if (part == NULL) - continue; + list_iter = g_hash_table_lookup (emf->mail_part_table, id); + if (list_iter) + return list_iter->data; - /* This may block even though the stream does not. - * XXX Pretty inefficient way to test if the MIME part - * is empty. Surely there's a quicker way? */ - null_stream = camel_stream_null_new (); - data_wrapper = camel_medium_get_content (CAMEL_MEDIUM (part)); - camel_data_wrapper_decode_to_stream_sync ( - data_wrapper, null_stream, cancellable, NULL); - content_size = CAMEL_STREAM_NULL (null_stream)->written; - g_object_unref (null_stream); + return NULL; +} - if (content_size == 0) - continue; +void +em_format_class_add_handler (EMFormatClass *emfc, + EMFormatHandler *handler) +{ + EMFormatHandler *old_handler; - type = camel_mime_part_get_content_type (part); - mime_type = camel_content_type_simple (type); + g_return_if_fail (EM_IS_FORMAT_CLASS (emfc)); + g_return_if_fail (handler); - camel_strdown (mime_type); + old_handler = g_hash_table_lookup ( + emfc->type_handlers, handler->mime_type); - /*if (want_plain && !strcmp (mime_type, "text/plain")) - return part;*/ + handler->old = old_handler; - if (!em_format_is_attachment (emf, part) && - (!camel_content_type_is (type, "multipart", "related") || - !related_display_part_is_attachment (emf, part)) && - (em_format_find_handler (emf, mime_type) - || (best == NULL && em_format_fallback_handler (emf, mime_type)))) { - best = part; - bestid = i; - } + /* If parse_func or write_func of the new handler is not set, + * use function from the old handler (if it exists). + * This way we can assign a new write_func for to an existing + * parse_func */ + if (old_handler && handler->parse_func == NULL) { + handler->parse_func = old_handler->parse_func; + } - g_free (mime_type); + if (old_handler && handler->write_func == NULL) { + handler->write_func = old_handler->write_func; } - if (best) { - gint len = emf->part_id->len; + g_hash_table_insert (emfc->type_handlers, + handler->mime_type, handler); +} - g_string_append_printf(emf->part_id, ".alternative.%d", bestid); - em_format_part (emf, stream, best, cancellable); - g_string_truncate (emf->part_id, len); - } else - emf_multipart_mixed ( - emf, stream, part, info, cancellable, is_fallback); +void +em_format_class_remove_handler (EMFormatClass *emfc, + EMFormatHandler *handler) +{ + g_return_if_fail (EM_IS_FORMAT_CLASS (emfc)); + g_return_if_fail (handler); + + g_hash_table_remove (emfc->type_handlers, handler->mime_type); } -static void -emf_multipart_encrypted (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +const EMFormatHandler * +em_format_find_handler (EMFormat *emf, + const gchar *mime_type) { - CamelCipherContext *context; - const gchar *protocol; - CamelMimePart *opart; - CamelCipherValidity *valid; - CamelMultipartEncrypted *mpe; - EMFormatCache *emfc; - GError *local_error = NULL; + EMFormatClass *emfc; + gchar *s; + const EMFormatHandler *handler; - /* should this perhaps run off a key of ".secured" ? */ - emfc = g_hash_table_lookup (emf->inline_table, emf->part_id->str); - if (emfc && emfc->valid) { - em_format_format_secure ( - emf, stream, emfc->secured, - camel_cipher_validity_clone (emfc->valid), - cancellable); - return; - } + g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); + g_return_val_if_fail (mime_type && *mime_type, NULL); - mpe = (CamelMultipartEncrypted *) camel_medium_get_content ((CamelMedium *) part); - if (!CAMEL_IS_MULTIPART_ENCRYPTED (mpe)) { - em_format_format_error ( - emf, stream, _("Could not parse MIME message. " - "Displaying as source.")); - em_format_format_source (emf, stream, part, cancellable); - return; - } + emfc = (EMFormatClass *) G_OBJECT_GET_CLASS (emf); - /* Currently we only handle RFC2015-style PGP encryption. */ - protocol = camel_content_type_param ( - ((CamelDataWrapper *)mpe)->mime_type, "protocol"); - if (protocol == NULL || g_ascii_strcasecmp (protocol, "application/pgp-encrypted") != 0) { - em_format_format_error ( - emf, stream, _("Unsupported encryption " - "type for multipart/encrypted")); - em_format_part_as ( - emf, stream, part, - "multipart/mixed", cancellable); - return; - } + s = g_ascii_strdown (mime_type, -1); - emf->validity_found |= - EM_FORMAT_VALIDITY_FOUND_ENCRYPTED | - EM_FORMAT_VALIDITY_FOUND_PGP; + handler = g_hash_table_lookup ( + emfc->type_handlers, s); - context = camel_gpg_context_new (emf->session); - opart = camel_mime_part_new (); - valid = camel_cipher_context_decrypt_sync ( - context, part, opart, cancellable, &local_error); - preserve_charset_in_content_type (part, opart); - if (valid == NULL) { - em_format_format_error ( - emf, stream, local_error->message ? - _("Could not parse PGP/MIME message") : - _("Could not parse PGP/MIME message: Unknown error")); - if (local_error->message != NULL) - em_format_format_error ( - emf, stream, "%s", local_error->message); - g_clear_error (&local_error); + g_free (s); - em_format_part_as ( - emf, stream, part, - "multipart/mixed", cancellable); - } else { - if (emfc == NULL) - emfc = emf_insert_cache (emf, emf->part_id->str); + return handler; +} + +/** + * em_format_fallback_handler: + * @emf: + * @mime_type: + * + * Try to find a format handler based on the major type of the @mime_type. + * + * The subtype is replaced with "*" and a lookup performed. + * + * Return value: + **/ +const EMFormatHandler * +em_format_fallback_handler (EMFormat *emf, + const gchar *mime_type) +{ + gchar *mime, *s; - emfc->valid = camel_cipher_validity_clone (valid); - g_object_ref ((emfc->secured = opart)); + s = strchr (mime_type, '/'); + if (s == NULL) + mime = (gchar *) mime_type; + else { + gsize len = (s - mime_type) + 1; - add_validity_found (emf, valid); - em_format_format_secure ( - emf, stream, opart, valid, cancellable); + mime = g_alloca (len + 2); + strncpy (mime, mime_type, len); + strcpy(mime+len, "*"); } - /* TODO: Make sure when we finalize this part, it is zero'd out */ - g_object_unref (opart); - g_object_unref (context); + return em_format_find_handler (emf, mime); } -static CamelMimePart * -get_related_display_part (CamelMimePart *part, - gint *out_displayid) +void +em_format_parse (EMFormat *emf, + CamelMimeMessage *message, + CamelFolder *folder, + GCancellable *cancellable) { - CamelMultipart *mp; - CamelMimePart *body_part, *display_part = NULL; - CamelContentType *content_type; - const gchar *start; - gint i, nparts, displayid = 0; + GString *part_id; + EMFormatPURI *puri; + EMFormatParserInfo info = { 0 }; - mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); + g_return_if_fail (EM_IS_FORMAT (emf)); - if (!CAMEL_IS_MULTIPART (mp)) - return NULL; + if (g_cancellable_is_cancelled (cancellable)) + return; - nparts = camel_multipart_get_number (mp); - content_type = camel_mime_part_get_content_type (part); - start = camel_content_type_param (content_type, "start"); - if (start && strlen (start) > 2) { - gint len; - const gchar *cid; + if (message) { + g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message)); - /* strip <>'s */ - len = strlen (start) - 2; - start++; + if (emf->message) + g_object_unref (emf->message); + emf->message = g_object_ref (message); + } - for (i = 0; i < nparts; i++) { - body_part = camel_multipart_get_part (mp, i); - cid = camel_mime_part_get_content_id (body_part); + if (folder) { + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - if (cid && !strncmp (cid, start, len) && strlen (cid) == len) { - display_part = body_part; - displayid = i; - break; - } - } - } else { - display_part = camel_multipart_get_part (mp, 0); + if (emf->folder) + g_object_unref (emf->folder); + emf->folder = g_object_ref (folder); } - if (out_displayid) - *out_displayid = displayid; + /* Before the actual parsing starts, let child classes prepare themselves. */ + if (EM_FORMAT_GET_CLASS (emf)->preparse) + EM_FORMAT_GET_CLASS (emf)->preparse (emf); - return display_part; + part_id = g_string_new (".message"); + + /* Create a special PURI with entire message */ + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), + (CamelMimePart *) emf->message, part_id->str); + puri->mime_type = g_strdup ("text/html"); + em_format_add_puri (emf, puri); + + info.force_handler = TRUE; + em_format_parse_part_as (emf, CAMEL_MIME_PART (emf->message), part_id, &info, + "x-evolution/message", cancellable); + + g_string_free (part_id, TRUE); } -static gboolean -related_display_part_is_attachment (EMFormat *emf, - CamelMimePart *part) +void +em_format_write (EMFormat *emf, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) { - CamelMimePart *display_part; + EMFormatClass *emf_class; - display_part = get_related_display_part (part, NULL); - return display_part && em_format_is_attachment (emf, display_part); + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (CAMEL_IS_STREAM (stream)); + + emf_class = EM_FORMAT_GET_CLASS (emf); + if (emf_class->write) + emf_class->write (emf, stream, info, cancellable); } static void -emf_write_related (EMFormat *emf, - CamelStream *stream, - EMFormatPURI *puri, - GCancellable *cancellable) +emf_start_async_parser (GSimpleAsyncResult *result, + GObject *object, + GCancellable *cancellable) { - em_format_format_content (emf, stream, puri->part, cancellable); - camel_stream_close (stream, cancellable, NULL); + em_format_parse (EM_FORMAT (object), NULL, NULL, cancellable); } -/* RFC 2387 */ -static void -emf_multipart_related (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, +void +em_format_parse_async (EMFormat *emf, + CamelMimeMessage *message, + CamelFolder *folder, GCancellable *cancellable, - gboolean is_fallback) + GAsyncReadyCallback callback, + gpointer user_data) { - CamelMultipart *mp; - CamelMimePart *body_part, *display_part = NULL; - gint i, nparts, partidlen, displayid = 0; - gchar *oldpartid; - GList *link; + GSimpleAsyncResult *result; - mp = (CamelMultipart *) camel_medium_get_content ((CamelMedium *) part); + g_return_if_fail (EM_IS_FORMAT (emf)); - if (!CAMEL_IS_MULTIPART (mp)) { - em_format_format_source (emf, stream, part, cancellable); + if (g_cancellable_is_cancelled (cancellable)) return; - } - display_part = get_related_display_part (part, &displayid); - - if (display_part == NULL) { - emf_multipart_mixed ( - emf, stream, part, info, cancellable, is_fallback); - return; - } + if (message) { + g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message)); - em_format_push_level (emf); + if (emf->message) + g_object_unref (emf->message); - oldpartid = g_strdup (emf->part_id->str); - partidlen = emf->part_id->len; + emf->message = g_object_ref (message); - /* queue up the parts for possible inclusion */ - nparts = camel_multipart_get_number (mp); - for (i = 0; i < nparts; i++) { - body_part = camel_multipart_get_part (mp, i); - if (body_part != display_part) { - /* set the partid since add_puri uses it */ - g_string_append_printf(emf->part_id, ".related.%d", i); - em_format_add_puri ( - emf, sizeof (EMFormatPURI), NULL, - body_part, emf_write_related); - g_string_truncate (emf->part_id, partidlen); - } } - g_string_append_printf(emf->part_id, ".related.%d", displayid); - em_format_part (emf, stream, display_part, cancellable); - g_string_truncate (emf->part_id, partidlen); - camel_stream_flush (stream, NULL, NULL); + if (folder) { + g_return_if_fail (CAMEL_IS_FOLDER (folder)); - link = g_queue_peek_head_link (emf->pending_uri_level->data); - - while (link && link->next != NULL) { - EMFormatPURI *puri = link->data; + if (emf->folder) + g_object_unref (emf->folder); - if (puri->use_count == 0) { - if (puri->func == emf_write_related) { - g_string_printf(emf->part_id, "%s", puri->part_id); - em_format_part ( - emf, stream, puri->part, cancellable); - } - } + emf->folder = g_object_ref (folder); - link = g_list_next (link); } - g_string_printf(emf->part_id, "%s", oldpartid); - g_free (oldpartid); - - em_format_pull_level (emf); + result = g_simple_async_result_new (G_OBJECT (emf), callback, + user_data, em_format_parse_async); + g_simple_async_result_run_in_thread (result, emf_start_async_parser, + G_PRIORITY_DEFAULT, cancellable); } -static void -emf_multipart_signed (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +void +em_format_parse_part_as (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + const gchar *mime_type, + GCancellable *cancellable) { - CamelMimePart *cpart; - CamelMultipartSigned *mps; - CamelCipherContext *cipher = NULL; - EMFormatCache *emfc; - - /* should this perhaps run off a key of ".secured" ? */ - emfc = g_hash_table_lookup (emf->inline_table, emf->part_id->str); - if (emfc && emfc->valid) { - em_format_format_secure ( - emf, stream, emfc->secured, - camel_cipher_validity_clone (emfc->valid), - cancellable); - return; - } + const EMFormatHandler *handler; + const CamelContentDisposition *disposition; + EMFormatParserInfo ninfo = { + .handler = 0, + .validity_type = info ? info->validity_type : 0, + .validity = info ? info->validity : 0, + .force_handler = 0 + }; + + /* Let everything that claims to be an attachment or inlined part to be parsed + * as an attachment. The parser will decide how to display it. */ + disposition = camel_mime_part_get_content_disposition (part); + if (!info->force_handler && disposition && + (g_strcmp0 (disposition->disposition, "attachment") == 0)) { + ninfo.is_attachment = TRUE; + handler = em_format_find_handler (emf, "x-evolution/message/attachment"); + ninfo.handler = handler; + + if (handler && handler->parse_func) + handler->parse_func (emf, part, part_id, &ninfo, cancellable); - mps = (CamelMultipartSigned *) camel_medium_get_content ((CamelMedium *) part); - if (!CAMEL_IS_MULTIPART_SIGNED (mps) - || (cpart = camel_multipart_get_part ((CamelMultipart *) mps, - CAMEL_MULTIPART_SIGNED_CONTENT)) == NULL) { - em_format_format_error ( - emf, stream, _("Could not parse MIME message. " - "Displaying as source.")); - em_format_format_source (emf, stream, part, cancellable); return; } - /* FIXME: Should be done via a plugin interface */ - /* FIXME: duplicated in em-format-html-display.c */ - if (mps->protocol) { -#ifdef ENABLE_SMIME - if (g_ascii_strcasecmp ("application/x-pkcs7-signature", mps->protocol) == 0 - || g_ascii_strcasecmp ("application/pkcs7-signature", mps->protocol) == 0) { - cipher = camel_smime_context_new (emf->session); - emf->validity_found |= EM_FORMAT_VALIDITY_FOUND_SMIME; - } else -#endif - if (g_ascii_strcasecmp ("application/pgp-signature", mps->protocol) == 0) { - cipher = camel_gpg_context_new (emf->session); - emf->validity_found |= EM_FORMAT_VALIDITY_FOUND_PGP; - } - } - - emf->validity_found |= EM_FORMAT_VALIDITY_FOUND_SIGNED; - - if (cipher == NULL) { - em_format_format_error(emf, stream, _("Unsupported signature format")); - em_format_part_as ( - emf, stream, part, - "multipart/mixed", cancellable); + handler = em_format_find_handler (emf, mime_type); + if (handler && handler->parse_func) { + ninfo.handler = handler; + handler->parse_func (emf, part, part_id, &ninfo, cancellable); } else { - CamelCipherValidity *valid; - GError *local_error = NULL; + handler = em_format_find_handler (emf, "x-evolution/message/attachment"); + ninfo.handler = handler; - valid = camel_cipher_context_verify_sync ( - cipher, part, cancellable, &local_error); - if (valid == NULL) { - em_format_format_error ( - emf, stream, local_error->message ? - _("Error verifying signature") : - _("Unknown error verifying signature")); - if (local_error->message != NULL) - em_format_format_error ( - emf, stream, "%s", - local_error->message); - g_clear_error (&local_error); + /* When this fails, something is probably very wrong...*/ + if (handler && handler->parse_func) + handler->parse_func (emf, part, part_id, &ninfo, cancellable); + } +} - em_format_part_as ( - emf, stream, part, - "multipart/mixed", cancellable); - } else { - if (emfc == NULL) - emfc = emf_insert_cache (emf, emf->part_id->str); +void +em_format_parse_part (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable) +{ + CamelContentType *ct; + gchar *mime_type; - emfc->valid = camel_cipher_validity_clone (valid); - g_object_ref ((emfc->secured = cpart)); + ct = camel_mime_part_get_content_type (part); + if (ct) { + mime_type = camel_content_type_simple (ct); + } else { + mime_type = (gchar *) "text/plain"; + } - add_validity_found (emf, valid); - em_format_format_secure ( - emf, stream, cpart, valid, cancellable); - } + em_format_parse_part_as (emf, part, part_id, info, mime_type, cancellable); - g_object_unref (cipher); - } + if (ct) + g_free (mime_type); } -/* RFC 4155 */ -static void -emf_application_mbox (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +gboolean +em_format_is_inline (EMFormat *emf, + const gchar *part_id, + CamelMimePart *part, + const EMFormatHandler *handler) { - const EMFormatHandler *handle; - CamelMimeParser *parser; - CamelStream *mem_stream; - camel_mime_parser_state_t state; - - /* Extract messages from the application/mbox part and - * render them as a flat list of messages. */ - - /* XXX If the mbox has multiple messages, maybe render them - * as a multipart/digest so each message can be expanded - * or collapsed individually. - * - * See attachment_handler_mail_x_uid_list() for example. */ + EMFormatClass *klass; - /* XXX This is based on em_utils_read_messages_from_stream(). - * Perhaps refactor that function to return an array of - * messages instead of assuming we want to append them - * to a folder? */ + g_return_val_if_fail (EM_IS_FORMAT (emf), FALSE); + g_return_val_if_fail (part_id && *part_id, FALSE); + g_return_val_if_fail (CAMEL_IS_MIME_PART (part), FALSE); + g_return_val_if_fail (handler, FALSE); - handle = em_format_find_handler (emf, "x-evolution/message/rfc822"); - g_return_if_fail (handle != NULL); + klass = EM_FORMAT_GET_CLASS (emf); + g_return_val_if_fail (klass->is_inline != NULL, FALSE); - parser = camel_mime_parser_new (); - camel_mime_parser_scan_from (parser, TRUE); + return klass->is_inline (emf, part_id, part, handler); - mem_stream = camel_stream_mem_new (); - camel_data_wrapper_decode_to_stream_sync ( - camel_medium_get_content (CAMEL_MEDIUM (mime_part)), - mem_stream, NULL, NULL); - g_seekable_seek (G_SEEKABLE (mem_stream), 0, G_SEEK_SET, NULL, NULL); - camel_mime_parser_init_with_stream (parser, mem_stream, NULL); - g_object_unref (mem_stream); +} - /* Extract messages from the mbox. */ - state = camel_mime_parser_step (parser, NULL, NULL); - while (state == CAMEL_MIME_PARSER_STATE_FROM) { - CamelMimeMessage *message; +void +em_format_format_error (EMFormat *emf, + const gchar *format, + ...) +{ + EMFormatPURI *puri; + CamelMimePart *part; + const EMFormatHandler *handler; + gchar *errmsg; + gchar *uri; + va_list ap; - message = camel_mime_message_new (); - mime_part = CAMEL_MIME_PART (message); + g_return_if_fail (EM_IS_FORMAT (emf)); + g_return_if_fail (format != NULL); - if (!camel_mime_part_construct_from_parser_sync ( - mime_part, parser, NULL, NULL)) { - g_object_unref (message); - break; - } + va_start (ap, format); + errmsg = g_strdup_vprintf (format, ap); - /* Render the message. */ - handle->handler ( - emf, stream, mime_part, - handle, cancellable, FALSE); + part = camel_mime_part_new (); + camel_mime_part_set_content (part, errmsg, strlen (errmsg), "text/plain"); + g_free (errmsg); + va_end (ap); - g_object_unref (message); + handler = em_format_find_handler (emf, "x-evolution/error"); - /* Skip past CAMEL_MIME_PARSER_STATE_FROM_END. */ - camel_mime_parser_step (parser, NULL, NULL); + emf->priv->last_error++; + uri = g_strdup_printf (".error.%d", emf->priv->last_error); + puri = em_format_puri_new (emf, sizeof (EMFormatPURI), part, uri); + puri->mime_type = g_strdup ("text/html"); + if (handler && handler->write_func) + puri->write_func = handler->write_func; + else + puri->write_func = emf_write_error; - state = camel_mime_parser_step (parser, NULL, NULL); - } + em_format_add_puri (emf, puri); - g_object_unref (parser); + g_free (uri); + g_object_unref (part); } -static void -emf_message_rfc822 (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +/** + * em_format_format_text: + * @emf: + * @stream: Where to write the converted text + * @part: Part whose container is to be formatted + * @cancellable: optional #GCancellable object, or %NULL + * + * Decode/output a part's content to @stream. + **/ +void +em_format_format_text (EMFormat *emf, + CamelStream *stream, + CamelDataWrapper *dw, + GCancellable *cancellable) { - CamelDataWrapper *dw = camel_medium_get_content ((CamelMedium *) part); - const EMFormatHandler *handle; - gint len; - gchar *parent_message_part_id; + CamelStream *filter_stream; + CamelMimeFilter *filter; + const gchar *charset = NULL; + CamelMimeFilterWindows *windows = NULL; + CamelStream *mem_stream = NULL; + gsize size; + gsize max; + GSettings *settings; - if (!CAMEL_IS_MIME_MESSAGE (dw)) { - em_format_format_source (emf, stream, part, cancellable); + if (g_cancellable_is_cancelled (cancellable)) return; - } - - parent_message_part_id = emf->current_message_part_id; - emf->current_message_part_id = g_strdup (emf->part_id->str); - len = emf->part_id->len; - g_string_append_printf(emf->part_id, ".rfc822"); - - handle = em_format_find_handler(emf, "x-evolution/message/rfc822"); - if (handle) - handle->handler ( - emf, stream, CAMEL_MIME_PART (dw), - handle, cancellable, FALSE); + if (emf->priv->charset) { + charset = emf->priv->charset; + } else if (dw->mime_type + && (charset = camel_content_type_param (dw->mime_type, "charset")) + && g_ascii_strncasecmp(charset, "iso-8859-", 9) == 0) { + CamelStream *null; - g_string_truncate (emf->part_id, len); + /* Since a few Windows mailers like to claim they sent + * out iso-8859-# encoded text when they really sent + * out windows-cp125#, do some simple sanity checking + * before we move on... */ - g_free (emf->current_message_part_id); - emf->current_message_part_id = parent_message_part_id; -} + null = camel_stream_null_new (); + filter_stream = camel_stream_filter_new (null); + g_object_unref (null); -static void -emf_message_deliverystatus (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) -{ - em_format_format_text ( - emf, stream, (CamelDataWrapper *) part, cancellable); -} + windows = (CamelMimeFilterWindows *) camel_mime_filter_windows_new (charset); + camel_stream_filter_add ( + CAMEL_STREAM_FILTER (filter_stream), + CAMEL_MIME_FILTER (windows)); -static void -emf_inlinepgp_signed (EMFormat *emf, - CamelStream *stream, - CamelMimePart *ipart, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) -{ - CamelStream *filtered_stream; - CamelMimeFilterPgp *pgp_filter; - CamelContentType *content_type; - CamelCipherContext *cipher; - CamelCipherValidity *valid; - CamelDataWrapper *dw; - CamelMimePart *opart; - CamelStream *ostream; - gchar *type; - GError *local_error = NULL; + camel_data_wrapper_decode_to_stream_sync ( + dw, (CamelStream *) filter_stream, cancellable, NULL); + camel_stream_flush ((CamelStream *) filter_stream, cancellable, NULL); + g_object_unref (filter_stream); - if (!ipart) { - em_format_format_error(emf, stream, _("Unknown error verifying signature")); - return; + charset = camel_mime_filter_windows_real_charset (windows); + } else if (charset == NULL) { + charset = emf->priv->default_charset; } - emf->validity_found |= - EM_FORMAT_VALIDITY_FOUND_SIGNED | - EM_FORMAT_VALIDITY_FOUND_PGP; + mem_stream = (CamelStream *) camel_stream_mem_new (); + filter_stream = camel_stream_filter_new (mem_stream); - cipher = camel_gpg_context_new (emf->session); - /* Verify the signature of the message */ - valid = camel_cipher_context_verify_sync ( - cipher, ipart, cancellable, &local_error); - if (!valid) { - em_format_format_error ( - emf, stream, local_error->message ? - _("Error verifying signature") : - _("Unknown error verifying signature")); - if (local_error->message) - em_format_format_error ( - emf, stream, "%s", local_error->message); - em_format_format_source (emf, stream, ipart, cancellable); - /* XXX I think this will loop: - * em_format_part_as(emf, stream, part, "text/plain"); */ - g_clear_error (&local_error); - g_object_unref (cipher); - return; + if ((filter = camel_mime_filter_charset_new (charset, "UTF-8"))) { + camel_stream_filter_add ( + CAMEL_STREAM_FILTER (filter_stream), + CAMEL_MIME_FILTER (filter)); + g_object_unref (filter); } - /* Setup output stream */ - ostream = camel_stream_mem_new (); - filtered_stream = camel_stream_filter_new (ostream); - - /* Add PGP header / footer filter */ - pgp_filter = (CamelMimeFilterPgp *) camel_mime_filter_pgp_new (); - camel_stream_filter_add ( - CAMEL_STREAM_FILTER (filtered_stream), - CAMEL_MIME_FILTER (pgp_filter)); - g_object_unref (pgp_filter); - - /* Pass through the filters that have been setup */ - dw = camel_medium_get_content ((CamelMedium *) ipart); - camel_data_wrapper_decode_to_stream_sync ( - dw, (CamelStream *) filtered_stream, NULL, NULL); - camel_stream_flush ((CamelStream *) filtered_stream, NULL, NULL); - g_object_unref (filtered_stream); + max = -1; - /* Create a new text/plain MIME part containing the signed - * content preserving the original part's Content-Type params. */ - content_type = camel_mime_part_get_content_type (ipart); - type = camel_content_type_format (content_type); - content_type = camel_content_type_decode (type); - g_free (type); + settings = g_settings_new ("org.gnome.evolution.mail"); + if (g_settings_get_boolean (settings, "force-message-limit")) { + max = g_settings_get_int (settings, "message-text-part-limit"); + if (max == 0) + max = -1; + } + g_object_unref (settings); - g_free (content_type->type); - content_type->type = g_strdup ("text"); - g_free (content_type->subtype); - content_type->subtype = g_strdup ("plain"); - type = camel_content_type_format (content_type); - camel_content_type_unref (content_type); + size = camel_data_wrapper_decode_to_stream_sync ( + camel_medium_get_content ((CamelMedium *) dw), + (CamelStream *) filter_stream, cancellable, NULL); + camel_stream_flush ((CamelStream *) filter_stream, cancellable, NULL); + g_object_unref (filter_stream); - dw = camel_data_wrapper_new (); - camel_data_wrapper_construct_from_stream_sync (dw, ostream, NULL, NULL); - camel_data_wrapper_set_mime_type (dw, type); - g_free (type); + g_seekable_seek (G_SEEKABLE (mem_stream), 0, G_SEEK_SET, NULL, NULL); - opart = camel_mime_part_new (); - camel_medium_set_content ((CamelMedium *) opart, dw); - camel_data_wrapper_set_mime_type_field ( - (CamelDataWrapper *) opart, dw->mime_type); + if (max == -1 || size == -1 || size < (max * 1024) || emf->priv->composer) { + camel_stream_write_to_stream ( + mem_stream, (CamelStream *) stream, cancellable, NULL); + camel_stream_flush ((CamelStream *) mem_stream, cancellable, NULL); + } else { + /* Parse it as an attachment */ + CamelMimePart *part = camel_mime_part_new (); + EMFormatParserInfo info = { 0 }; + GString *part_id = g_string_new (".attachment"); + camel_medium_set_content ((CamelMedium *) part, dw); + + info.is_attachment = TRUE; + em_format_parse_part_as (emf, part, part_id, &info, + "x-evolution/message/attachment", cancellable); + + g_string_free (part_id, TRUE); + g_object_unref (part); + } - add_validity_found (emf, valid); - /* Pass it off to the real formatter */ - em_format_format_secure (emf, stream, opart, valid, cancellable); + if (windows) + g_object_unref (windows); - /* Clean Up */ - g_object_unref (dw); - g_object_unref (opart); - g_object_unref (ostream); - g_object_unref (cipher); + g_object_unref (mem_stream); } -static void -emf_inlinepgp_encrypted (EMFormat *emf, - CamelStream *stream, - CamelMimePart *ipart, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback) +/** + * em_format_describe_part: + * @part: + * @mimetype: + * + * Generate a simple textual description of a part, @mime_type represents + * the content. + * + * Return value: + **/ +gchar * +em_format_describe_part (CamelMimePart *part, + const gchar *mime_type) { - CamelCipherContext *cipher; - CamelCipherValidity *valid; - CamelMimePart *opart; - CamelDataWrapper *dw; - gchar *mime_type; - GError *local_error = NULL; + GString *stext; + const gchar *filename, *description; + gchar *content_type, *desc; - emf->validity_found |= - EM_FORMAT_VALIDITY_FOUND_ENCRYPTED | - EM_FORMAT_VALIDITY_FOUND_PGP; + stext = g_string_new(""); + content_type = g_content_type_from_mime_type (mime_type); + desc = g_content_type_get_description ( + content_type != NULL ? content_type : mime_type); + g_free (content_type); + g_string_append_printf ( + stext, _("%s attachment"), desc ? desc : mime_type); + g_free (desc); - cipher = camel_gpg_context_new (emf->session); - opart = camel_mime_part_new (); + filename = camel_mime_part_get_filename (part); + description = camel_mime_part_get_description (part); - /* Decrypt the message */ - valid = camel_cipher_context_decrypt_sync ( - cipher, ipart, opart, cancellable, &local_error); + if (!filename || !*filename) { + CamelDataWrapper *content; - if (!valid) { - em_format_format_error ( - emf, stream, _("Could not parse PGP message: ")); - if (local_error->message != NULL) - em_format_format_error ( - emf, stream, "%s", local_error->message); - else - em_format_format_error ( - emf, stream, _("Unknown error")); - em_format_format_source (emf, stream, ipart, cancellable); - /* XXX I think this will loop: - * em_format_part_as(emf, stream, part, "text/plain"); */ + content = camel_medium_get_content (CAMEL_MEDIUM (part)); - g_clear_error (&local_error); - g_object_unref (cipher); - g_object_unref (opart); - return; + if (CAMEL_IS_MIME_MESSAGE (content)) + filename = camel_mime_message_get_subject ( + CAMEL_MIME_MESSAGE (content)); } - dw = camel_medium_get_content ((CamelMedium *) opart); - mime_type = camel_data_wrapper_get_mime_type (dw); - - /* this ensures to show the 'opart' as inlined, if possible */ - if (mime_type != NULL && g_ascii_strcasecmp ( - mime_type, "application/octet-stream") == 0) { - const gchar *snoop = em_format_snoop_type (opart); - - if (snoop) - camel_data_wrapper_set_mime_type (dw, snoop); + if (filename != NULL && *filename != '\0') { + gchar *basename = g_path_get_basename (filename); + g_string_append_printf (stext, " (%s)", basename); + g_free (basename); } - preserve_charset_in_content_type (ipart, opart); - g_free (mime_type); - - add_validity_found (emf, valid); - /* Pass it off to the real formatter */ - em_format_format_secure (emf, stream, opart, valid, cancellable); + if (description != NULL && *description != '\0' && + g_strcmp0 (filename, description) != 0) + g_string_append_printf (stext, ", \"%s\"", description); - /* Clean Up */ - g_object_unref (opart); - g_object_unref (cipher); + return g_string_free (stext, FALSE); } -static EMFormatHandler type_builtin_table[] = { -#ifdef ENABLE_SMIME - { (gchar *) "application/x-pkcs7-mime", - emf_application_xpkcs7mime, - EM_FORMAT_HANDLER_INLINE_DISPOSITION }, -#endif - { (gchar *) "application/mbox", emf_application_mbox, EM_FORMAT_HANDLER_INLINE }, - { (gchar *) "multipart/alternative", emf_multipart_alternative }, - { (gchar *) "multipart/appledouble", emf_multipart_appledouble }, - { (gchar *) "multipart/encrypted", emf_multipart_encrypted }, - { (gchar *) "multipart/mixed", emf_multipart_mixed }, - { (gchar *) "multipart/signed", emf_multipart_signed }, - { (gchar *) "multipart/related", emf_multipart_related }, - { (gchar *) "multipart/*", emf_multipart_mixed }, - { (gchar *) "message/rfc822", emf_message_rfc822, EM_FORMAT_HANDLER_INLINE }, - { (gchar *) "message/news", emf_message_rfc822, EM_FORMAT_HANDLER_INLINE }, - { (gchar *) "message/delivery-status", emf_message_deliverystatus }, - { (gchar *) "message/*", emf_message_rfc822, EM_FORMAT_HANDLER_INLINE }, - - /* Insert brokenly-named parts here */ -#ifdef ENABLE_SMIME - { (gchar *) "application/pkcs7-mime", - emf_application_xpkcs7mime, - EM_FORMAT_HANDLER_INLINE_DISPOSITION }, -#endif - - /* internal types */ - { (gchar *) "application/x-inlinepgp-signed", emf_inlinepgp_signed }, - { (gchar *) "application/x-inlinepgp-encrypted", emf_inlinepgp_encrypted }, -}; - -static void -emf_builtin_init (EMFormatClass *class) +/** + * em_format_is_attachment: + * @emf: + * @part: Part to check. + * + * Returns true if the part is an attachment. + * + * A part is not considered an attachment if it is a + * multipart, or a text part with no filename. It is used + * to determine if an attachment header should be displayed for + * the part. + * + * Content-Disposition is not checked. + * + * Return value: TRUE/FALSE + **/ +gint +em_format_is_attachment (EMFormat *emf, + CamelMimePart *part) { - gint ii; + /*CamelContentType *ct = camel_mime_part_get_content_type(part);*/ + CamelDataWrapper *dw = camel_medium_get_content ((CamelMedium *) part); + + if (!dw) + return 0; - for (ii = 0; ii < G_N_ELEMENTS (type_builtin_table); ii++) - g_hash_table_insert ( - class->type_handlers, - type_builtin_table[ii].mime_type, - &type_builtin_table[ii]); + d(printf("checking is attachment %s/%s\n", dw->mime_type->type, dw->mime_type->subtype)); + return !(camel_content_type_is (dw->mime_type, "multipart", "*") + || camel_content_type_is ( + dw->mime_type, "application", "x-pkcs7-mime") + || camel_content_type_is ( + dw->mime_type, "application", "pkcs7-mime") + || camel_content_type_is ( + dw->mime_type, "application", "x-inlinepgp-signed") + || camel_content_type_is ( + dw->mime_type, "application", "x-inlinepgp-encrypted") + || camel_content_type_is ( + dw->mime_type, "x-evolution", "evolution-rss-feed") + || camel_content_type_is (dw->mime_type, "text", "calendar") + || camel_content_type_is (dw->mime_type, "text", "x-calendar") + || (camel_content_type_is (dw->mime_type, "text", "*") + && camel_mime_part_get_filename (part) == NULL)); } /** @@ -2493,5 +2401,237 @@ em_format_snoop_type (CamelMimePart *part) return res; /* We used to load parts to check their type, we don't anymore, - * see bug #11778 for some discussion */ + * see bug #211778 for some discussion */ +} + +/** + * Construct a URI for message. + * + * The URI can contain multiple query parameters. The list of parameters must be + * NULL-terminated. Each query must contain name, GType of value and value. + * + * @param folder Folder wit the message + * @param message_uid ID of message within the \p folder + * @param first_param_name Name of first query parameter followed by GType of it's value and value. + */ +gchar * +em_format_build_mail_uri (CamelFolder *folder, + const gchar *message_uid, + const gchar *first_param_name, + ...) +{ + CamelStore *store; + gchar *uri, *tmp; + va_list ap; + const gchar *name; + const gchar *service_uid, *folder_name; + gchar separator; + + g_return_val_if_fail (message_uid && *message_uid, NULL); + + if (!folder) { + folder_name = "generic"; + service_uid = "generic"; + } else { + folder_name = camel_folder_get_full_name (folder); + store = camel_folder_get_parent_store (folder); + if (store) + service_uid = camel_service_get_uid (CAMEL_SERVICE (store)); + else + service_uid = "generic"; + } + + tmp = g_strdup_printf ("mail://%s/%s/%s", + service_uid, + folder_name, + message_uid); + + va_start (ap, first_param_name); + name = first_param_name; + separator = '?'; + while (name) { + gchar *tmp2; + gint type = va_arg (ap, gint); + switch (type) { + case G_TYPE_INT: + case G_TYPE_BOOLEAN: { + gint val = va_arg (ap, gint); + tmp2 = g_strdup_printf ("%s%c%s=%d", tmp, + separator, name, val); + break; + } + case G_TYPE_FLOAT: + case G_TYPE_DOUBLE: { + gdouble val = va_arg (ap, double); + tmp2 = g_strdup_printf ("%s%c%s=%f", tmp, + separator, name, val); + break; + } + case G_TYPE_STRING: { + gchar *val = va_arg (ap, gchar *); + gchar *escaped = soup_uri_encode (val, NULL); + tmp2 = g_strdup_printf ("%s%c%s=%s", tmp, + separator, name, escaped); + g_free (escaped); + break; + } + default: + g_warning ("Invalid param type %s", g_type_name (type)); + return NULL; + } + + g_free (tmp); + tmp = tmp2; + + if (separator == '?') + separator = '&'; + + name = va_arg (ap, gchar *); + } + va_end (ap); + + uri = tmp; + + /* For some reason, webkit won't accept URL with username, but + * without password (mail://store@host/folder/mail), so we + * will replace the '@' symbol by '/' to get URL like + * mail://store/host/folder/mail which is OK + */ + tmp = strchr (tmp, '@'); + if (tmp) { + tmp[0] = '/'; + } + + return uri; +} + +void +em_format_redraw (EMFormat *emf) +{ + g_return_if_fail (EM_IS_FORMAT (emf)); + + g_signal_emit (emf, signals[REDRAW_REQUESTED], 0); +} + +/**************************************************************************/ +EMFormatPURI * +em_format_puri_new (EMFormat *emf, + gsize puri_size, + CamelMimePart *part, + const gchar *uri) +{ + EMFormatPURI *puri; + + g_return_val_if_fail (EM_IS_FORMAT (emf), NULL); + g_return_val_if_fail (puri_size >= sizeof (EMFormatPURI), NULL); + + puri = (EMFormatPURI *) g_malloc0 (puri_size); + puri->emf = emf; + + if (part) + puri->part = g_object_ref (part); + + if (uri) + puri->uri = g_strdup (uri); + + return puri; +} + +void +em_format_puri_free (EMFormatPURI *puri) +{ + g_return_if_fail (puri); + + if (puri->part) + g_object_unref (puri->part); + + if (puri->uri) + g_free (puri->uri); + + if (puri->cid) + g_free (puri->cid); + + if (puri->mime_type) + g_free (puri->mime_type); + + if (puri->validity) + camel_cipher_validity_free (puri->validity); + + if (puri->validity_parent) + camel_cipher_validity_free (puri->validity_parent); + + if (puri->free) + puri->free (puri); + + g_free (puri); +} + +void +em_format_puri_write (EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable) +{ + g_return_if_fail (puri); + g_return_if_fail (CAMEL_IS_STREAM (stream)); + + if (info->mode == EM_FORMAT_WRITE_MODE_SOURCE) { + const EMFormatHandler *handler; + handler = em_format_find_handler (puri->emf, "x-evolution/message/source"); + handler->write_func (puri->emf, puri, stream, info, cancellable); + return; + } + + if (puri->write_func) { + puri->write_func (puri->emf, puri, stream, info, cancellable); + } else { + const EMFormatHandler *handler; + const gchar *mime_type; + + if (puri->mime_type) { + mime_type = puri->mime_type; + } else { + mime_type = (gchar *) "plain/text"; + } + + handler = em_format_find_handler (puri->emf, mime_type); + if (handler && handler->write_func) { + handler->write_func (puri->emf, + puri, stream, info, cancellable); + } + } +} + +EMFormatHeader * +em_format_header_new (const gchar *name, + const gchar *value) +{ + EMFormatHeader *header; + + g_return_val_if_fail (name && *name, NULL); + + header = g_new0 (EMFormatHeader, 1); + header->name = g_strdup (name); + if (value && *value) + header->value = g_strdup (value); + + return header; +} + +void +em_format_header_free (EMFormatHeader * header) +{ + g_return_if_fail (header != NULL); + + if (header->name) { + g_free (header->name); + header->name = NULL; + } + + if (header->value) { + g_free (header->value); + header->value = NULL; + } + + g_free (header); } diff --git a/em-format/em-format.h b/em-format/em-format.h index cf214d81a5..712b41bce1 100644 --- a/em-format/em-format.h +++ b/em-format/em-format.h @@ -21,14 +21,11 @@ * */ -/* - Abstract class for formatting mime messages -*/ - #ifndef EM_FORMAT_H #define EM_FORMAT_H #include +#include /* Standard GObject macros */ #define EM_TYPE_FORMAT \ @@ -51,194 +48,139 @@ G_BEGIN_DECLS +#define EM_FORMAT_HEADER_BOLD (1<<0) +#define EM_FORMAT_HEADER_LAST (1<<4) /* reserve 4 slots */ + +#define EM_FORMAT_VALIDITY_FOUND_PGP (1<<0) +#define EM_FORMAT_VALIDITY_FOUND_SMIME (1<<1) +#define EM_FORMAT_VALIDITY_FOUND_SIGNED (1<<2) +#define EM_FORMAT_VALIDITY_FOUND_ENCRYPTED (1<<3) + typedef struct _EMFormat EMFormat; typedef struct _EMFormatClass EMFormatClass; typedef struct _EMFormatPrivate EMFormatPrivate; -typedef struct _EMFormatHandler EMFormatHandler; +typedef struct _EMFormatPURI EMFormatPURI; typedef struct _EMFormatHeader EMFormatHeader; +typedef struct _EMFormatHandler EMFormatHandler; +typedef struct _EMFormatParserInfo EMFormatParserInfo; +typedef struct _EMFormatWriterInfo EMFormatWriterInfo; +typedef struct _WebKitDOMElement WebKitDOMElement; -typedef void (*EMFormatFunc) (EMFormat *emf, +typedef void (*EMFormatParseFunc) (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable); +typedef void (*EMFormatWriteFunc) (EMFormat *emf, + EMFormatPURI *puri, CamelStream *stream, - CamelMimePart *mime_part, - const EMFormatHandler *info, - GCancellable *cancellable, - gboolean is_fallback); - -typedef enum { - EM_FORMAT_MODE_NORMAL, - EM_FORMAT_MODE_ALLHEADERS, - EM_FORMAT_MODE_SOURCE -} EMFormatMode; + EMFormatWriterInfo *info, + GCancellable *cancellable); +typedef GtkWidget * (*EMFormatWidgetFunc) (EMFormat *emf, + EMFormatPURI *puri, + GCancellable *cancellable); +typedef void (*EMailDisplayBindFunc) (WebKitDOMElement *root, + EMFormatPURI *puri); -/** - * EMFormatHandlerFlags - Format handler flags. - * - * @EM_FORMAT_HANDLER_INLINE: This type should be shown expanded - * inline by default. - * @EM_FORMAT_HANDLER_INLINE_DISPOSITION: This type should always be - * shown inline, despite what the Content-Disposition suggests. - * - **/ typedef enum { EM_FORMAT_HANDLER_INLINE = 1 << 0, - EM_FORMAT_HANDLER_INLINE_DISPOSITION = 1 << 1 + EM_FORMAT_HANDLER_INLINE_DISPOSITION = 1 << 1, + EM_FORMAT_HANDLER_COMPOUND_TYPE = 1 << 2 } EMFormatHandlerFlags; -/** - * struct _EMFormatHandler - MIME type handler. - * - * @mime_type: Type this handler handles. - * @handler: The handler callback. - * @flags: Handler flags - * @old: The last handler set on this type. Allows overrides to - * fallback to previous implementation. - * - **/ +typedef enum { + EM_FORMAT_WRITE_MODE_NORMAL= 1 << 0, + EM_FORMAT_WRITE_MODE_ALL_HEADERS = 1 << 1, + EM_FORMAT_WRITE_MODE_SOURCE = 1 << 2, + EM_FORMAT_WRITE_MODE_PRINTING = 1 << 3, + EM_FORMAT_WRITE_MODE_RAW = 1 << 4 +} EMFormatWriteMode; + struct _EMFormatHandler { gchar *mime_type; - EMFormatFunc handler; + EMFormatParseFunc parse_func; + EMFormatWriteFunc write_func; EMFormatHandlerFlags flags; EMFormatHandler *old; }; -typedef struct _EMFormatPURI EMFormatPURI; -typedef void (*EMFormatPURIFunc) (EMFormat *emf, - CamelStream *stream, - EMFormatPURI *puri, - GCancellable *cancellable); - /** - * struct _EMFormatPURI - Pending URI object. - * - * @free: May be set by allocator and will be called when no longer needed. - * @format: - * @uri: Calculated URI of the part, if the part has one in its - * Content-Location field. - * @cid: The RFC2046 Content-Id of the part. If none is present, a unique value - * is calculated from @part_id. - * @part_id: A unique identifier for each part. - * @func: Callback for when the URI is requested. The callback writes - * its data to the supplied stream. - * @part: - * @use_count: - * - * This is used for multipart/related, and other formatters which may - * need to include a reference to out-of-band data in the content - * stream. - * - * This object may be subclassed as a struct. - **/ -struct _EMFormatPURI { - void (*free)(EMFormatPURI *p); /* optional callback for freeing user-fields */ - EMFormat *format; + * Use this struct to pass additional information between + * EMFormatParseFunc's. + * Much cleaner then setting public property of EMFormat. + */ +struct _EMFormatParserInfo { + const EMFormatHandler *handler; - gchar *uri; /* will be the location of the part, may be empty */ - gchar *cid; /* will always be set, a fake one created if needed */ - gchar *part_id; /* will always be set, emf->part_id->str for this part */ + /* EM_FORMAT_VALIDITY_* flags */ + guint32 validity_type; + CamelCipherValidity *validity; - EMFormatPURIFunc func; - CamelMimePart *part; + gint is_attachment : 1; + gint force_handler: 1; +}; - guint use_count; /* used by multipart/related to see if it was accessed */ +struct _EMFormatWriterInfo { + EMFormatWriteMode mode; + gboolean headers_collapsable; + gboolean headers_collapsed; }; struct _EMFormatHeader { guint32 flags; /* E_FORMAT_HEADER_ * */ - gchar name[1]; + gchar *name; + gchar *value; }; #define EM_FORMAT_HEADER_BOLD (1<<0) #define EM_FORMAT_HEADER_LAST (1<<4) /* reserve 4 slots */ -#define EM_FORMAT_VALIDITY_FOUND_PGP (1<<0) -#define EM_FORMAT_VALIDITY_FOUND_SMIME (1<<1) -#define EM_FORMAT_VALIDITY_FOUND_SIGNED (1<<2) -#define EM_FORMAT_VALIDITY_FOUND_ENCRYPTED (1<<3) +struct _EMFormatPURI { + CamelMimePart *part; + + EMFormat *emf; + EMFormatWriteFunc write_func; + EMFormatWidgetFunc widget_func; + + /** + * Called by #EMailDisplay whenever document/frame is reloaded. + * Modules and plugins can create bindings to events of DOM + * objects they created. + */ + EMailDisplayBindFunc bind_func; + + gchar *uri; + gchar *cid; + gchar *mime_type; + + /* EM_FORMAT_VALIDITY_* flags */ + guint32 validity_type; + CamelCipherValidity *validity; + CamelCipherValidity *validity_parent; + + gboolean is_attachment; + + void (*free)(EMFormatPURI *puri); /* optional callback for freeing user-fields */ +}; -/** - * struct _EMFormat - Mail formatter object. - * - * @parent: - * @priv: - * @message: - * @folder: - * @uid: - * @part_id: - * @header_list: - * @session: - * @base url: - * @snoop_mime_type: - * @valid: - * @valid_parent: - * @inline_table: - * @pending_uri_table: - * @pending_uri_tree: - * @pending_uri_level: - * @mode: - * @charset: - * @default_charset: - * - * Most fields are private or read-only. - * - * This is the base MIME formatter class. It provides no formatting - * itself, but drives most of the basic types, including multipart / * types. - **/ struct _EMFormat { GObject parent; EMFormatPrivate *priv; - /* The current message */ CamelMimeMessage *message; - CamelFolder *folder; - gchar *uid; + gchar *message_uid; + gchar *uri_base; - /* Current part ID prefix for identifying parts directly. */ - GString *part_id; - /* part_id of the currently processing message - * (when the message has message-attachments) */ - gchar *current_message_part_id; + /* Defines order in which parts should be displayed */ + GList *mail_part_list; + /* For quick search for parts by their URI/ID */ + GHashTable *mail_part_table; /* If empty, then all. */ GQueue header_list; - - /* Used for authentication when required. */ - CamelSession *session; - - /* Content-Base header or absolute Content-Location, for any part. */ - CamelURL *base; - - /* If we snooped an application/octet-stream, what we snooped. */ - const gchar *snoop_mime_type; - - /* For validity enveloping. */ - CamelCipherValidity *valid; - CamelCipherValidity *valid_parent; - - /* For checking whether we found any signed or encrypted parts. */ - guint32 validity_found; - - /* For forcing inlining. */ - GHashTable *inline_table; - - /* Global URI lookup table for message. */ - GHashTable *pending_uri_table; - - /* This structure is used internally to form a visibility tree of - * parts in the current formatting stream. This is to implement the - * part resolution rules for RFC2387 to implement multipart/related. */ - GNode *pending_uri_tree; - - /* The current level to search from. */ - GNode *pending_uri_level; - - EMFormatMode mode; /* source/headers/etc */ - gchar *charset; /* charset override */ - gchar *default_charset; /* charset fallback */ - gboolean composer; /* formatting from composer? */ - gboolean print; /* formatting for printing? */ }; struct _EMFormatClass { @@ -246,187 +188,161 @@ struct _EMFormatClass { GHashTable *type_handlers; - /* lookup handler, default falls back to hashtable above */ - const EMFormatHandler * - (*find_handler) (EMFormat *emf, - const gchar *mime_type); - - /* start formatting a message */ - void (*format_clone) (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *message, - EMFormat *source, - GCancellable *cancellable); - - /* some internel error/inconsistency */ - void (*format_error) (EMFormat *emf, - CamelStream *stream, - const gchar *errmsg); - - /* use for external structured parts */ - void (*format_attachment) (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - const gchar *mime_type, - const EMFormatHandler *info, - GCancellable *cancellable); + gboolean (*is_inline) (EMFormat *emf, + const gchar *part_id, + CamelMimePart *part, + const EMFormatHandler *handler); - /* use for unparsable content */ - void (*format_source) (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - GCancellable *cancellable); - /* for outputing secure(d) content */ - void (*format_secure) (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - CamelCipherValidity *validity, - GCancellable *cancellable); + /* Write the entire message to stream */ + void (*write) (EMFormat *emf, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable); - /* returns true if the formatter is still busy with pending stuff */ - gboolean (*busy) (EMFormat *); - - /* Shows optional way to open messages */ - void (*format_optional) (EMFormat *emf, - CamelStream *filter_stream, - CamelMimePart *mime_part, - CamelStream *mem_stream, - GCancellable *cancellable); - - gboolean (*is_inline) (EMFormat *emf, - const gchar *part_id, - CamelMimePart *mime_part, - const EMFormatHandler *handle); + void (*preparse) (EMFormat *emf); /* signals */ - /* complete, alternative to polling busy, for asynchronous work */ - void (*complete) (EMFormat *emf); -}; + void (*redraw_requested) (EMFormat *emf); -void em_format_set_mode (EMFormat *emf, - EMFormatMode mode); -void em_format_set_charset (EMFormat *emf, - const gchar *charset); -void em_format_set_default_charset (EMFormat *emf, - const gchar *charset); - -/* also indicates to show all headers */ -void em_format_clear_headers (EMFormat *emf); - -void em_format_default_headers (EMFormat *emf); -void em_format_add_header (EMFormat *emf, - const gchar *name, - guint32 flags); - -/* FIXME: Need a 'clone' api to copy details about the current view (inlines etc) - * Or maybe it should live with sub-classes? */ - -gint em_format_is_attachment (EMFormat *emf, - CamelMimePart *part); - -gboolean em_format_is_inline (EMFormat *emf, - const gchar *part_id, - CamelMimePart *mime_part, - const EMFormatHandler *handle); -void em_format_set_inline (EMFormat *emf, - const gchar *partid, - gint state); - -gchar * em_format_describe_part (CamelMimePart *part, - const gchar *mime_type); - -/* for implementers */ -GType em_format_get_type (void); - -void em_format_class_add_handler (EMFormatClass *emfc, - EMFormatHandler *info); -void em_format_class_remove_handler (EMFormatClass *emfc, - EMFormatHandler *info); -const EMFormatHandler * - em_format_find_handler (EMFormat *emf, - const gchar *mime_type); -const EMFormatHandler * - em_format_fallback_handler (EMFormat *emf, - const gchar *mime_type); - -/* puri is short for pending uri ... really */ -EMFormatPURI * em_format_add_puri (EMFormat *emf, - gsize size, - const gchar *uri, - CamelMimePart *part, - EMFormatPURIFunc func); -EMFormatPURI * em_format_find_visible_puri (EMFormat *emf, - const gchar *uri); -EMFormatPURI * em_format_find_puri (EMFormat *emf, - const gchar *uri); -void em_format_clear_puri_tree (EMFormat *emf); -void em_format_push_level (EMFormat *emf); -void em_format_pull_level (EMFormat *emf); - -/* clones inline state/view and format, or use to redraw */ -void em_format_format_clone (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *message, - EMFormat *source, - GCancellable *cancellable); - -/* formats a new message */ -void em_format_format (EMFormat *emf, - CamelFolder *folder, - const gchar *uid, - CamelMimeMessage *message, - GCancellable *cancellable); -void em_format_queue_redraw (EMFormat *emf); -void em_format_format_attachment (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - const gchar *mime_type, - const EMFormatHandler *info, - GCancellable *cancellable); -void em_format_format_error (EMFormat *emf, - CamelStream *stream, - const gchar *format, - ...) G_GNUC_PRINTF (3, 4); -void em_format_format_secure (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - CamelCipherValidity *valid, - GCancellable *cancellable); -void em_format_format_source (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - GCancellable *cancellable); - -gboolean em_format_busy (EMFormat *emf); - -/* raw content only */ -void em_format_format_content (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - GCancellable *cancellable); - -/* raw content text parts - should this just be checked/done by above? */ -void em_format_format_text (EMFormat *emf, - CamelStream *stream, - CamelDataWrapper *part, - GCancellable *cancellable); - -void em_format_part_as (EMFormat *emf, - CamelStream *stream, - CamelMimePart *part, - const gchar *mime_type, - GCancellable *cancellable); -void em_format_part (EMFormat *emf, - CamelStream *stream, - CamelMimePart *mime_part, - GCancellable *cancellable); -void em_format_merge_handler (EMFormat *new, - EMFormat *old); - -const gchar * em_format_snoop_type (CamelMimePart *part); +}; -G_END_DECLS +EMFormat * em_format_new (void); + +GType em_format_get_type (void); + +void em_format_set_charset (EMFormat *emf, + const gchar *charset); +const gchar * em_format_get_charset (EMFormat *emf); + +void em_format_set_default_charset (EMFormat *emf, + const gchar *charset); +const gchar * em_format_get_default_charset (EMFormat *emf); + +void em_format_set_composer (EMFormat *emf, + gboolean composer); +gboolean em_format_get_composer (EMFormat *emf); + +void em_format_set_base_url (EMFormat *emf, + CamelURL *url); +void em_format_set_base_url_string (EMFormat *emf, + const gchar *url_string); +CamelURL * em_format_get_base_url (EMFormat *emf); + +void em_format_clear_headers (EMFormat *emf); + +void em_format_default_headers (EMFormat *emf); + +void em_format_add_header (EMFormat *emf, + const gchar *name, + const gchar *value, + guint32 flags); +void em_format_add_header_struct (EMFormat *emf, + EMFormatHeader *header); +void em_format_remove_header (EMFormat *emf, + const gchar *name, + const gchar *value); +void em_format_remove_header_struct (EMFormat *emf, + const EMFormatHeader *header); + +void em_format_add_puri (EMFormat *emf, + EMFormatPURI *puri); +EMFormatPURI * em_format_find_puri (EMFormat *emf, + const gchar *id); + +void em_format_class_add_handler (EMFormatClass *emfc, + EMFormatHandler *handler); +void em_format_class_remove_handler (EMFormatClass *emfc, + EMFormatHandler *handler); + +const EMFormatHandler * em_format_find_handler (EMFormat *emf, + const gchar *mime_type); +const EMFormatHandler * em_format_fallback_handler (EMFormat *emf, + const gchar *mime_type); + +void em_format_parse (EMFormat *emf, + CamelMimeMessage *message, + CamelFolder *folder, + GCancellable *cancellable); + +void em_format_write (EMFormat *emf, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable); + +void em_format_parse_async (EMFormat *emf, + CamelMimeMessage *message, + CamelFolder *folder, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +void em_format_parse_part (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable); +void em_format_parse_part_as (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + const gchar *mime_type, + GCancellable *cancellable); +gboolean em_format_is_inline (EMFormat *emf, + const gchar *part_id, + CamelMimePart *part, + const EMFormatHandler *handler); + +gchar * em_format_get_error_id (EMFormat *emf); + +void em_format_format_error (EMFormat *emf, + const gchar *format, + ...) G_GNUC_PRINTF (2, 3); +void em_format_format_text (EMFormat *emf, + CamelStream *stream, + CamelDataWrapper *dw, + GCancellable *cancellable); +gchar * em_format_describe_part (CamelMimePart *part, + const gchar *mime_type); +gint em_format_is_attachment (EMFormat *emf, + CamelMimePart *part); +const gchar * em_format_snoop_type (CamelMimePart *part); + +gchar * em_format_build_mail_uri (CamelFolder *folder, + const gchar *message_uid, + const gchar *part_uid, + ...) G_GNUC_NULL_TERMINATED; + +/* EMFormatParseFunc that does nothing. Use it to disable + * parsing of a specific mime type parts */ +void em_format_empty_parser (EMFormat *emf, + CamelMimePart *part, + GString *part_id, + EMFormatParserInfo *info, + GCancellable *cancellable); + +/* EMFormatWriteFunc that does nothing. Use it to disable + * writing of a specific mime type parts */ +void em_format_empty_writer (EMFormat *emf, + EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable); + +void em_format_redraw (EMFormat *emf); + +EMFormatPURI * em_format_puri_new (EMFormat *emf, + gsize puri_size, + CamelMimePart *part, + const gchar *uri); +void em_format_puri_free (EMFormatPURI *puri); + +void em_format_puri_write (EMFormatPURI *puri, + CamelStream *stream, + EMFormatWriterInfo *info, + GCancellable *cancellable); + +EMFormatHeader * em_format_header_new (const gchar *name, + const gchar *value); +void em_format_header_free (EMFormatHeader *header); #endif /* EM_FORMAT_H */ -- cgit v1.2.3