[evolution-data-server/camel-gobject] Minor changes to sync with master.

[Matthew Barnes <mbarnes src gnome org>]

commit 4f5b662b6d697a46739a3dac77ef9472c29046ba
Author: Matthew Barnes <mbarnes redhat com>
Date:   Sun Apr 4 11:08:30 2010 -0400

    Minor changes to sync with master.

 camel/camel-block-file.c           |    2 +-
 camel/camel-cipher-context.c       |   18 ++--
 camel/camel-debug.c                |    2 +-
 camel/camel-disco-diary.h          |    2 +-
 camel/camel-file-utils.c           |    2 -
 camel/camel-gpg-context.c          |    3 +-
 camel/camel-index-control.c        |    4 +-
 camel/camel-medium.c               |    2 +-
 camel/camel-medium.h               |    8 +-
 camel/camel-mime-filter-basic.c    |    2 +-
 camel/camel-mime-filter-enriched.c |   48 +++++-----
 camel/camel-mime-filter-from.c     |   30 +++---
 camel/camel-mime-filter-gzip.c     |  134 ++++++++++++++------------
 camel/camel-mime-filter-html.c     |   51 ++++++----
 camel/camel-mime-filter-progress.c |   11 +-
 camel/camel-mime-filter-save.c     |    7 ++
 camel/camel-mime-filter-windows.c  |    5 +-
 camel/camel-mime-filter-yenc.c     |  185 +++++++++++++++++++----------------
 camel/camel-mime-message.c         |   15 ++--
 camel/camel-mime-message.h         |   12 +-
 camel/camel-net-utils.h            |    4 +-
 camel/camel-nntp-address.c         |    5 -
 camel/camel-sasl-anonymous.c       |   22 ++--
 camel/camel-sasl-digest-md5.c      |    2 +-
 camel/camel-sasl-plain.c           |    1 -
 camel/camel-search-private.c       |    2 -
 camel/camel-session.c              |    5 +-
 camel/camel-smime-context.c        |   21 ++++-
 28 files changed, 329 insertions(+), 276 deletions(-)
