Support gmime 3.0

configure.ac

@@ -146,11 +146,11 @@ AC_SUBST(GLIB_CFLAGS)
 AC_SUBST(GLIB_LIBS)
 glib_version="`$PKG_CONFIG --modversion glib-2.0`"
 
-# gmime, some late-2012 version
+# gmime, version 3.0 or higher
-PKG_CHECK_MODULES(GMIME,gmime-2.6 >= 2.6.7)
+PKG_CHECK_MODULES(GMIME,gmime-3.0)
 AC_SUBST(GMIME_CFLAGS)
 AC_SUBST(GMIME_LIBS)
-gmime_version="`$PKG_CONFIG --modversion gmime-2.6`"
+gmime_version="`$PKG_CONFIG --modversion gmime-3.0`"
 
 
 # xapian checking - we need 1.2.x at least

contrib/gmime-test.c

@@ -31,13 +31,13 @@
 #include <locale.h>
 
 static gchar*
-get_recip (GMimeMessage *msg, GMimeRecipientType rtype)
+get_recip (GMimeMessage *msg, GMimeAddressType atype)
 {
 	char *recep;
 	InternetAddressList *receps;
 
-	receps = g_mime_message_get_recipients (msg, rtype);
+	receps = g_mime_message_get_addresses (msg, atype);
-	recep = (char*)internet_address_list_to_string (receps, FALSE);
+	recep = (char*)internet_address_list_to_string (receps, NULL, FALSE);
 
 	if (!recep || !*recep) {
 		g_free (recep);
@@ -51,20 +51,19 @@ static gchar*
 get_refs_str (GMimeMessage *msg)
 {
 	const gchar *str;
-	const GMimeReferences *cur;
 	GMimeReferences *mime_refs;
+	int i, refs_len;
 	gchar *rv;
 
 	str = g_mime_object_get_header (GMIME_OBJECT(msg), "References");
 	if (!str)
 		return NULL;
 
-	mime_refs = g_mime_references_decode (str);
+	mime_refs = g_mime_references_parse (NULL, str);
-	for (rv = NULL, cur = mime_refs; cur;
+	refs_len = g_mime_references_length (mime_refs);
-	     cur = g_mime_references_get_next(cur)) {
+	for (rv = NULL, i = 0; i < refs_len; ++i) {
-
 		const char* msgid;
-		msgid = g_mime_references_get_message_id (cur);
+		msgid = g_mime_references_get_message_id (mime_refs, i);
 		rv = g_strdup_printf ("%s%s%s",
 				      rv ? rv : "",
 				      rv ? "," : "",
@@ -78,21 +77,21 @@ get_refs_str (GMimeMessage *msg)
 static void
 print_date (GMimeMessage *msg)
 {
-	time_t		 t;
+	GDateTime       *dt;
-	int		 tz;
+	gchar           *buf;
-	char		 buf[64];
-	size_t		 len;
-	struct  tm	*t_m;
 
+	dt = g_mime_message_get_date (msg);
+	if (!dt)
+		return;
 
-	g_mime_message_get_date (msg, &t, &tz);
+	dt = g_date_time_to_local (dt);
-	t_m = localtime (&t);
+	buf = g_date_time_format (dt, "%c");
+	g_date_time_unref (dt);
 
-	len = strftime (buf, sizeof(buf) - 1, "%c", t_m);
+	if (buf) {
-
+		g_print ("Date   : %s\n", buf);
-	if (len > 0)
+		g_free (buf);
-		g_print ("Date   : %s (%s%04d)\n",
+	}
-			 buf,tz < 0 ? "-" : "+", tz);
 }
 
 
@@ -111,7 +110,7 @@ print_body (GMimeMessage *msg)
 	if (!GMIME_IS_PART(body))
 		return;
 
-	wrapper = g_mime_part_get_content_object (GMIME_PART(body));
+	wrapper = g_mime_part_get_content (GMIME_PART(body));
 	if (!GMIME_IS_DATA_WRAPPER(wrapper))
 		return;
 
@@ -142,17 +141,19 @@ test_message (GMimeMessage *msg)
 	gchar		*val;
 	const gchar	*str;
 
-	g_print ("From   : %s\n", g_mime_message_get_sender (msg));
+	val = get_recip (msg, GMIME_ADDRESS_TYPE_FROM);
+	g_print ("From   : %s\n", val ? val : "<none>" );
+	g_free (val);
 
-	val = get_recip (msg, GMIME_RECIPIENT_TYPE_TO);
+	val = get_recip (msg, GMIME_ADDRESS_TYPE_TO);
 	g_print ("To     : %s\n", val ? val : "<none>" );
 	g_free (val);
 
-	val = get_recip (msg, GMIME_RECIPIENT_TYPE_CC);
+	val = get_recip (msg, GMIME_ADDRESS_TYPE_CC);
 	g_print ("Cc     : %s\n", val ? val : "<none>" );
 	g_free (val);
 
-	val = get_recip (msg, GMIME_RECIPIENT_TYPE_BCC);
+	val = get_recip (msg, GMIME_ADDRESS_TYPE_BCC);
 	g_print ("Bcc    : %s\n", val ? val : "<none>" );
 	g_free (val);
 
@@ -195,7 +196,7 @@ test_stream (GMimeStream *stream)
 		goto leave;
 	}
 
-	msg = g_mime_parser_construct_message (parser);
+	msg = g_mime_parser_construct_message (parser, NULL);
 	if (!msg) {
 		g_warning ("failed to construct message");
 		rv = FALSE;
@@ -207,8 +208,6 @@ test_stream (GMimeStream *stream)
 leave:
 	if (parser)
 		g_object_unref (parser);
-	else
-		g_object_unref (stream);
 
 	if (msg)
 		g_object_unref (msg);
@@ -242,7 +241,9 @@ test_file (const char *path)
 		goto leave;
 	}
 
-	rv = test_stream (stream);  /* test-stream will unref it */
+	rv = test_stream (stream);
+	g_object_unref (stream);
+	return rv;
 
 leave:
 	if (file)
@@ -264,7 +265,7 @@ main (int argc, char *argv[])
 
 	setlocale (LC_ALL, "");
 
-	g_mime_init(GMIME_ENABLE_RFC2047_WORKAROUNDS);
+	g_mime_init();
 
 	rv = test_file (argv[1]);
 

lib/mu-msg-crypto.c

@@ -99,83 +99,6 @@ dummy_password_func (const char *user_id, const char *prompt_ctx,
 }
 
 
-static char*
-get_gpg (GError **err)
-{
-	char		*path;
-	const char	*envpath;
-
-	if ((envpath = g_getenv ("MU_GPG_PATH"))) {
-		if (access (envpath, X_OK) != 0) {
-			mu_util_g_set_error (
-				err, MU_ERROR,
-				"'%s': not a valid gpg path: %s",
-				envpath, strerror (errno));
-			return NULL;
-		 }
-		return g_strdup (envpath);
-	}
-
-	if (!(path = g_find_program_in_path ("gpg2")) &&
-	    !(path = g_find_program_in_path ("gpg"))) {
-		mu_util_g_set_error (err, MU_ERROR, "gpg/gpg2 not found");
-		return NULL;
-	} else
-		return path;
-}
-
-
-static GMimeCryptoContext*
-get_gpg_crypto_context (MuMsgOptions opts, GError **err)
-{
-	GMimeCryptoContext	*cctx;
-	char			*gpg;
-
-	cctx  = NULL;
-	if (!(gpg   = get_gpg (err)))
-		return NULL;
-
-	cctx = g_mime_gpg_context_new (
-		(GMimePasswordRequestFunc)password_requester, gpg);
-	g_free (gpg);
-
-	if (!cctx) {
-		mu_util_g_set_error (err, MU_ERROR,
-				     "failed to get GPG crypto context");
-		return NULL;
-	}
-
-	/* always try to use the agent */
-	g_mime_gpg_context_set_use_agent (GMIME_GPG_CONTEXT(cctx), TRUE);
- 	g_mime_gpg_context_set_auto_key_retrieve
-		(GMIME_GPG_CONTEXT(cctx),
-		 opts & MU_MSG_OPTION_AUTO_RETRIEVE ? TRUE:FALSE);
-
-	return cctx;
-}
-
-
-static GMimeCryptoContext*
-get_crypto_context (MuMsgOptions opts, MuMsgPartPasswordFunc password_func,
-		    gpointer user_data, GError **err)
-{
-	CallbackData *cbdata;
-	GMimeCryptoContext *cctx;
-
-	cctx = get_gpg_crypto_context (opts, err);
-	if (!cctx)
-		return NULL;
-
-	/* use gobject to pass data to the callback func */
-	cbdata = g_new0 (CallbackData, 1);
-	cbdata->pw_func   = password_func ? password_func : dummy_password_func;
-	cbdata->user_data = user_data;
-
-	g_object_set_data_full (G_OBJECT(cctx), CALLBACK_DATA,
-				cbdata, (GDestroyNotify)g_free);
-	return cctx;
-}
-
 static const char*
 get_pubkey_algo_name (GMimePubKeyAlgo algo)
 {
@@ -250,12 +173,12 @@ get_cert_data (GMimeCertificate *cert)
 		(g_mime_certificate_get_pubkey_algo (cert));
 
 	switch (g_mime_certificate_get_trust (cert)) {
-	case GMIME_CERTIFICATE_TRUST_NONE:      trust = "none"; break;
+	case GMIME_TRUST_UNKNOWN:   trust = "unknown"; break;
-	case GMIME_CERTIFICATE_TRUST_NEVER:     trust = "never"; break;
+	case GMIME_TRUST_UNDEFINED: trust = "undefined"; break;
-	case GMIME_CERTIFICATE_TRUST_UNDEFINED: trust = "undefined"; break;
+	case GMIME_TRUST_NEVER:     trust = "never"; break;
-	case GMIME_CERTIFICATE_TRUST_MARGINAL:  trust = "marginal"; break;
+	case GMIME_TRUST_MARGINAL:  trust = "marginal"; break;
-	case GMIME_CERTIFICATE_TRUST_FULLY:     trust = "full"; break;
+	case GMIME_TRUST_FULL:      trust = "full"; break;
-	case GMIME_CERTIFICATE_TRUST_ULTIMATE:  trust = "ultimate"; break;
+	case GMIME_TRUST_ULTIMATE:  trust = "ultimate"; break;
 	default:
 		g_return_val_if_reached (NULL);
 	}
@@ -277,13 +200,17 @@ get_verdict_report (GMimeSignature *msig)
 	time_t t;
 	const char *status, *created, *expires;
 	gchar *certdata, *report;
+	GMimeSignatureStatus sigstat;
 
-	switch (g_mime_signature_get_status (msig)) {
+	sigstat = g_mime_signature_get_status (msig);
-	case GMIME_SIGNATURE_STATUS_GOOD:  status = "good";  break;
+	if (sigstat & GMIME_SIGNATURE_STATUS_ERROR_MASK)
-	case GMIME_SIGNATURE_STATUS_ERROR: status = "error"; break;
+	  status = "error";
-	case GMIME_SIGNATURE_STATUS_BAD:   status = "bad";   break;
+	else if (sigstat & GMIME_SIGNATURE_STATUS_RED)
-	default: g_return_val_if_reached (NULL);
+	  status = "bad";
-	}
+	else if (sigstat & GMIME_SIGNATURE_STATUS_GREEN)
+	  status = "good";
+	else
+	  g_return_val_if_reached (NULL);
 
 	t = g_mime_signature_get_created (msig);
 	created = (t == 0 || t == (time_t)-1) ? "?" : mu_date_str_s ("%x", t);
@@ -320,14 +247,13 @@ get_status_report (GMimeSignatureList *sigs)
 		msig = g_mime_signature_list_get_signature (sigs, i);
 		sigstat = g_mime_signature_get_status (msig);
 
-		switch (sigstat) {
+		/* downgrade our expectations */
-		case GMIME_SIGNATURE_STATUS_GOOD:              break;
+		if ((sigstat & GMIME_SIGNATURE_STATUS_ERROR_MASK) &&
-		case GMIME_SIGNATURE_STATUS_ERROR:
+		    status != MU_MSG_PART_SIG_STATUS_ERROR)
-			status = MU_MSG_PART_SIG_STATUS_ERROR; break;
+		  status = MU_MSG_PART_SIG_STATUS_ERROR;
-		case GMIME_SIGNATURE_STATUS_BAD:
+		else if ((sigstat & GMIME_SIGNATURE_STATUS_RED) &&
-			status = MU_MSG_PART_SIG_STATUS_BAD;   break;
+			 status == MU_MSG_PART_SIG_STATUS_GOOD)
-		default: g_return_val_if_reached (NULL);
+		  status = MU_MSG_PART_SIG_STATUS_BAD;
-		}
 
 		rep  = get_verdict_report (msig);
 		report = g_strdup_printf ("%s%s%d: %s",
@@ -371,20 +297,11 @@ mu_msg_crypto_verify_part (GMimeMultipartSigned *sig, MuMsgOptions opts,
 {
 	/* the signature status */
 	MuMsgPartSigStatusReport *report;
-	GMimeCryptoContext *ctx;
 	GMimeSignatureList *sigs;
 
 	g_return_if_fail (GMIME_IS_MULTIPART_SIGNED(sig));
 
-	ctx = get_crypto_context (opts, NULL, NULL, err);
+	sigs = g_mime_multipart_signed_verify (sig, GMIME_VERIFY_NONE, err);
-	if (!ctx) {
-		mu_util_g_set_error (err, MU_ERROR_CRYPTO,
-				     "failed to get crypto context");
-		return;
-	}
-
-	sigs = g_mime_multipart_signed_verify (sig, ctx, err);
-	g_object_unref (ctx);
 	if (!sigs) {
 		if (err && !*err)
 			mu_util_g_set_error (err, MU_ERROR_CRYPTO,
@@ -434,29 +351,12 @@ mu_msg_crypto_decrypt_part (GMimeMultipartEncrypted *enc, MuMsgOptions opts,
 			    GError **err)
 {
 	GMimeObject *dec;
-	GMimeCryptoContext *ctx;
 	GMimeDecryptResult *res;
 
 	g_return_val_if_fail (GMIME_IS_MULTIPART_ENCRYPTED(enc), NULL);
 
-	ctx = get_crypto_context (opts, func, user_data, err);
-	if (!ctx) {
-		mu_util_g_set_error (err, MU_ERROR_CRYPTO,
-				     "failed to get crypto context");
-		return NULL;
-	}
-
-	/* at the time of writing, there is a small leak in
-	 * g_mime_multipart_encrypted_decrypt; I've notified its
-	 * author and it has been fixed 2012-09-12:
-	 *   http://git.gnome.org/browse/gmime/commit/
-	 *   ?id=1bacd43b50d91bd03a4ae1dc9f46f5783dee61b1
-	 * (or GMime > 2.6.10)
-	 *   */
 	res = NULL;
-	dec = g_mime_multipart_encrypted_decrypt (enc, ctx, &res, err);
+	dec = g_mime_multipart_encrypted_decrypt (enc, GMIME_DECRYPT_NONE, NULL, &res, err);
-	g_object_unref (ctx);
-
 	check_decrypt_result(enc, res, err);
 
 	if (!dec) {

lib/mu-msg-file.c

@@ -159,7 +159,7 @@ init_mime_msg (MuMsgFile *self, const char* path, GError **err)
 		return FALSE;
 	}
 
-	self->_mime_msg = g_mime_parser_construct_message (parser);
+	self->_mime_msg = g_mime_parser_construct_message (parser, NULL);
 	g_object_unref (parser);
 	if (!self->_mime_msg) {
 		g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME,
@@ -171,15 +171,15 @@ init_mime_msg (MuMsgFile *self, const char* path, GError **err)
 }
 
 static char*
-get_recipient (MuMsgFile *self, GMimeRecipientType rtype)
+get_recipient (MuMsgFile *self, GMimeAddressType atype)
 {
 	char			*recip;
 	InternetAddressList	*recips;
 
-	recips = g_mime_message_get_recipients (self->_mime_msg, rtype);
+	recips = g_mime_message_get_addresses (self->_mime_msg, atype);
 
 	/* FALSE --> don't encode */
-	recip = (char*)internet_address_list_to_string (recips, FALSE);
+	recip = (char*)internet_address_list_to_string (recips, NULL, FALSE);
 
 	if (recip && !g_utf8_validate (recip, -1, NULL)) {
 		g_debug ("invalid recipient in %s\n", self->_path);
@@ -488,7 +488,7 @@ mu_msg_mime_part_to_string (GMimePart *part, gboolean *err)
 	*err = TRUE; /* guilty until proven innocent */
 	g_return_val_if_fail (GMIME_IS_PART(part), NULL);
 
-	wrapper = g_mime_part_get_content_object (part);
+	wrapper = g_mime_part_get_content (part);
 	if (!wrapper) {
 		/* this happens with invalid mails */
 		g_debug ("failed to create data wrapper");
@@ -545,20 +545,21 @@ get_references  (MuMsgFile *self)
 	for (msgids = NULL, u = 0; headers[u]; ++u) {
 
 		char *str;
-		const GMimeReferences *cur;
 		GMimeReferences *mime_refs;
+		int i, refs_len;
 
 		str = mu_msg_file_get_header (self, headers[u]);
 		if (!str)
 			continue;
 
-		mime_refs = g_mime_references_decode (str);
+		mime_refs = g_mime_references_parse (NULL, str);
 		g_free (str);
 
-		for (cur = mime_refs; cur;
+		refs_len = g_mime_references_length (mime_refs);
-		     cur = g_mime_references_get_next(cur)) {
+		for (i = 0; i < refs_len; ++i) {
 			const char* msgid;
-			msgid = g_mime_references_get_message_id (cur);
+			msgid = g_mime_references_get_message_id (mime_refs, i);
+
 			/* don't include duplicates */
 			if (msgid && !contains (msgids, msgid))
 				/* explicitly ensure it's utf8-safe,
@@ -638,13 +639,14 @@ cleanup_maybe (const char *str, gboolean *do_free)
 
 
 
-G_GNUC_CONST static GMimeRecipientType
+G_GNUC_CONST static GMimeAddressType
-recipient_type (MuMsgFieldId mfid)
+address_type (MuMsgFieldId mfid)
 {
 	switch (mfid) {
-	case MU_MSG_FIELD_ID_BCC: return GMIME_RECIPIENT_TYPE_BCC;
+	case MU_MSG_FIELD_ID_BCC : return GMIME_ADDRESS_TYPE_BCC;
-	case MU_MSG_FIELD_ID_CC : return GMIME_RECIPIENT_TYPE_CC;
+	case MU_MSG_FIELD_ID_CC	 : return GMIME_ADDRESS_TYPE_CC;
-	case MU_MSG_FIELD_ID_TO : return GMIME_RECIPIENT_TYPE_TO;
+	case MU_MSG_FIELD_ID_TO	 : return GMIME_ADDRESS_TYPE_TO;
+	case MU_MSG_FIELD_ID_FROM: return GMIME_ADDRESS_TYPE_FROM;
 	default: g_return_val_if_reached (-1);
 	}
 }
@@ -679,12 +681,10 @@ mu_msg_file_get_str_field (MuMsgFile *self, MuMsgFieldId mfid,
 
 	case MU_MSG_FIELD_ID_BCC:
 	case MU_MSG_FIELD_ID_CC:
-	case MU_MSG_FIELD_ID_TO: *do_free = TRUE;
-		return get_recipient (self, recipient_type(mfid));
-
 	case MU_MSG_FIELD_ID_FROM:
-		return (char*)cleanup_maybe
+	case MU_MSG_FIELD_ID_TO:
-			(g_mime_message_get_sender (self->_mime_msg), do_free);
+		*do_free = TRUE;
+		return get_recipient (self, address_type(mfid));
 
 	case MU_MSG_FIELD_ID_PATH: return self->_path;
 
@@ -736,9 +736,9 @@ mu_msg_file_get_num_field (MuMsgFile *self, const MuMsgFieldId mfid)
 	switch (mfid) {
 
 	case MU_MSG_FIELD_ID_DATE: {
-		time_t t;
+		GDateTime *dt;
-		g_mime_message_get_date (self->_mime_msg, &t, NULL);
+		dt = g_mime_message_get_date (self->_mime_msg);
-		return (time_t)t;
+		return dt ? g_date_time_to_unix (dt) : 0;
 	}
 
 	case MU_MSG_FIELD_ID_FLAGS:

lib/mu-msg-part.c

@@ -113,18 +113,22 @@ accumulate_text_message (MuMsg *msg, MuMsgPart *part, GString **gstrp)
 	/* put sender, recipients and subject in the string, so they
 	 * can be indexed as well */
 	mimemsg = GMIME_MESSAGE (part->data);
-	str = g_mime_message_get_sender (mimemsg);
+	addresses = g_mime_message_get_addresses (mimemsg, GMIME_ADDRESS_TYPE_FROM);
+	adrs = internet_address_list_to_string (addresses, NULL, FALSE);
 	g_string_append_printf
-		(*gstrp, "%s%s", str ? str : "", str ? "\n" : "");
+		(*gstrp, "%s%s", adrs ? adrs : "", adrs ? "\n" : "");
+	g_free (adrs);
+
 	str = g_mime_message_get_subject (mimemsg);
 	g_string_append_printf
 		(*gstrp, "%s%s", str ? str : "", str ? "\n" : "");
-		addresses = g_mime_message_get_all_recipients (mimemsg);
+
-		adrs = internet_address_list_to_string (addresses, FALSE);
+	addresses = g_mime_message_get_all_recipients (mimemsg);
-		g_object_unref (addresses);
+	adrs = internet_address_list_to_string (addresses, NULL, FALSE);
-		g_string_append_printf
+	g_object_unref (addresses);
-			(*gstrp, "%s%s", adrs ? adrs : "", adrs ? "\n" : "");
+	g_string_append_printf
-		g_free (adrs);
+		(*gstrp, "%s%s", adrs ? adrs : "", adrs ? "\n" : "");
+	g_free (adrs);
 }
 
 static void
@@ -225,7 +229,7 @@ get_part_size (GMimePart *part)
 	GMimeDataWrapper *wrapper;
 	GMimeStream *stream;
 
-	wrapper = g_mime_part_get_content_object (part);
+	wrapper = g_mime_part_get_content (part);
 	if (!GMIME_IS_DATA_WRAPPER(wrapper))
 		return -1;
 
@@ -665,7 +669,7 @@ write_part_to_fd (GMimePart *part, int fd, GError **err)
 	}
 	g_mime_stream_fs_set_owner (GMIME_STREAM_FS(stream), FALSE);
 
-	wrapper = g_mime_part_get_content_object (part);
+	wrapper = g_mime_part_get_content (part);
 	if (!GMIME_IS_DATA_WRAPPER(wrapper)) {
 		g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME,
 			     "failed to create wrapper");
@@ -694,7 +698,7 @@ static gboolean
 write_object_to_fd (GMimeObject *obj, int fd, GError **err)
 {
 	gchar *str;
-	str = g_mime_object_to_string (obj);
+	str = g_mime_object_to_string (obj, NULL);
 
 	if (!str) {
 		g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME,

lib/mu-msg.c

@@ -48,12 +48,7 @@ gmime_init (void)
 {
 	g_return_if_fail (!_gmime_initialized);
 
-#ifdef GMIME_ENABLE_RFC2047_WORKAROUNDS
+	g_mime_init();
-	g_mime_init(GMIME_ENABLE_RFC2047_WORKAROUNDS);
-#else
-	g_mime_init(0);
-#endif /* GMIME_ENABLE_RFC2047_WORKAROUNDS */
-
 	_gmime_initialized = TRUE;
 }
 
@@ -385,7 +380,7 @@ mu_msg_get_mailing_list (MuMsg *self)
 	if (!ml)
 		return NULL;
 
-	decml = g_mime_utils_header_decode_text (ml);
+	decml = g_mime_utils_header_decode_text (NULL, ml);
 	if (!decml)
 		return NULL;
 
@@ -566,21 +561,22 @@ get_content_type_parameters (MuMsg *self, MuMsgOptions opts, gboolean want_html)
 
 	if (cdata.ctype) {
 
-		GSList			*paramlist;
+		GSList			*gslist;
+		GMimeParamList		*paramlist;
 		const GMimeParam	*param;
+		int i, len;
 
-		paramlist = NULL;
+		gslist	  = NULL;
-		param	  = g_mime_content_type_get_params (cdata.ctype);
+		paramlist = g_mime_content_type_get_parameters (cdata.ctype);
+		len	  = g_mime_param_list_length (paramlist);
 
-		for (; param; param = param->next) {
+		for (i = 0; i < len; ++i) {
-			paramlist = g_slist_prepend (paramlist,
+			param = g_mime_param_list_get_parameter_at (paramlist, i);
-						     g_strdup (param->name));
+			gslist = g_slist_prepend (gslist, g_strdup (param->name));
-
+			gslist = g_slist_prepend (gslist, g_strdup (param->value));
-			paramlist = g_slist_prepend (paramlist,
-						     g_strdup (param->value));
 		}
 
-		return free_later_lst(self, g_slist_reverse (paramlist));
+		return free_later_lst (self, g_slist_reverse (gslist));
 	}
 	return NULL;
 }
@@ -660,6 +656,10 @@ fill_contact (MuMsgContact *self, InternetAddress *addr,
 		return FALSE;
 
 	self->name = internet_address_get_name (addr);
+	if (mu_str_is_empty (self->name)) {
+		self->name = NULL;
+	}
+
 	self->type = ctype;
 
 	/* we only support internet mailbox addresses; if we don't
@@ -716,7 +716,7 @@ addresses_foreach (const char* addrs, MuMsgContactType ctype,
 	if (!addrs)
 		return;
 
-	addrlist = internet_address_list_parse_string (addrs);
+	addrlist = internet_address_list_parse (NULL, addrs);
 	if (addrlist) {
 		address_list_foreach (addrlist, ctype, func, user_data);
 		g_object_unref (addrlist);
@@ -730,27 +730,20 @@ msg_contact_foreach_file (MuMsg *msg, MuMsgContactForeachFunc func,
 {
 	int i;
 	struct {
-		GMimeRecipientType     _gmime_type;
+		GMimeAddressType _gmime_type;
-		MuMsgContactType       _type;
+		MuMsgContactType _type;
 	} ctypes[] = {
-		{GMIME_RECIPIENT_TYPE_TO,  MU_MSG_CONTACT_TYPE_TO},
+		{GMIME_ADDRESS_TYPE_FROM,     MU_MSG_CONTACT_TYPE_FROM},
-		{GMIME_RECIPIENT_TYPE_CC,  MU_MSG_CONTACT_TYPE_CC},
+		{GMIME_ADDRESS_TYPE_REPLY_TO, MU_MSG_CONTACT_TYPE_REPLY_TO},
-		{GMIME_RECIPIENT_TYPE_BCC, MU_MSG_CONTACT_TYPE_BCC},
+		{GMIME_ADDRESS_TYPE_TO,       MU_MSG_CONTACT_TYPE_TO},
+		{GMIME_ADDRESS_TYPE_CC,       MU_MSG_CONTACT_TYPE_CC},
+		{GMIME_ADDRESS_TYPE_BCC,      MU_MSG_CONTACT_TYPE_BCC},
 	};
 
-	/* sender */
-	addresses_foreach (g_mime_message_get_sender (msg->_file->_mime_msg),
-			   MU_MSG_CONTACT_TYPE_FROM, func, user_data);
-
-	/* reply_to */
-	addresses_foreach (g_mime_message_get_reply_to (msg->_file->_mime_msg),
-			   MU_MSG_CONTACT_TYPE_REPLY_TO, func, user_data);
-
-	/* get to, cc, bcc */
 	for (i = 0; i != G_N_ELEMENTS(ctypes); ++i) {
 		InternetAddressList *addrlist;
-		addrlist = g_mime_message_get_recipients (msg->_file->_mime_msg,
+		addrlist = g_mime_message_get_addresses (msg->_file->_mime_msg,
-							  ctypes[i]._gmime_type);
+							 ctypes[i]._gmime_type);
 		address_list_foreach (addrlist, ctypes[i]._type, func, user_data);
 	}
 }