---
diff --git a/camel/camel-block-file.c b/camel/camel-block-file.c
index cdc6b70..d1749f0 100644
--- a/camel/camel-block-file.c
+++ b/camel/camel-block-file.c
@@ -484,7 +484,7 @@ camel_block_file_new_block (CamelBlockFile *bs,
 			goto fail;
 		bs->root->free = ((camel_block_t *)bl->data)[0];
 	} else {
-		bl = camel_block_file_get_block(bs, bs->root->last, error);
+		bl = camel_block_file_get_block (bs, bs->root->last, error);
 		if (bl == NULL)
 			goto fail;
 		bs->root->last += CAMEL_BLOCK_SIZE;
diff --git a/camel/camel-cipher-context.c b/camel/camel-cipher-context.c
index d5df0c2..4635e58 100644
--- a/camel/camel-cipher-context.c
+++ b/camel/camel-cipher-context.c
@@ -157,7 +157,7 @@ camel_cipher_verify (CamelCipherContext *context,
 	g_return_val_if_fail (CAMEL_IS_CIPHER_CONTEXT (context), NULL);
 
 	class = CAMEL_CIPHER_CONTEXT_GET_CLASS (context);
-	g_return_val_if_fail (class->verify, NULL);
+	g_return_val_if_fail (class->verify != NULL, NULL);
 
 	camel_operation_start (NULL, _("Verifying message"));
 
@@ -412,13 +412,13 @@ camel_cipher_hash_to_id (CamelCipherContext *context,
 static void
 ccv_certinfo_free (CamelCipherCertInfo *info)
 {
-	g_free(info->name);
-	g_free(info->email);
+	g_free (info->name);
+	g_free (info->email);
 
 	if (info->cert_data && info->cert_data_free)
 		info->cert_data_free (info->cert_data);
 
-	g_free(info);
+	g_free (info);
 }
 
 CamelCipherValidity *
@@ -548,9 +548,9 @@ camel_cipher_validity_add_certinfo_ex (CamelCipherValidity *vin, camel_cipher_va
 	CamelCipherCertInfo *info;
 	CamelDList *list;
 
-	info = g_malloc0(sizeof(*info));
-	info->name = g_strdup(name);
-	info->email = g_strdup(email);
+	info = g_malloc0 (sizeof (*info));
+	info->name = g_strdup (name);
+	info->email = g_strdup (email);
 	if (cert_data) {
 		if (cert_data_free && cert_data_clone) {
 			info->cert_data = cert_data;
@@ -565,7 +565,7 @@ camel_cipher_validity_add_certinfo_ex (CamelCipherValidity *vin, camel_cipher_va
 	}
 
 	list = (mode==CAMEL_CIPHER_VALIDITY_SIGN)?&vin->sign.signers:&vin->encrypt.encrypters;
-	camel_dlist_addtail(list, (CamelDListNode *)info);
+	camel_dlist_addtail (list, (CamelDListNode *)info);
 }
 
 /**
@@ -754,7 +754,7 @@ camel_cipher_context_init (CamelCipherContext *context)
  * This creates a new CamelCipherContext object which is used to sign,
  * verify, encrypt and decrypt streams.
  *
- * Return value: the new CamelCipherContext
+ * Returns: the new CamelCipherContext
  **/
 CamelCipherContext *
 camel_cipher_context_new (CamelSession *session)
diff --git a/camel/camel-debug.c b/camel/camel-debug.c
index 8dfeb11..3aa01ce 100644
--- a/camel/camel-debug.c
+++ b/camel/camel-debug.c
@@ -33,7 +33,7 @@ gint camel_verbose_debug;
 static GHashTable *debug_table = NULL;
 
 /**
- * debug_init:
+ * camel_debug_init:
  * @void:
  *
  * Init camel debug.
diff --git a/camel/camel-disco-diary.h b/camel/camel-disco-diary.h
index f28351d..2c1e428 100644
--- a/camel/camel-disco-diary.h
+++ b/camel/camel-disco-diary.h
@@ -103,7 +103,7 @@ void		camel_disco_diary_replay	(CamelDiscoDiary *diary,
 void		camel_disco_diary_uidmap_add	(CamelDiscoDiary *diary,
 						 const gchar *old_uid,
 						 const gchar *new_uid);
-const gchar *camel_disco_diary_uidmap_lookup	(CamelDiscoDiary *diary,
+const gchar *	camel_disco_diary_uidmap_lookup	(CamelDiscoDiary *diary,
 						 const gchar *uid);
 
 G_END_DECLS
diff --git a/camel/camel-file-utils.c b/camel/camel-file-utils.c
index b1b6b31..215ff39 100644
--- a/camel/camel-file-utils.c
+++ b/camel/camel-file-utils.c
@@ -41,8 +41,6 @@
 #include <gio/gio.h>
 #include <glib/gi18n-lib.h>
 
-#include <libedataserver/e-data-server-util.h>
-
 #include "camel-file-utils.h"
 #include "camel-operation.h"
 #include "camel-url.h"
diff --git a/camel/camel-gpg-context.c b/camel/camel-gpg-context.c
index ba706e3..a4bee94 100644
--- a/camel/camel-gpg-context.c
+++ b/camel/camel-gpg-context.c
@@ -1363,7 +1363,7 @@ gpg_sign (CamelCipherContext *context,
 
 	/* FIXME: stream this, we stream output at least */
 	istream = camel_stream_mem_new();
-	if (camel_cipher_canonical_to_stream(
+	if (camel_cipher_canonical_to_stream (
 		ipart, CAMEL_MIME_FILTER_CANON_STRIP |
 		CAMEL_MIME_FILTER_CANON_CRLF |
 		CAMEL_MIME_FILTER_CANON_FROM,
@@ -1714,6 +1714,7 @@ gpg_verify (CamelCipherContext *context,
 		g_free (sigfile);
 	}
 	g_object_unref (istream);
+	g_object_unref (canon_stream);
 
 	return validity;
 
diff --git a/camel/camel-index-control.c b/camel/camel-index-control.c
index a9c55dd..89bd0fc 100644
--- a/camel/camel-index-control.c
+++ b/camel/camel-index-control.c
@@ -193,7 +193,7 @@ do_perf(gint argc, gchar **argv)
 		printf("indexing '%s'\n", d->d_name);
 
 		idn = camel_index_add_name(idx, d->d_name);
-		camel_mime_filter_index_set_name(
+		camel_mime_filter_index_set_name (
 			CAMEL_MIME_FILTER_INDEX (filter_index), idn);
 		name = g_strdup_printf("%s/%s", path, d->d_name);
 		stream = camel_stream_fs_new_with_name(name, O_RDONLY, 0, NULL);
@@ -203,7 +203,7 @@ do_perf(gint argc, gchar **argv)
 
 		camel_index_write_name(idx, idn);
 		g_object_unref (idn);
-		camel_mime_filter_index_set_name(
+		camel_mime_filter_index_set_name (
 			CAMEL_MIME_FILTER_INDEX (filter_index), NULL);
 	}
 
diff --git a/camel/camel-medium.c b/camel/camel-medium.c
index 81c6d8c..ef0f162 100644
--- a/camel/camel-medium.c
+++ b/camel/camel-medium.c
@@ -108,7 +108,7 @@ medium_is_offline (CamelDataWrapper *data_wrapper)
 
 	content = camel_medium_get_content (CAMEL_MEDIUM (data_wrapper));
 
-	return CAMEL_DATA_WRAPPER_GET_CLASS (data_wrapper)->is_offline (data_wrapper) ||
+	return CAMEL_DATA_WRAPPER_CLASS (camel_medium_parent_class)->is_offline (data_wrapper) ||
 		camel_data_wrapper_is_offline (content);
 }
 
diff --git a/camel/camel-medium.h b/camel/camel-medium.h
index 043da09..02b0c8b 100644
--- a/camel/camel-medium.h
+++ b/camel/camel-medium.h
@@ -80,7 +80,7 @@ struct _CamelMediumClass {
 						 const gchar *name);
 	gconstpointer	(*get_header)		(CamelMedium *medium,
 						 const gchar *name);
-	GArray * (*get_headers) (CamelMedium *medium);
+	GArray *	(*get_headers)		(CamelMedium *medium);
 	void		(*free_headers)		(CamelMedium *medium,
 						 GArray *headers);
 	CamelDataWrapper *
@@ -100,13 +100,13 @@ void		camel_medium_remove_header	(CamelMedium *medium,
 						 const gchar *name);
 gconstpointer	camel_medium_get_header		(CamelMedium *medium,
 						 const gchar *name);
-GArray *camel_medium_get_headers (CamelMedium *medium);
+GArray *	camel_medium_get_headers	(CamelMedium *medium);
 void		camel_medium_free_headers	(CamelMedium *medium,
 						 GArray *headers);
 CamelDataWrapper *
 		camel_medium_get_content	(CamelMedium *medium);
-void camel_medium_set_content (CamelMedium *medium,
-			       CamelDataWrapper *content);
+void		camel_medium_set_content	(CamelMedium *medium,
+						 CamelDataWrapper *content);
 
 G_END_DECLS
 
diff --git a/camel/camel-mime-filter-basic.c b/camel/camel-mime-filter-basic.c
index 2af2c18..9f3e086 100644
--- a/camel/camel-mime-filter-basic.c
+++ b/camel/camel-mime-filter-basic.c
@@ -253,7 +253,7 @@ camel_mime_filter_basic_init (CamelMimeFilterBasic *filter)
 }
 
 /**
- * camel_mime_filter_basic_new_type:
+ * camel_mime_filter_basic_new:
  * @type: a #CamelMimeFilterBasicType type
  *
  * Create a new #CamelMimeFilterBasic object of type @type.
diff --git a/camel/camel-mime-filter-enriched.c b/camel/camel-mime-filter-enriched.c
index e1cfbe2..115a348 100644
--- a/camel/camel-mime-filter-enriched.c
+++ b/camel/camel-mime-filter-enriched.c
@@ -214,7 +214,7 @@ param_parse (const gchar *enriched, const gchar *inptr, gint inlen)
 #define IS_RICHTEXT CAMEL_MIME_FILTER_ENRICHED_IS_RICHTEXT
 
 static void
-enriched_to_html (CamelMimeFilter *filter,
+enriched_to_html (CamelMimeFilter *mime_filter,
                   const gchar *in,
                   gsize inlen,
                   gsize prespace,
@@ -228,14 +228,14 @@ enriched_to_html (CamelMimeFilter *filter,
 	register const gchar *inptr;
 	register gchar *outptr;
 
-	priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (mime_filter);
 
-	camel_mime_filter_set_size (filter, inlen * 2 + 6, FALSE);
+	camel_mime_filter_set_size (mime_filter, inlen * 2 + 6, FALSE);
 
 	inptr = in;
 	inend = in + inlen;
-	outptr = filter->outbuf;
-	outend = filter->outbuf + filter->outsize;
+	outptr = mime_filter->outbuf;
+	outend = mime_filter->outbuf + mime_filter->outsize;
 
  retry:
 	do {
@@ -457,11 +457,11 @@ enriched_to_html (CamelMimeFilter *filter,
            do. */
 
 	if (inptr < inend)
-		camel_mime_filter_backup (filter, inptr, (unsigned) (inend - inptr));
+		camel_mime_filter_backup (mime_filter, inptr, (unsigned) (inend - inptr));
 
-	*out = filter->outbuf;
-	*outlen = outptr - filter->outbuf;
-	*outprespace = filter->outpre;
+	*out = mime_filter->outbuf;
+	*outlen = outptr - mime_filter->outbuf;
+	*outprespace = mime_filter->outpre;
 
 	return;
 
@@ -471,23 +471,23 @@ enriched_to_html (CamelMimeFilter *filter,
 		gsize offset, grow;
 
 		grow = (inend - inptr) * 2 + 20;
-		offset = outptr - filter->outbuf;
-		camel_mime_filter_set_size (filter, filter->outsize + grow, TRUE);
-		outend = filter->outbuf + filter->outsize;
-		outptr = filter->outbuf + offset;
+		offset = outptr - mime_filter->outbuf;
+		camel_mime_filter_set_size (mime_filter, mime_filter->outsize + grow, TRUE);
+		outend = mime_filter->outbuf + mime_filter->outsize;
+		outptr = mime_filter->outbuf + offset;
 
 		goto retry;
 	} else {
-		camel_mime_filter_backup (filter, inptr, (unsigned) (inend - inptr));
+		camel_mime_filter_backup (mime_filter, inptr, (unsigned) (inend - inptr));
 	}
 
-	*out = filter->outbuf;
-	*outlen = outptr - filter->outbuf;
-	*outprespace = filter->outpre;
+	*out = mime_filter->outbuf;
+	*outlen = outptr - mime_filter->outbuf;
+	*outprespace = mime_filter->outpre;
 }
 
 static void
-mime_filter_enriched_filter (CamelMimeFilter *filter,
+mime_filter_enriched_filter (CamelMimeFilter *mime_filter,
                              const gchar *in,
                              gsize len,
                              gsize prespace,
@@ -496,11 +496,12 @@ mime_filter_enriched_filter (CamelMimeFilter *filter,
                              gsize *outprespace)
 {
 	enriched_to_html (
-		filter, in, len, prespace, out, outlen, outprespace, FALSE);
+		mime_filter, in, len, prespace,
+		out, outlen, outprespace, FALSE);
 }
 
 static void
-mime_filter_enriched_complete (CamelMimeFilter *filter,
+mime_filter_enriched_complete (CamelMimeFilter *mime_filter,
                                const gchar *in,
                                gsize len,
                                gsize prespace,
@@ -509,15 +510,16 @@ mime_filter_enriched_complete (CamelMimeFilter *filter,
                                gsize *outprespace)
 {
 	enriched_to_html (
-		filter, in, len, prespace, out, outlen, outprespace, TRUE);
+		mime_filter, in, len, prespace,
+		out, outlen, outprespace, TRUE);
 }
 
 static void
-mime_filter_enriched_reset (CamelMimeFilter *filter)
+mime_filter_enriched_reset (CamelMimeFilter *mime_filter)
 {
 	CamelMimeFilterEnrichedPrivate *priv;
 
-	priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_ENRICHED_GET_PRIVATE (mime_filter);
 
 	priv->nofill = 0;
 }
diff --git a/camel/camel-mime-filter-from.c b/camel/camel-mime-filter-from.c
index 4d91dc6..ff078a2 100644
--- a/camel/camel-mime-filter-from.c
+++ b/camel/camel-mime-filter-from.c
@@ -34,7 +34,7 @@
 #define d(x)
 
 struct _CamelMimeFilterFromPrivate {
-	gint midline;		/* are we between lines? */
+	gboolean midline;	/* are we between lines? */
 };
 
 struct fromnode {
@@ -44,20 +44,6 @@ struct fromnode {
 
 G_DEFINE_TYPE (CamelMimeFilterFrom, camel_mime_filter_from, CAMEL_TYPE_MIME_FILTER)
 
-static void
-mime_filter_from_complete (CamelMimeFilter *mime_filter,
-                           const gchar *in,
-                           gsize len,
-                           gsize prespace,
-                           gchar **out,
-                           gsize *outlen,
-                           gsize *outprespace)
-{
-	*out = (gchar *) in;
-	*outlen = len;
-	*outprespace = prespace;
-}
-
 /* Yes, it is complicated ... */
 static void
 mime_filter_from_filter (CamelMimeFilter *mime_filter,
@@ -150,6 +136,20 @@ mime_filter_from_filter (CamelMimeFilter *mime_filter,
 }
 
 static void
+mime_filter_from_complete (CamelMimeFilter *mime_filter,
+                           const gchar *in,
+                           gsize len,
+                           gsize prespace,
+                           gchar **out,
+                           gsize *outlen,
+                           gsize *outprespace)
+{
+	*out = (gchar *) in;
+	*outlen = len;
+	*outprespace = prespace;
+}
+
+static void
 camel_mime_filter_from_class_init (CamelMimeFilterFromClass *class)
 {
 	CamelMimeFilterClass *mime_filter_class;
diff --git a/camel/camel-mime-filter-gzip.c b/camel/camel-mime-filter-gzip.c
index 01a5a5e..358bf2c 100644
--- a/camel/camel-mime-filter-gzip.c
+++ b/camel/camel-mime-filter-gzip.c
@@ -98,7 +98,7 @@ struct _CamelMimeFilterGZipPrivate {
 G_DEFINE_TYPE (CamelMimeFilterGZip, camel_mime_filter_gzip, CAMEL_TYPE_MIME_FILTER)
 
 static void
-gzip_filter (CamelMimeFilter *filter,
+gzip_filter (CamelMimeFilter *mime_filter,
              const gchar *in,
              gsize len,
              gsize prespace,
@@ -110,7 +110,7 @@ gzip_filter (CamelMimeFilter *filter,
 	CamelMimeFilterGZipPrivate *priv;
 	gint retval;
 
-	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
 
 	if (!priv->state.zip.wrote_hdr) {
 		priv->hdr.v.id1 = 31;
@@ -126,19 +126,19 @@ gzip_filter (CamelMimeFilter *filter,
 			priv->hdr.v.xfl = 0;
 		priv->hdr.v.os = 255;
 
-		camel_mime_filter_set_size (filter, (len * 2) + 22, FALSE);
+		camel_mime_filter_set_size (mime_filter, (len * 2) + 22, FALSE);
 
-		memcpy (filter->outbuf, priv->hdr.buf, 10);
+		memcpy (mime_filter->outbuf, priv->hdr.buf, 10);
 
-		priv->stream->next_out = (Bytef *) filter->outbuf + 10;
-		priv->stream->avail_out = filter->outsize - 10;
+		priv->stream->next_out = (Bytef *) mime_filter->outbuf + 10;
+		priv->stream->avail_out = mime_filter->outsize - 10;
 
 		priv->state.zip.wrote_hdr = TRUE;
 	} else {
-		camel_mime_filter_set_size (filter, (len * 2) + 12, FALSE);
+		camel_mime_filter_set_size (mime_filter, (len * 2) + 12, FALSE);
 
-		priv->stream->next_out = (Bytef *) filter->outbuf;
-		priv->stream->avail_out = filter->outsize;
+		priv->stream->next_out = (Bytef *) mime_filter->outbuf;
+		priv->stream->avail_out = mime_filter->outsize;
 	}
 
 	priv->stream->next_in = (Bytef *) in;
@@ -152,10 +152,10 @@ gzip_filter (CamelMimeFilter *filter,
 		if (flush == Z_FULL_FLUSH) {
 			gsize n;
 
-			n = filter->outsize - priv->stream->avail_out;
-			camel_mime_filter_set_size (filter, n + (priv->stream->avail_in * 2) + 12, TRUE);
-			priv->stream->avail_out = filter->outsize - n;
-			priv->stream->next_out = (Bytef *) filter->outbuf + n;
+			n = mime_filter->outsize - priv->stream->avail_out;
+			camel_mime_filter_set_size (mime_filter, n + (priv->stream->avail_in * 2) + 12, TRUE);
+			priv->stream->avail_out = mime_filter->outsize - n;
+			priv->stream->next_out = (Bytef *) mime_filter->outbuf + n;
 
 			if (priv->stream->avail_in == 0) {
 				guint32 val;
@@ -174,7 +174,7 @@ gzip_filter (CamelMimeFilter *filter,
 			}
 		} else {
 			if (priv->stream->avail_in > 0)
-				camel_mime_filter_backup (filter, (const gchar *) priv->stream->next_in, priv->stream->avail_in);
+				camel_mime_filter_backup (mime_filter, (const gchar *) priv->stream->next_in, priv->stream->avail_in);
 
 			break;
 		}
@@ -183,13 +183,13 @@ gzip_filter (CamelMimeFilter *filter,
 	priv->crc32 = crc32 (priv->crc32, (guchar *) in, len - priv->stream->avail_in);
 	priv->isize += len - priv->stream->avail_in;
 
-	*out = filter->outbuf;
-	*outlen = filter->outsize - priv->stream->avail_out;
-	*outprespace = filter->outpre;
+	*out = mime_filter->outbuf;
+	*outlen = mime_filter->outsize - priv->stream->avail_out;
+	*outprespace = mime_filter->outpre;
 }
 
 static void
-gunzip_filter (CamelMimeFilter *filter,
+gunzip_filter (CamelMimeFilter *mime_filter,
                const gchar *in,
                gsize len,
                gsize prespace,
@@ -202,11 +202,11 @@ gunzip_filter (CamelMimeFilter *filter,
 	guint16 need, val;
 	gint retval;
 
-	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
 
 	if (!priv->state.unzip.got_hdr) {
 		if (len < 10) {
-			camel_mime_filter_backup (filter, in, len);
+			camel_mime_filter_backup (mime_filter, in, len);
 			return;
 		}
 
@@ -226,7 +226,7 @@ gunzip_filter (CamelMimeFilter *filter,
 	if (priv->hdr.v.flg & GZIP_FLAG_FEXTRA) {
 		if (!priv->state.unzip.got_xlen) {
 			if (len < 2) {
-				camel_mime_filter_backup (filter, in, len);
+				camel_mime_filter_backup (mime_filter, in, len);
 				return;
 			}
 
@@ -283,7 +283,7 @@ gunzip_filter (CamelMimeFilter *filter,
 
 	if ((priv->hdr.v.flg & GZIP_FLAG_FHCRC) && !priv->state.unzip.got_crc16) {
 		if (len < 2) {
-			camel_mime_filter_backup (filter, in, len);
+			camel_mime_filter_backup (mime_filter, in, len);
 			return;
 		}
 
@@ -296,13 +296,13 @@ gunzip_filter (CamelMimeFilter *filter,
 	if (len == 0)
 		return;
 
-	camel_mime_filter_set_size (filter, (len * 2) + 12, FALSE);
+	camel_mime_filter_set_size (mime_filter, (len * 2) + 12, FALSE);
 
 	priv->stream->next_in = (Bytef *) in;
 	priv->stream->avail_in = len - 8;
 
-	priv->stream->next_out = (Bytef *) filter->outbuf;
-	priv->stream->avail_out = filter->outsize;
+	priv->stream->next_out = (Bytef *) mime_filter->outbuf;
+	priv->stream->avail_out = mime_filter->outsize;
 
 	do {
 		/* FIXME: handle error cases? */
@@ -317,15 +317,15 @@ gunzip_filter (CamelMimeFilter *filter,
 				break;
 			}
 
-			n = filter->outsize - priv->stream->avail_out;
-			camel_mime_filter_set_size (filter, n + (priv->stream->avail_in * 2) + 12, TRUE);
-			priv->stream->avail_out = filter->outsize - n;
-			priv->stream->next_out = (Bytef *) filter->outbuf + n;
+			n = mime_filter->outsize - priv->stream->avail_out;
+			camel_mime_filter_set_size (mime_filter, n + (priv->stream->avail_in * 2) + 12, TRUE);
+			priv->stream->avail_out = mime_filter->outsize - n;
+			priv->stream->next_out = (Bytef *) mime_filter->outbuf + n;
 		} else {
 			priv->stream->avail_in += 8;
 
 			if (priv->stream->avail_in > 0)
-				camel_mime_filter_backup (filter, (gchar *) priv->stream->next_in, priv->stream->avail_in);
+				camel_mime_filter_backup (mime_filter, (gchar *) priv->stream->next_in, priv->stream->avail_in);
 
 			break;
 		}
@@ -337,32 +337,31 @@ gunzip_filter (CamelMimeFilter *filter,
 	/*priv->crc32 = crc32 (priv->crc32, in, len - priv->stream->avail_in - 8);
 	  priv->isize += len - priv->stream->avail_in - 8;*/
 
-	*out = filter->outbuf;
-	*outlen = filter->outsize - priv->stream->avail_out;
-	*outprespace = filter->outpre;
+	*out = mime_filter->outbuf;
+	*outlen = mime_filter->outsize - priv->stream->avail_out;
+	*outprespace = mime_filter->outpre;
 }
 
-/* should this 'flush' outstanding state/data bytes? */
 static void
-mime_filter_gzip_reset (CamelMimeFilter *filter)
+mime_filter_gzip_finalize (GObject *object)
 {
 	CamelMimeFilterGZipPrivate *priv;
 
-	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (filter);
-
-	memset (&priv->state, 0, sizeof (priv->state));
+	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (object);
 
 	if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
-		deflateReset (priv->stream);
+		deflateEnd (priv->stream);
 	else
-		inflateReset (priv->stream);
+		inflateEnd (priv->stream);
 
-	priv->crc32 = crc32 (0, Z_NULL, 0);
-	priv->isize = 0;
+	g_free (priv->stream);
+
+	/* Chain up to parent's finalize() method. */
+	G_OBJECT_CLASS (camel_mime_filter_gzip_parent_class)->finalize (object);
 }
 
 static void
-mime_filter_gzip_filter (CamelMimeFilter *filter,
+mime_filter_gzip_filter (CamelMimeFilter *mime_filter,
                          const gchar *in,
                          gsize len,
                          gsize prespace,
@@ -372,16 +371,20 @@ mime_filter_gzip_filter (CamelMimeFilter *filter,
 {
 	CamelMimeFilterGZipPrivate *priv;
 
-	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
 
 	if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
-		gzip_filter (filter, in, len, prespace, out, outlen, outprespace, Z_SYNC_FLUSH);
+		gzip_filter (
+			mime_filter, in, len, prespace,
+			out, outlen, outprespace, Z_SYNC_FLUSH);
 	else
-		gunzip_filter (filter, in, len, prespace, out, outlen, outprespace, Z_SYNC_FLUSH);
+		gunzip_filter (
+			mime_filter, in, len, prespace,
+			out, outlen, outprespace, Z_SYNC_FLUSH);
 }
 
 static void
-mime_filter_gzip_complete (CamelMimeFilter *filter,
+mime_filter_gzip_complete (CamelMimeFilter *mime_filter,
                            const gchar *in,
                            gsize len,
                            gsize prespace,
@@ -391,30 +394,35 @@ mime_filter_gzip_complete (CamelMimeFilter *filter,
 {
 	CamelMimeFilterGZipPrivate *priv;
 
-	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
 
 	if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
-		gzip_filter (filter, in, len, prespace, out, outlen, outprespace, Z_FULL_FLUSH);
+		gzip_filter (
+			mime_filter, in, len, prespace,
+			out, outlen, outprespace, Z_FULL_FLUSH);
 	else
-		gunzip_filter (filter, in, len, prespace, out, outlen, outprespace, Z_FULL_FLUSH);
+		gunzip_filter (
+			mime_filter, in, len, prespace,
+			out, outlen, outprespace, Z_FULL_FLUSH);
 }
 
+/* should this 'flush' outstanding state/data bytes? */
 static void
-mime_filter_gzip_finalize (GObject *object)
+mime_filter_gzip_reset (CamelMimeFilter *mime_filter)
 {
 	CamelMimeFilterGZipPrivate *priv;
 
-	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (object);
+	priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+
+	memset (&priv->state, 0, sizeof (priv->state));
 
 	if (priv->mode == CAMEL_MIME_FILTER_GZIP_MODE_ZIP)
-		deflateEnd (priv->stream);
+		deflateReset (priv->stream);
 	else
-		inflateEnd (priv->stream);
-
-	g_free (priv->stream);
+		inflateReset (priv->stream);
 
-	/* Chain up to parent's finalize() method. */
-	G_OBJECT_CLASS (camel_mime_filter_gzip_parent_class)->finalize (object);
+	priv->crc32 = crc32 (0, Z_NULL, 0);
+	priv->isize = 0;
 }
 
 static void
@@ -429,17 +437,17 @@ camel_mime_filter_gzip_class_init (CamelMimeFilterGZipClass *class)
 	object_class->finalize = mime_filter_gzip_finalize;
 
 	mime_filter_class = CAMEL_MIME_FILTER_CLASS (class);
-	mime_filter_class->reset = mime_filter_gzip_reset;
 	mime_filter_class->filter = mime_filter_gzip_filter;
 	mime_filter_class->complete = mime_filter_gzip_complete;
+	mime_filter_class->reset = mime_filter_gzip_reset;
 }
 
 static void
-camel_mime_filter_gzip_init (CamelMimeFilterGZip *filter)
+camel_mime_filter_gzip_init (CamelMimeFilterGZip *mime_filter)
 {
-	filter->priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (filter);
-	filter->priv->stream = g_new0 (z_stream, 1);
-	filter->priv->crc32 = crc32 (0, Z_NULL, 0);
+	mime_filter->priv = CAMEL_MIME_FILTER_GZIP_GET_PRIVATE (mime_filter);
+	mime_filter->priv->stream = g_new0 (z_stream, 1);
+	mime_filter->priv->crc32 = crc32 (0, Z_NULL, 0);
 }
 
 /**
diff --git a/camel/camel-mime-filter-html.c b/camel/camel-mime-filter-html.c
index 1a96834..2aca726 100644
--- a/camel/camel-mime-filter-html.c
+++ b/camel/camel-mime-filter-html.c
@@ -69,24 +69,33 @@ static struct {
 /* ********************************************************************** */
 
 static void
-run(CamelMimeFilter *mime_filter, const gchar *in, gsize inlen, gsize prespace, gchar **out, gsize *outlenptr, gsize *outprespace, gint last)
+mime_filter_html_run (CamelMimeFilter *mime_filter,
+                      const gchar *in,
+                      gsize inlen,
+                      gsize prespace,
+                      gchar **out,
+                      gsize *outlenptr,
+                      gsize *outprespace,
+                      gint last)
 {
-	CamelMimeFilterHTML *f = (CamelMimeFilterHTML *) mime_filter;
+	CamelMimeFilterHTMLPrivate *priv;
 	camel_html_parser_t state;
 	gchar *outp;
 
+	priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
+
 	d(printf("converting html:\n%.*s\n", (gint)inlen, in));
 
 	/* We should generally shrink the data, but this'll do */
 	camel_mime_filter_set_size (mime_filter, inlen * 2 + 256, FALSE);
 	outp = mime_filter->outbuf;
 
-	camel_html_parser_set_data (f->priv->ctxt, in, inlen, last);
+	camel_html_parser_set_data (priv->ctxt, in, inlen, last);
 	do {
 		const gchar *data;
 		gint len;
 
-		state = camel_html_parser_step(f->priv->ctxt, &data, &len);
+		state = camel_html_parser_step(priv->ctxt, &data, &len);
 
 		switch (state) {
 		case CAMEL_HTML_PARSER_DATA:
@@ -127,17 +136,6 @@ mime_filter_html_dispose (GObject *object)
 }
 
 static void
-mime_filter_html_reset (CamelMimeFilter *mime_filter)
-{
-	CamelMimeFilterHTMLPrivate *priv;
-
-	priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
-
-	g_object_unref (priv->ctxt);
-	priv->ctxt = camel_html_parser_new ();
-}
-
-static void
 mime_filter_html_filter (CamelMimeFilter *mime_filter,
                          const gchar *in,
                          gsize len,
@@ -146,7 +144,7 @@ mime_filter_html_filter (CamelMimeFilter *mime_filter,
                          gsize *outlenptr,
                          gsize *outprespace)
 {
-	run (
+	mime_filter_html_run (
 		mime_filter, in, len, prespace,
 		out, outlenptr, outprespace, FALSE);
 }
@@ -160,12 +158,23 @@ mime_filter_html_complete (CamelMimeFilter *mime_filter,
                            gsize *outlenptr,
                            gsize *outprespace)
 {
-	run (
+	mime_filter_html_run (
 		mime_filter, in, len, prespace,
 		out, outlenptr, outprespace, TRUE);
 }
 
 static void
+mime_filter_html_reset (CamelMimeFilter *mime_filter)
+{
+	CamelMimeFilterHTMLPrivate *priv;
+
+	priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
+
+	g_object_unref (priv->ctxt);
+	priv->ctxt = camel_html_parser_new ();
+}
+
+static void
 camel_mime_filter_html_class_init (CamelMimeFilterHTMLClass *class)
 {
 	GObjectClass *object_class;
@@ -177,16 +186,16 @@ camel_mime_filter_html_class_init (CamelMimeFilterHTMLClass *class)
 	object_class->dispose = mime_filter_html_dispose;
 
 	mime_filter_class = CAMEL_MIME_FILTER_CLASS (class);
-	mime_filter_class->reset = mime_filter_html_reset;
 	mime_filter_class->filter = mime_filter_html_filter;
 	mime_filter_class->complete = mime_filter_html_complete;
+	mime_filter_class->reset = mime_filter_html_reset;
 }
 
 static void
-camel_mime_filter_html_init (CamelMimeFilterHTML *filter)
+camel_mime_filter_html_init (CamelMimeFilterHTML *mime_filter)
 {
-	filter->priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (filter);
-	filter->priv->ctxt = camel_html_parser_new ();
+	mime_filter->priv = CAMEL_MIME_FILTER_HTML_GET_PRIVATE (mime_filter);
+	mime_filter->priv->ctxt = camel_html_parser_new ();
 }
 
 /**
diff --git a/camel/camel-mime-filter-progress.c b/camel/camel-mime-filter-progress.c
index ad0357a..ccf4ba7 100644
--- a/camel/camel-mime-filter-progress.c
+++ b/camel/camel-mime-filter-progress.c
@@ -45,7 +45,7 @@ struct _CamelMimeFilterProgressPrivate {
 G_DEFINE_TYPE (CamelMimeFilterProgress, camel_mime_filter_progress, CAMEL_TYPE_MIME_FILTER)
 
 static void
-mime_filter_progress_filter (CamelMimeFilter *filter,
+mime_filter_progress_filter (CamelMimeFilter *mime_filter,
                              const gchar *in,
                              gsize len,
                              gsize prespace,
@@ -56,11 +56,11 @@ mime_filter_progress_filter (CamelMimeFilter *filter,
 	CamelMimeFilterProgressPrivate *priv;
 	gdouble percent;
 
-	priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (filter);
+	priv = CAMEL_MIME_FILTER_PROGRESS_GET_PRIVATE (mime_filter);
 	priv->count += len;
 
 	if (priv->count < priv->total)
-		percent = ((double) priv->count * 100.0) / ((double) priv->total);
+		percent = ((gdouble) priv->count * 100.0) / ((gdouble) priv->total);
 	else
 		percent = 100.0;
 
@@ -81,7 +81,8 @@ mime_filter_progress_complete (CamelMimeFilter *mime_filter,
                                gsize *outprespace)
 {
 	mime_filter_progress_filter (
-		mime_filter, in, len, prespace, out, outlen, outprespace);
+		mime_filter, in, len, prespace,
+		out, outlen, outprespace);
 }
 
 static void
@@ -102,9 +103,9 @@ camel_mime_filter_progress_class_init (CamelMimeFilterProgressClass *class)
 	g_type_class_add_private (class, sizeof (CamelMimeFilterProgressPrivate));
 
 	mime_filter_class = CAMEL_MIME_FILTER_CLASS (class);
-	mime_filter_class->reset = mime_filter_progress_reset;
 	mime_filter_class->filter = mime_filter_progress_filter;
 	mime_filter_class->complete = mime_filter_progress_complete;
+	mime_filter_class->reset = mime_filter_progress_reset;
 }
 
 static void
diff --git a/camel/camel-mime-filter-save.c b/camel/camel-mime-filter-save.c
index 7c30913..3de1ef3 100644
--- a/camel/camel-mime-filter-save.c
+++ b/camel/camel-mime-filter-save.c
@@ -74,6 +74,12 @@ mime_filter_save_complete (CamelMimeFilter *mime_filter,
 }
 
 static void
+mime_filter_save_reset (CamelMimeFilter *mime_filter)
+{
+	/* no-op */
+}
+
+static void
 camel_mime_filter_save_class_init (CamelMimeFilterSaveClass *class)
 {
 	CamelMimeFilterClass *mime_filter_class;
@@ -83,6 +89,7 @@ camel_mime_filter_save_class_init (CamelMimeFilterSaveClass *class)
 	mime_filter_class = CAMEL_MIME_FILTER_CLASS (class);
 	mime_filter_class->filter = mime_filter_save_filter;
 	mime_filter_class->complete = mime_filter_save_complete;
+	mime_filter_class->reset = mime_filter_save_reset;
 }
 
 static void
diff --git a/camel/camel-mime-filter-windows.c b/camel/camel-mime-filter-windows.c
index ffe4bdd..0f62acf 100644
--- a/camel/camel-mime-filter-windows.c
+++ b/camel/camel-mime-filter-windows.c
@@ -104,7 +104,8 @@ mime_filter_windows_complete (CamelMimeFilter *mime_filter,
                               gsize *outprespace)
 {
 	mime_filter_windows_filter (
-		mime_filter, in, len, prespace, out, outlen, outprespace);
+		mime_filter, in, len, prespace,
+		out, outlen, outprespace);
 }
 
 static void
@@ -169,7 +170,7 @@ camel_mime_filter_windows_new (const gchar *claimed_charset)
  * camel_mime_filter_windows_is_windows_charset:
  * @filter: a #CamelMimeFilterWindows object
  *
- * Get whether or not the textual content filtered by @filetr is
+ * Get whether or not the textual content filtered by @filter is
  * really in a Microsoft Windows charset rather than the claimed ISO
  * charset.
  *
diff --git a/camel/camel-mime-filter-yenc.c b/camel/camel-mime-filter-yenc.c
index 59fd869..d9d501c 100644
--- a/camel/camel-mime-filter-yenc.c
+++ b/camel/camel-mime-filter-yenc.c
@@ -61,86 +61,93 @@ mime_filter_yenc_filter (CamelMimeFilter *mime_filter,
 	priv = CAMEL_MIME_FILTER_YENC_GET_PRIVATE (mime_filter);
 
 	switch (priv->direction) {
-	case CAMEL_MIME_FILTER_YENC_DIRECTION_ENCODE:
-		/* won't go to more than 2 * (x + 2) + 62 */
-		camel_mime_filter_set_size (mime_filter, (len + 2) * 2 + 62, FALSE);
-		newlen = camel_yencode_step ((const guchar *) in, len, (guchar *) mime_filter->outbuf, &priv->state,
-					     &priv->pcrc, &priv->crc);
-		g_assert (newlen <= (len + 2) * 2 + 62);
-		break;
-	case CAMEL_MIME_FILTER_YENC_DIRECTION_DECODE:
-		if (!(priv->state & CAMEL_MIME_YDECODE_STATE_DECODE)) {
-			const gchar *inptr, *inend;
-			gsize left;
-
-			inptr = in;
-			inend = inptr + len;
-
-			/* we cannot start decoding until we have found an =ybegin line */
-			if (!(priv->state & CAMEL_MIME_YDECODE_STATE_BEGIN)) {
-				while (inptr < inend) {
-					left = inend - inptr;
-					if (left < 8) {
-						if (!strncmp (inptr, "=ybegin ", left))
-							camel_mime_filter_backup (mime_filter, inptr, left);
-						break;
-					} else if (!strncmp (inptr, "=ybegin ", 8)) {
+		case CAMEL_MIME_FILTER_YENC_DIRECTION_ENCODE:
+			/* won't go to more than 2 * (x + 2) + 62 */
+			camel_mime_filter_set_size (
+				mime_filter, (len + 2) * 2 + 62, FALSE);
+			newlen = camel_yencode_step (
+				(const guchar *) in, len,
+				(guchar *) mime_filter->outbuf, &priv->state,
+				&priv->pcrc, &priv->crc);
+			g_assert (newlen <= (len + 2) * 2 + 62);
+			break;
+		case CAMEL_MIME_FILTER_YENC_DIRECTION_DECODE:
+			if (!(priv->state & CAMEL_MIME_YDECODE_STATE_DECODE)) {
+				const gchar *inptr, *inend;
+				gsize left;
+
+				inptr = in;
+				inend = inptr + len;
+
+				/* we cannot start decoding until we have found an =ybegin line */
+				if (!(priv->state & CAMEL_MIME_YDECODE_STATE_BEGIN)) {
+					while (inptr < inend) {
+						left = inend - inptr;
+						if (left < 8) {
+							if (!strncmp (inptr, "=ybegin ", left))
+								camel_mime_filter_backup (mime_filter, inptr, left);
+							break;
+						} else if (!strncmp (inptr, "=ybegin ", 8)) {
+							for (in = inptr; inptr < inend && *inptr != '\n'; inptr++);
+							if (inptr < inend) {
+								inptr++;
+								priv->state |= CAMEL_MIME_YDECODE_STATE_BEGIN;
+								/* we can start ydecoding if the next line isn't
+								   a ypart... */
+								in = inptr;
+								len = inend - in;
+							} else {
+								/* we don't have enough... */
+								camel_mime_filter_backup (mime_filter, in, left);
+							}
+							break;
+						}
+
+						/* go to the next line */
+						while (inptr < inend && *inptr != '\n')
+							inptr++;
+
+						if (inptr < inend)
+							inptr++;
+					}
+				}
+
+				left = inend - inptr;
+				if ((priv->state & CAMEL_MIME_YDECODE_STATE_BEGIN) && left > 0) {
+					/* we have found an '=ybegin' line but we may yet have an "=ypart" line to
+					   yield before decoding the content */
+					if (left < 7 && !strncmp (inptr, "=ypart ", left)) {
+						camel_mime_filter_backup (mime_filter, inptr, left);
+					} else if (!strncmp (inptr, "=ypart ", 7)) {
 						for (in = inptr; inptr < inend && *inptr != '\n'; inptr++);
 						if (inptr < inend) {
 							inptr++;
-							priv->state |= CAMEL_MIME_YDECODE_STATE_BEGIN;
-							/* we can start ydecoding if the next line isn't
-							   a ypart... */
+							priv->state |= CAMEL_MIME_YDECODE_STATE_PART | CAMEL_MIME_YDECODE_STATE_DECODE;
 							in = inptr;
 							len = inend - in;
 						} else {
-							/* we don't have enough... */
 							camel_mime_filter_backup (mime_filter, in, left);
 						}
-						break;
-					}
-
-					/* go to the next line */
-					while (inptr < inend && *inptr != '\n')
-						inptr++;
-
-					if (inptr < inend)
-						inptr++;
-				}
-			}
-
-			left = inend - inptr;
-			if ((priv->state & CAMEL_MIME_YDECODE_STATE_BEGIN) && left > 0) {
-				/* we have found an '=ybegin' line but we may yet have an "=ypart" line to
-				   yield before decoding the content */
-				if (left < 7 && !strncmp (inptr, "=ypart ", left)) {
-					camel_mime_filter_backup (mime_filter, inptr, left);
-				} else if (!strncmp (inptr, "=ypart ", 7)) {
-					for (in = inptr; inptr < inend && *inptr != '\n'; inptr++);
-					if (inptr < inend) {
-						inptr++;
-						priv->state |= CAMEL_MIME_YDECODE_STATE_PART | CAMEL_MIME_YDECODE_STATE_DECODE;
-						in = inptr;
-						len = inend - in;
 					} else {
-						camel_mime_filter_backup (mime_filter, in, left);
+						/* guess it doesn't have a =ypart line */
+						priv->state |= CAMEL_MIME_YDECODE_STATE_DECODE;
 					}
-				} else {
-					/* guess it doesn't have a =ypart line */
-					priv->state |= CAMEL_MIME_YDECODE_STATE_DECODE;
 				}
 			}
-		}
 
-		if ((priv->state & CAMEL_MIME_YDECODE_STATE_DECODE) && !(priv->state & CAMEL_MIME_YDECODE_STATE_END)) {
-			/* all yEnc headers have been found so we can now start decoding */
-			camel_mime_filter_set_size (mime_filter, len + 3, FALSE);
-			newlen = camel_ydecode_step ((const guchar *) in, len, (guchar *) mime_filter->outbuf, &priv->state, &priv->pcrc, &priv->crc);
-			g_assert (newlen <= len + 3);
-		} else {
-			newlen = 0;
-		}
-		break;
+			if ((priv->state & CAMEL_MIME_YDECODE_STATE_DECODE) && !(priv->state & CAMEL_MIME_YDECODE_STATE_END)) {
+				/* all yEnc headers have been found so we can now start decoding */
+				camel_mime_filter_set_size (
+					mime_filter, len + 3, FALSE);
+				newlen = camel_ydecode_step (
+					(const guchar *) in, len,
+					(guchar *) mime_filter->outbuf,
+					&priv->state, &priv->pcrc, &priv->crc);
+				g_assert (newlen <= len + 3);
+			} else {
+				newlen = 0;
+			}
+			break;
 	}
 
 	*out = mime_filter->outbuf;
@@ -164,23 +171,31 @@ mime_filter_yenc_complete (CamelMimeFilter *mime_filter,
 
 	switch (priv->direction) {
 	case CAMEL_MIME_FILTER_YENC_DIRECTION_ENCODE:
-		/* won't go to more than 2 * (x + 2) + 62 */
-		camel_mime_filter_set_size (mime_filter, (len + 2) * 2 + 62, FALSE);
-		newlen = camel_yencode_close ((const guchar *) in, len, (guchar *) mime_filter->outbuf, &priv->state,
-					       &priv->pcrc, &priv->crc);
-		g_assert (newlen <= (len + 2) * 2 + 62);
-		break;
-	case CAMEL_MIME_FILTER_YENC_DIRECTION_DECODE:
-		if ((priv->state & CAMEL_MIME_YDECODE_STATE_DECODE) && !(priv->state & CAMEL_MIME_YDECODE_STATE_END)) {
-			/* all yEnc headers have been found so we can now start decoding */
-			camel_mime_filter_set_size (mime_filter, len + 3, FALSE);
-			newlen = camel_ydecode_step ((const guchar *) in, len, (guchar *) mime_filter->outbuf, &priv->state,
-						      &priv->pcrc, &priv->crc);
-			g_assert (newlen <= len + 3);
-		} else {
-			newlen = 0;
-		}
-		break;
+			/* won't go to more than 2 * (x + 2) + 62 */
+			camel_mime_filter_set_size (
+				mime_filter, (len + 2) * 2 + 62, FALSE);
+			newlen = camel_yencode_close (
+				(const guchar *) in, len,
+				(guchar *) mime_filter->outbuf,
+				&priv->state, &priv->pcrc, &priv->crc);
+			g_assert (newlen <= (len + 2) * 2 + 62);
+			break;
+		case CAMEL_MIME_FILTER_YENC_DIRECTION_DECODE:
+			if ((priv->state & CAMEL_MIME_YDECODE_STATE_DECODE) &&
+				!(priv->state & CAMEL_MIME_YDECODE_STATE_END)) {
+				/* all yEnc headers have been found so we
+				 * can now start decoding */
+				camel_mime_filter_set_size (
+					mime_filter, len + 3, FALSE);
+				newlen = camel_ydecode_step (
+					(const guchar *) in, len,
+					(guchar *) mime_filter->outbuf,
+					&priv->state, &priv->pcrc, &priv->crc);
+				g_assert (newlen <= len + 3);
+			} else {
+				newlen = 0;
+			}
+			break;
 	}
 
 	*out = mime_filter->outbuf;
@@ -216,9 +231,9 @@ camel_mime_filter_yenc_class_init (CamelMimeFilterYencClass *class)
 	g_type_class_add_private (class, sizeof (CamelMimeFilterYencPrivate));
 
 	mime_filter_class = CAMEL_MIME_FILTER_CLASS (class);
-	mime_filter_class->reset = mime_filter_yenc_reset;
 	mime_filter_class->filter = mime_filter_yenc_filter;
 	mime_filter_class->complete = mime_filter_yenc_complete;
+	mime_filter_class->reset = mime_filter_yenc_reset;
 }
 
 static void
diff --git a/camel/camel-mime-message.c b/camel/camel-mime-message.c
index 9ad881f..9a051a4 100644
--- a/camel/camel-mime-message.c
+++ b/camel/camel-mime-message.c
@@ -541,7 +541,7 @@ camel_mime_message_get_message_id (CamelMimeMessage *mime_message)
  * Set the Reply-To of a message.
  **/
 void
-camel_mime_message_set_reply_to (CamelMimeMessage *msg, const CamelInternetAddress *reply_to)
+camel_mime_message_set_reply_to (CamelMimeMessage *msg, CamelInternetAddress *reply_to)
 {
 	gchar *addr;
 
@@ -571,7 +571,7 @@ camel_mime_message_set_reply_to (CamelMimeMessage *msg, const CamelInternetAddre
  *
  * Returns: the Reply-Toa ddress of the message
  **/
-const CamelInternetAddress *
+CamelInternetAddress *
 camel_mime_message_get_reply_to (CamelMimeMessage *mime_message)
 {
 	g_assert (mime_message);
@@ -641,7 +641,7 @@ camel_mime_message_get_subject (CamelMimeMessage *mime_message)
  * Set the from address of a message.
  **/
 void
-camel_mime_message_set_from (CamelMimeMessage *msg, const CamelInternetAddress *from)
+camel_mime_message_set_from (CamelMimeMessage *msg, CamelInternetAddress *from)
 {
 	gchar *addr;
 
@@ -671,7 +671,7 @@ camel_mime_message_set_from (CamelMimeMessage *msg, const CamelInternetAddress *
  *
  * Returns: the from address of the message
  **/
-const CamelInternetAddress *
+CamelInternetAddress *
 camel_mime_message_get_from (CamelMimeMessage *mime_message)
 {
 	g_assert (mime_message);
@@ -692,7 +692,7 @@ camel_mime_message_get_from (CamelMimeMessage *mime_message)
  * Set the recipients of a message.
  **/
 void
-camel_mime_message_set_recipients(CamelMimeMessage *mime_message, const gchar *type, const CamelInternetAddress *r)
+camel_mime_message_set_recipients(CamelMimeMessage *mime_message, const gchar *type, CamelInternetAddress *r)
 {
 	gchar *text;
 	CamelInternetAddress *addr;
@@ -729,7 +729,7 @@ camel_mime_message_set_recipients(CamelMimeMessage *mime_message, const gchar *t
  *
  * Returns: the requested recipients
  **/
-const CamelInternetAddress *
+CamelInternetAddress *
 camel_mime_message_get_recipients (CamelMimeMessage *mime_message, const gchar *type)
 {
 	g_assert(mime_message);
@@ -900,7 +900,8 @@ find_best_encoding (CamelMimePart *part, CamelBestencRequired required, CamelBes
 	}
 
 	bestenc = camel_mime_filter_bestenc_new (flags);
-	idb = camel_stream_filter_add (CAMEL_STREAM_FILTER (filter), bestenc);
+	idb = camel_stream_filter_add (
+		CAMEL_STREAM_FILTER (filter), bestenc);
 	d(printf("writing to checking stream\n"));
 	camel_data_wrapper_decode_to_stream (content, filter, NULL);
 	camel_stream_filter_remove (CAMEL_STREAM_FILTER (filter), idb);
diff --git a/camel/camel-mime-message.h b/camel/camel-mime-message.h
index 55b7a64..7c5c76b 100644
--- a/camel/camel-mime-message.h
+++ b/camel/camel-mime-message.h
@@ -108,21 +108,21 @@ void                        camel_mime_message_set_message_id     (CamelMimeMess
 								   const gchar                 *message_id);
 const gchar                 *camel_mime_message_get_message_id     (CamelMimeMessage           *message);
 void                        camel_mime_message_set_reply_to       (CamelMimeMessage           *message,
-								   const CamelInternetAddress *reply_to);
-const CamelInternetAddress *camel_mime_message_get_reply_to       (CamelMimeMessage           *message);
+								   CamelInternetAddress *reply_to);
+CamelInternetAddress *      camel_mime_message_get_reply_to       (CamelMimeMessage           *message);
 
 void                        camel_mime_message_set_subject        (CamelMimeMessage           *message,
 								   const gchar                 *subject);
 const gchar                 *camel_mime_message_get_subject        (CamelMimeMessage           *message);
 void                        camel_mime_message_set_from           (CamelMimeMessage           *message,
-								   const CamelInternetAddress *from);
-const CamelInternetAddress *camel_mime_message_get_from           (CamelMimeMessage           *message);
+								   CamelInternetAddress *from);
+CamelInternetAddress *      camel_mime_message_get_from           (CamelMimeMessage           *message);
 
-const CamelInternetAddress *camel_mime_message_get_recipients     (CamelMimeMessage           *message,
+CamelInternetAddress *      camel_mime_message_get_recipients     (CamelMimeMessage           *message,
 								   const gchar                 *type);
 void                        camel_mime_message_set_recipients     (CamelMimeMessage           *message,
 								   const gchar                 *type,
-								   const CamelInternetAddress *recipients);
+								   CamelInternetAddress *recipients);
 
 void                        camel_mime_message_set_source         (CamelMimeMessage           *message,
 								   const gchar                 *identity);
diff --git a/camel/camel-net-utils.h b/camel/camel-net-utils.h
index 9dfb228..f7d78c7 100644
--- a/camel/camel-net-utils.h
+++ b/camel/camel-net-utils.h
@@ -90,10 +90,10 @@ struct addrinfo {
 #endif
 
 struct addrinfo *camel_getaddrinfo(const gchar *name, const gchar *service,
-				   const struct addrinfo *hints, struct _GError **error);
+				   const struct addrinfo *hints, GError **error);
 void camel_freeaddrinfo(struct addrinfo *host);
 gint camel_getnameinfo(const struct sockaddr *sa, socklen_t salen, gchar **host, gchar **serv,
-		      gint flags, struct _GError **error);
+		      gint flags, GError **error);
 
 G_END_DECLS
 
diff --git a/camel/camel-nntp-address.c b/camel/camel-nntp-address.c
index b7619f8..6fb5d30 100644
--- a/camel/camel-nntp-address.c
+++ b/camel/camel-nntp-address.c
@@ -26,11 +26,6 @@
 
 #define d(x)
 
-static gint    nntp_address_decode		(CamelAddress *, const gchar *raw);
-static gchar * nntp_address_encode		(CamelAddress *);
-static gint    nntp_address_cat		(CamelAddress *dest, CamelAddress *source);
-static void   nntp_address_remove		(CamelAddress *, gint index);
-
 struct _address {
 	gchar *name;
 	gchar *address;
diff --git a/camel/camel-sasl-anonymous.c b/camel/camel-sasl-anonymous.c
index f197c13..dbbb500 100644
--- a/camel/camel-sasl-anonymous.c
+++ b/camel/camel-sasl-anonymous.c
@@ -42,6 +42,17 @@ CamelServiceAuthType camel_sasl_anonymous_authtype = {
 
 G_DEFINE_TYPE (CamelSaslAnonymous, camel_sasl_anonymous, CAMEL_TYPE_SASL)
 
+static void
+sasl_anonymous_finalize (GObject *object)
+{
+	CamelSaslAnonymous *sasl = CAMEL_SASL_ANONYMOUS (object);
+
+	g_free (sasl->trace_info);
+
+	/* Chain up to parent's finalize() method. */
+	G_OBJECT_CLASS (camel_sasl_anonymous_parent_class)->finalize (object);
+}
+
 static GByteArray *
 sasl_anonymous_challenge (CamelSasl *sasl,
                           GByteArray *token,
@@ -104,17 +115,6 @@ sasl_anonymous_challenge (CamelSasl *sasl,
 }
 
 static void
-sasl_anonymous_finalize (GObject *object)
-{
-	CamelSaslAnonymous *sasl = CAMEL_SASL_ANONYMOUS (object);
-
-	g_free (sasl->trace_info);
-
-	/* Chain up to parent's finalize() method. */
-	G_OBJECT_CLASS (camel_sasl_anonymous_parent_class)->finalize (object);
-}
-
-static void
 camel_sasl_anonymous_class_init (CamelSaslAnonymousClass *class)
 {
 	GObjectClass *object_class;
diff --git a/camel/camel-sasl-digest-md5.c b/camel/camel-sasl-digest-md5.c
index 96e9e8f..7e595b3 100644
--- a/camel/camel-sasl-digest-md5.c
+++ b/camel/camel-sasl-digest-md5.c
@@ -810,7 +810,7 @@ sasl_digest_md5_challenge (CamelSasl *sasl,
 			g_set_error (
 				error, CAMEL_SERVICE_ERROR,
 				CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
-			      _("Server challenge too long (>2048 octets)"));
+				_("Server challenge too long (>2048 octets)"));
 			return NULL;
 		}
 
diff --git a/camel/camel-sasl-plain.c b/camel/camel-sasl-plain.c
index 93232ed..e27a6b9 100644
--- a/camel/camel-sasl-plain.c
+++ b/camel/camel-sasl-plain.c
@@ -92,4 +92,3 @@ camel_sasl_plain_init (CamelSaslPlain *sasl)
 {
 	sasl->priv = CAMEL_SASL_PLAIN_GET_PRIVATE (sasl);
 }
-
diff --git a/camel/camel-search-private.c b/camel/camel-search-private.c
index 757c05f..71ea9a3 100644
--- a/camel/camel-search-private.c
+++ b/camel/camel-search-private.c
@@ -35,8 +35,6 @@
 
 #include <glib/gi18n-lib.h>
 
-#include <libedataserver/e-sexp.h>
-
 #include "camel-mime-message.h"
 #include "camel-multipart.h"
 #include "camel-search-private.h"
diff --git a/camel/camel-session.c b/camel/camel-session.c
index 00844f2..d82332c 100644
--- a/camel/camel-session.c
+++ b/camel/camel-session.c
@@ -37,8 +37,6 @@
 #include <glib/gi18n-lib.h>
 #include <glib/gstdio.h>
 
-#include <libedataserver/e-data-server-util.h>
-
 #include "camel-file-utils.h"
 #include "camel-private.h"
 #include "camel-session.h"
@@ -581,7 +579,8 @@ camel_session_alert_user (CamelSession *session,
  * Since: 2.22
  **/
 gboolean
-camel_session_lookup_addressbook (CamelSession *session, const gchar *name)
+camel_session_lookup_addressbook (CamelSession *session,
+                                  const gchar *name)
 {
 	CamelSessionClass *class;
 
diff --git a/camel/camel-smime-context.c b/camel/camel-smime-context.c
index f5fef01..a4e920d 100644
--- a/camel/camel-smime-context.c
+++ b/camel/camel-smime-context.c
@@ -77,6 +77,22 @@ struct _CamelSMIMEContextPrivate {
 
 G_DEFINE_TYPE (CamelSMIMEContext, camel_smime_context, CAMEL_TYPE_CIPHER_CONTEXT)
 
+static void
+smime_cert_data_free (gpointer cert_data)
+{
+	g_return_if_fail (cert_data != NULL);
+
+	CERT_DestroyCertificate (cert_data);
+}
+
+static gpointer
+smime_cert_data_clone (gpointer cert_data)
+{
+	g_return_val_if_fail (cert_data != NULL, NULL);
+
+	return CERT_DupCertificate (cert_data);
+}
+
 /* used for decode content callback, for streaming decode */
 static void
 sm_write_stream (gpointer arg, const gchar *buf, gulong len)
@@ -615,7 +631,10 @@ sm_verify_cmsg (CamelCipherContext *context,
 							       cn?cn:"<unknown>", em?em:"<unknown>",
 							       sm_status_description (status));
 
-					camel_cipher_validity_add_certinfo (valid, CAMEL_CIPHER_VALIDITY_SIGN, cn, em);
+					camel_cipher_validity_add_certinfo_ex (
+						valid, CAMEL_CIPHER_VALIDITY_SIGN, cn, em,
+						smime_cert_data_clone (NSS_CMSSignerInfo_GetSigningCertificate (si, p->certdb)),
+						smime_cert_data_free, smime_cert_data_clone);
 
 					if (cn)
 						PORT_Free (cn);