** Fixes bug #362638

2007-12-20  Matthew Barnes  <mbarnes@redhat.com>

	** Fixes bug #362638

	* calendar/gui/alarm-notify/alarm-notify.c:
	* calendar/gui/alarm-notify/alarm-notify.h:
	* calendar/gui/alarm-notify/alarm-queue.c:
	Rewrite message passing to use GThreadPool instead of EThread.

	* mail/mail-mt.h:
	Overhaul the message passing API:
	- Define a MailMsg type as the base message struct.
	- Define types for the various callback functions.
	- Add a priority value to each message (not yet used).
	- Add a reference count to each message.
	- Define a MailMsgInfo type for the virtual function table.
	- Record the size of message sub-types in MailMsgInfo.
	- New/changed functions:
	    mail_msg_new()   - Easier to use.
	    mail_msg_ref()   - Increase reference count.
	    mail_msg_unref() - Decrease reference count.
	    mail_msg_main_loop_push()    }
	    mail_msg_unordered_push()    } Submit MailMsgs to various
	    mail_msg_fast_ordered_push() } message-processing threads.
	    mail_msg_slow_ordered_push() }

	* mail/mail-mt.c (mail_msg_new):
	Use GSlice for memory allocation.

	* mail/mail-mt.c (mail_msg_ref), (mail_msg_unref):
	New functions increment/decrement a MailMsg's reference count.

	* mail/mail-mt.c (mail_cancel_hood_add), (mail_cancel_hook_remove):
	Convert the 'cancel_hook_list' from an  EDList to a GHookList and
	modify the API accordingly.

	* mail/mail-mt.c:
	Use GThreadPools instead of EThreads.
	Use GAsyncQueues instead of EMsgPorts.

	* mail/em-composer-utils.c:
	* mail/em-folder-browser.c:
	* mail/em-folder-properties.c:
	* mail/em-folder-tree.c:
	* mail/em-folder-utils.c:
	* mail/em-folder-view.c:
	* mail/em-format-html-print.c:
	* mail/em-format-html.c:
	* mail/em-subscribe-editor.c:
	* mail/em-sync-stream.c:
	* mail/importers/elm-importer.c:
	* mail/importers/mail-importer.c:
	* mail/importers/pine-importer.c:
	* mail/mail-component.c:
	* mail/mail-folder-cache.c:
	* mail/mail-mt.c:
	* mail/mail-ops.c:
	* mail/mail-ops.h:
	* mail/mail-send-recv.c:
	* mail/mail-session.c:
	* mail/mail-vfolder.c:
	* mail/message-list.c:
	* plugins/folder-unsubscribe/folder-unsubscribe.c:
	* plugins/groupwise-features/share-folder-common.c:
	* plugins/exchange-operations/exchange-folder.c:
	* plugins/mark-all-read/mark-all-read.c:
	* plugins/mailing-list-actions/mailing-list-actions.c:
	* plugins/itip-formatter/itip-formatter.c:
	* plugins/save-attachments/save-attachments.c:
	Use the new MailMsg API for messages.


svn path=/trunk/; revision=34730

26 files changed, 1421 insertions, 1641 deletions

diff --git a/mail/ChangeLog b/mail/ChangeLog
index a47e7ffee5..e5370135a7 100644
--- a/mail/ChangeLog
+++ b/mail/ChangeLog
@@ -1,3 +1,62 @@
+2007-12-20  Matthew Barnes  <mbarnes@redhat.com>
+
+	** Fixes part of bug #362638
+
+	* mail-mt.h:
+	Overhaul the message passing API:
+	- Define a MailMsg type as the base message struct.
+	- Define types for the various callback functions.
+	- Add a priority value to each message (not yet used).
+	- Add a reference count to each message.
+	- Define a MailMsgInfo type for the virtual function table.
+	- Record the size of message sub-types in MailMsgInfo.
+	- New/changed functions:
+	    mail_msg_new()   - Easier to use.
+	    mail_msg_ref()   - Increase reference count.
+	    mail_msg_unref() - Decrease reference count.
+	    mail_msg_main_loop_push()    }
+	    mail_msg_unordered_push()    } Submit MailMsgs to various
+	    mail_msg_fast_ordered_push() } message-processing threads.
+	    mail_msg_slow_ordered_push() }
+
+	* mail-mt.c (mail_msg_new):
+	Use GSlice for memory allocation.
+
+	* mail-mt.c (mail_msg_ref), (mail_msg_unref):
+	New functions increment/decrement a MailMsg's reference count.
+
+	* mail-mt.c (mail_cancel_hood_add), (mail_cancel_hook_remove):
+	Convert the 'cancel_hook_list' from an  EDList to a GHookList and
+	modify the API accordingly.
+
+	* mail-mt.c:
+	Use GThreadPools instead of EThreads.
+	Use GAsyncQueues instead of EMsgPorts.
+
+	* em-composer-utils.c:
+	* em-folder-browser.c:
+	* em-folder-properties.c:
+	* em-folder-tree.c:
+	* em-folder-utils.c:
+	* em-folder-view.c:
+	* em-format-html-print.c:
+	* em-format-html.c:
+	* em-subscribe-editor.c:
+	* em-sync-stream.c:
+	* importers/elm-importer.c:
+	* importers/mail-importer.c:
+	* importers/pine-importer.c:
+	* mail-component.c:
+	* mail-folder-cache.c:
+	* mail-mt.c:
+	* mail-ops.c:
+	* mail-ops.h:
+	* mail-send-recv.c:
+	* mail-session.c:
+	* mail-vfolder.c:
+	* message-list.c:
+	Use the new MailMsg API for messages.
+
 2007-12-18  Matthew Barnes  <mbarnes@redhat.com>
 
 	* mail-mt.c (do_op_status): Fix another compiler warning.
diff --git a/mail/em-composer-utils.c b/mail/em-composer-utils.c
index 580c9650f9..a2c75c3732 100644
--- a/mail/em-composer-utils.c
+++ b/mail/em-composer-utils.c
@@ -557,7 +557,7 @@ em_utils_composer_save_draft_cb (EMsgComposer *composer, int quit, gpointer user
 	    strcmp (account->drafts_folder_uri, default_drafts_folder_uri) != 0) {
 		int id;
 
-		id = mail_get_folder (account->drafts_folder_uri, 0, save_draft_folder, &folder, mail_thread_new);
+		id = mail_get_folder (account->drafts_folder_uri, 0, save_draft_folder, &folder, mail_msg_unordered_push);
 		mail_msg_wait (id);
 
 		if (!folder || !account->enabled) {
@@ -1108,7 +1108,7 @@ em_utils_redirect_message_by_uid (CamelFolder *folder, const char *uid)
 	g_return_if_fail (CAMEL_IS_FOLDER (folder));
 	g_return_if_fail (uid != NULL);
 
-	mail_get_message (folder, uid, redirect_msg, NULL, mail_thread_new);
+	mail_get_message (folder, uid, redirect_msg, NULL, mail_msg_unordered_push);
 }
 
 static void
@@ -1139,7 +1139,7 @@ em_utils_handle_receipt (CamelFolder *folder, const char *uid, CamelMimeMessage
 	}
 
 	if (msg == NULL) {
-		mail_get_messagex(folder, uid, emu_handle_receipt_message, NULL, mail_thread_new);
+		mail_get_messagex(folder, uid, emu_handle_receipt_message, NULL, mail_msg_unordered_push);
 		camel_message_info_free(info);
 		return;
 	}
@@ -1953,7 +1953,7 @@ em_utils_reply_to_message(CamelFolder *folder, const char *uid, CamelMimeMessage
 		rd->source = source;
 		if (rd->source)
 			g_object_ref(rd->source);
-		mail_get_message(folder, uid, reply_to_message, rd, mail_thread_new);
+		mail_get_message(folder, uid, reply_to_message, rd, mail_msg_unordered_push);
 
 		return;
 	}
@@ -2125,5 +2125,5 @@ em_utils_post_reply_to_message_by_uid (CamelFolder *folder, const char *uid)
 	g_return_if_fail (CAMEL_IS_FOLDER (folder));
 	g_return_if_fail (uid != NULL);
 
-	mail_get_message (folder, uid, post_reply_to_message, NULL, mail_thread_new);
+	mail_get_message (folder, uid, post_reply_to_message, NULL, mail_msg_unordered_push);
 }
diff --git a/mail/em-folder-browser.c b/mail/em-folder-browser.c
index de3067babf..f44a0e4648 100644
--- a/mail/em-folder-browser.c
+++ b/mail/em-folder-browser.c
@@ -908,7 +908,7 @@ get_view_query (ESearchBar *esb, CamelFolder *folder, const char *folder_uri)
 
 
 struct _setup_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *folder;
 	char *query;
@@ -916,16 +916,15 @@ struct _setup_msg {
 	GList *sources_folder;
 };
 
-static char *
-vfolder_setup_desc(struct _mail_msg *mm, int done)
+static gchar *
+vfolder_setup_desc(struct _setup_msg *m)
 {
 	return g_strdup(_("Searching"));
 }
 
 static void
-vfolder_setup_do(struct _mail_msg *mm)
+vfolder_setup_exec(struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
 	GList *l, *list = NULL;
 	CamelFolder *folder;
 
@@ -936,12 +935,12 @@ vfolder_setup_do(struct _mail_msg *mm)
 	l = m->sources_uri;
 	while (l) {
 		d(printf(" Adding uri: %s\n", (char *)l->data));
-		folder = mail_tool_uri_to_folder (l->data, 0, &mm->ex);
+		folder = mail_tool_uri_to_folder (l->data, 0, &m->base.ex);
 		if (folder) {
 			list = g_list_append(list, folder);
 		} else {
 			g_warning("Could not open vfolder source: %s", (char *)l->data);
-			camel_exception_clear(&mm->ex);
+			camel_exception_clear(&m->base.ex);
 		}
 		l = l->next;
 	}
@@ -965,17 +964,13 @@ vfolder_setup_do(struct _mail_msg *mm)
 }
 
 static void
-vfolder_setup_done(struct _mail_msg *mm)
+vfolder_setup_done(struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
-
-	m = m;
 }
 
 static void
-vfolder_setup_free (struct _mail_msg *mm)
+vfolder_setup_free (struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
 	GList *l;
 
 	camel_object_unref(m->folder);
@@ -996,11 +991,12 @@ vfolder_setup_free (struct _mail_msg *mm)
 	g_list_free(m->sources_folder);
 }
 
-static struct _mail_msg_op vfolder_setup_op = {
-	vfolder_setup_desc,
-	vfolder_setup_do,
-	vfolder_setup_done,
-	vfolder_setup_free,
+static MailMsgInfo vfolder_setup_info = {
+	sizeof (struct _setup_msg),
+	(MailMsgDescFunc) vfolder_setup_desc,
+	(MailMsgExecFunc) vfolder_setup_exec,
+	(MailMsgDoneFunc) vfolder_setup_done,
+	(MailMsgFreeFunc) vfolder_setup_free
 };
 
 /* sources_uri should be camel uri's */
@@ -1010,15 +1006,15 @@ vfolder_setup(CamelFolder *folder, const char *query, GList *sources_uri, GList
 	struct _setup_msg *m;
 	int id;
 
-	m = mail_msg_new(&vfolder_setup_op, NULL, sizeof (*m));
+	m = mail_msg_new(&vfolder_setup_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->query = g_strdup(query);
 	m->sources_uri = sources_uri;
 	m->sources_folder = sources_folder;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_slow_ordered_push (m);
 
 	return id;
 }
diff --git a/mail/em-folder-properties.c b/mail/em-folder-properties.c
index 98adb08588..8a2875969e 100644
--- a/mail/em-folder-properties.c
+++ b/mail/em-folder-properties.c
@@ -386,7 +386,7 @@ em_folder_properties_show(GtkWindow *parent, CamelFolder *folder, const char *ur
 	}
 
 	if (folder == NULL)
-		mail_get_folder(uri, 0, emfp_dialog_got_folder, NULL, mail_thread_new);
+		mail_get_folder(uri, 0, emfp_dialog_got_folder, NULL, mail_msg_unordered_push);
 	else
 		emfp_dialog_got_folder((char *)uri, folder, NULL);
 }
diff --git a/mail/em-folder-tree.c b/mail/em-folder-tree.c
index 714da2ef86..03475e51e8 100644
--- a/mail/em-folder-tree.c
+++ b/mail/em-folder-tree.c
@@ -846,7 +846,7 @@ fail:
 /* TODO: Merge the drop handling code/menu's into one spot using a popup target for details */
 /* Drop handling */
 struct _DragDataReceivedAsync {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	/* input data */
 	GdkDragContext *context;
@@ -871,17 +871,16 @@ emft_drop_folder(struct _DragDataReceivedAsync *m)
 
 	d(printf(" * Drop folder '%s' onto '%s'\n", m->selection->data, m->full_name));
 
-	if (!(src = mail_tool_uri_to_folder((char *)m->selection->data, 0, &m->msg.ex)))
+	if (!(src = mail_tool_uri_to_folder((char *)m->selection->data, 0, &m->base.ex)))
 		return;
 
 	em_folder_utils_copy_folders(src->parent_store, src->full_name, m->store, m->full_name?m->full_name:"", m->move);
 	camel_object_unref(src);
 }
 
-static char *
-emft_drop_async_desc (struct _mail_msg *mm, int done)
+static gchar *
+emft_drop_async__desc (struct _DragDataReceivedAsync *m)
 {
-	struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
 	CamelURL *url;
 	char *buf;
 
@@ -905,9 +904,8 @@ emft_drop_async_desc (struct _mail_msg *mm, int done)
 }
 
 static void
-emft_drop_async_drop (struct _mail_msg *mm)
+emft_drop_async__exec (struct _DragDataReceivedAsync *m)
 {
-	struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
 	CamelFolder *folder;
 
 	/* for types other than folder, we can't drop to the root path */
@@ -915,14 +913,14 @@ emft_drop_async_drop (struct _mail_msg *mm)
 		/* copy or move (aka rename) a folder */
 		emft_drop_folder(m);
 	} else if (m->full_name == NULL) {
-		camel_exception_set (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
+		camel_exception_set (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
 				     _("Cannot drop message(s) into toplevel store"));
-	} else if ((folder = camel_store_get_folder (m->store, m->full_name, 0, &mm->ex))) {
+	} else if ((folder = camel_store_get_folder (m->store, m->full_name, 0, &m->base.ex))) {
 		switch (m->info) {
 		case DND_DROP_TYPE_UID_LIST:
 			/* import a list of uids from another evo folder */
-			em_utils_selection_get_uidlist(m->selection, folder, m->move, &mm->ex);
-			m->moved = m->move && !camel_exception_is_set(&mm->ex);
+			em_utils_selection_get_uidlist(m->selection, folder, m->move, &m->base.ex);
+			m->moved = m->move && !camel_exception_is_set(&m->base.ex);
 			break;
 		case DND_DROP_TYPE_MESSAGE_RFC822:
 			/* import a message/rfc822 stream */
@@ -940,10 +938,25 @@ emft_drop_async_drop (struct _mail_msg *mm)
 }
 
 static void
-emft_drop_async_free (struct _mail_msg *mm)
+emft_drop_async__done (struct _DragDataReceivedAsync *m)
 {
-	struct _DragDataReceivedAsync *m = (struct _DragDataReceivedAsync *) mm;
+	gboolean success, delete;
 
+	/* ?? */
+	if (m->aborted) {
+		success = FALSE;
+		delete = FALSE;
+	} else {
+		success = !camel_exception_is_set (&m->base.ex);
+		delete = success && m->move && !m->moved;
+	}
+	
+	gtk_drag_finish (m->context, success, delete, GDK_CURRENT_TIME);
+}
+
+static void
+emft_drop_async__free (struct _DragDataReceivedAsync *m)
+{
 	g_object_unref(m->context);
 	camel_object_unref(m->store);
 	g_free(m->full_name);
@@ -952,18 +965,19 @@ emft_drop_async_free (struct _mail_msg *mm)
 	g_free(m->selection);
 }
 
-static struct _mail_msg_op emft_drop_async_op = {
-	emft_drop_async_desc,
-	emft_drop_async_drop,
-	NULL,
-	emft_drop_async_free,
+static MailMsgInfo emft_drop_async_info = {
+	sizeof (struct _DragDataReceivedAsync),
+	(MailMsgDescFunc) emft_drop_async__desc,
+	(MailMsgExecFunc) emft_drop_async__exec,
+	(MailMsgDoneFunc) emft_drop_async__done,
+	(MailMsgFreeFunc) emft_drop_async__free
 };
 
 static void
 tree_drag_data_action(struct _DragDataReceivedAsync *m)
 {
 	m->move = m->action == GDK_ACTION_MOVE;
-	e_thread_put (mail_thread_new, (EMsg *) m);
+	mail_msg_unordered_push (m);
 }
 
 static void
@@ -990,7 +1004,7 @@ emft_drop_popup_cancel(EPopup *ep, EPopupItem *item, void *data)
 	struct _DragDataReceivedAsync *m = data;
 
 	m->aborted = TRUE;
-	mail_msg_free(&m->msg);
+	mail_msg_unref(m);
 }
 
 static EPopupItem emft_drop_popup_menu[] = {
@@ -1046,7 +1060,7 @@ tree_drag_data_received(GtkWidget *widget, GdkDragContext *context, int x, int y
 		return;
 	}
 
-	m = mail_msg_new (&emft_drop_async_op, NULL, sizeof (struct _DragDataReceivedAsync));
+	m = mail_msg_new (&emft_drop_async_info);
 	m->context = context;
 	g_object_ref(context);
 	m->store = store;
@@ -1685,7 +1699,7 @@ dump_fi (CamelFolderInfo *fi, int depth)
 #endif
 
 struct _EMFolderTreeGetFolderInfo {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	/* input data */
 	GtkTreeRowReference *root;
@@ -1698,10 +1712,9 @@ struct _EMFolderTreeGetFolderInfo {
 	CamelFolderInfo *fi;
 };
 
-static char *
-emft_get_folder_info__desc(struct _mail_msg *mm, int done)
+static gchar *
+emft_get_folder_info__desc (struct _EMFolderTreeGetFolderInfo *m)
 {
-	struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *)mm;
 	char *ret, *name;
 
 	name = camel_service_get_name((CamelService *)m->store, TRUE);
@@ -1711,18 +1724,16 @@ emft_get_folder_info__desc(struct _mail_msg *mm, int done)
 }
 
 static void
-emft_get_folder_info__get (struct _mail_msg *mm)
+emft_get_folder_info__exec (struct _EMFolderTreeGetFolderInfo *m)
 {
-	struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *) mm;
 	guint32 flags = m->flags | CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;
 
-	m->fi = camel_store_get_folder_info (m->store, m->top, flags, &mm->ex);
+	m->fi = camel_store_get_folder_info (m->store, m->top, flags, &m->base.ex);
 }
 
 static void
-emft_get_folder_info__got (struct _mail_msg *mm)
+emft_get_folder_info__done (struct _EMFolderTreeGetFolderInfo *m)
 {
-	struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *) mm;
 	struct _EMFolderTreePrivate *priv = m->emft->priv;
 	struct _EMFolderTreeModelStoreInfo *si;
 	GtkTreeIter root, iter;
@@ -1750,7 +1761,7 @@ emft_get_folder_info__got (struct _mail_msg *mm)
 	gtk_tree_model_get_iter ((GtkTreeModel *) model, &root, path);
 
 	/* if we had an error, then we need to re-set the load subdirs state and collapse the node */
-	if (!m->fi && camel_exception_is_set(&mm->ex)) {
+	if (!m->fi && camel_exception_is_set(&m->base.ex)) {
 		gtk_tree_store_set(model, &root, COL_BOOL_LOAD_SUBDIRS, TRUE, -1);
 		gtk_tree_view_collapse_row (priv->treeview, path);
 		gtk_tree_path_free (path);
@@ -1805,10 +1816,8 @@ emft_get_folder_info__got (struct _mail_msg *mm)
 }
 
 static void
-emft_get_folder_info__free (struct _mail_msg *mm)
+emft_get_folder_info__free (struct _EMFolderTreeGetFolderInfo *m)
 {
-	struct _EMFolderTreeGetFolderInfo *m = (struct _EMFolderTreeGetFolderInfo *) mm;
-
 	camel_store_free_folder_info (m->store, m->fi);
 
 	gtk_tree_row_reference_free (m->root);
@@ -1817,11 +1826,12 @@ emft_get_folder_info__free (struct _mail_msg *mm)
 	g_free (m->top);
 }
 
-static struct _mail_msg_op get_folder_info_op = {
-	emft_get_folder_info__desc,
-	emft_get_folder_info__get,
-	emft_get_folder_info__got,
-	emft_get_folder_info__free,
+static MailMsgInfo get_folder_info_info = {
+	sizeof (struct _EMFolderTreeGetFolderInfo),
+	(MailMsgDescFunc) emft_get_folder_info__desc,
+	(MailMsgExecFunc) emft_get_folder_info__exec,
+	(MailMsgDoneFunc) emft_get_folder_info__done,
+	(MailMsgFreeFunc) emft_get_folder_info__free
 };
 
 static void
@@ -1884,7 +1894,7 @@ emft_tree_row_expanded (GtkTreeView *treeview, GtkTreeIter *root, GtkTreePath *t
 
 	gtk_tree_store_set((GtkTreeStore *)model, root, COL_BOOL_LOAD_SUBDIRS, FALSE, -1);
 
-	m = mail_msg_new (&get_folder_info_op, NULL, sizeof (struct _EMFolderTreeGetFolderInfo));
+	m = mail_msg_new (&get_folder_info_info);
 	m->root = gtk_tree_row_reference_new (model, tree_path);
 	camel_object_ref (store);
 	m->store = store;
@@ -1893,7 +1903,7 @@ emft_tree_row_expanded (GtkTreeView *treeview, GtkTreeIter *root, GtkTreePath *t
 	m->top = full_name;
 	m->flags = CAMEL_STORE_FOLDER_INFO_RECURSIVE|CAMEL_STORE_FOLDER_INFO_FAST;
 
-	e_thread_put (mail_thread_new, (EMsg *) m);
+	mail_msg_unordered_push (m);
 }
 
 static gboolean
diff --git a/mail/em-folder-utils.c b/mail/em-folder-utils.c
index 03d070540b..a12b758f82 100644
--- a/mail/em-folder-utils.c
+++ b/mail/em-folder-utils.c
@@ -85,7 +85,7 @@ emfu_is_special_local_folder (const char *name)
 }
 
 struct _EMCopyFolders {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	/* input data */
 	CamelStore *fromstore;
@@ -97,18 +97,15 @@ struct _EMCopyFolders {
 	int delete;
 };
 
-static char *
-emft_copy_folders__desc (struct _mail_msg *mm, int complete)
+static gchar *
+emft_copy_folders__desc (struct _EMCopyFolders *m, gint complete)
 {
-	struct _EMCopyFolders *m = (struct _EMCopyFolders *) mm;
-
 	return g_strdup_printf (_("Copying `%s' to `%s'"), m->frombase, m->tobase);
 }
 
 static void
-emft_copy_folders__copy (struct _mail_msg *mm)
+emft_copy_folders__exec (struct _EMCopyFolders *m)
 {
-	struct _EMCopyFolders *m = (struct _EMCopyFolders *) mm;
 	guint32 flags = CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_RECURSIVE | CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;
 	GList *pending = NULL, *deleting = NULL, *l;
 	GString *fromname, *toname;
@@ -116,7 +113,7 @@ emft_copy_folders__copy (struct _mail_msg *mm)
 	const char *tmp;
 	int fromlen;
 
-	if (!(fi = camel_store_get_folder_info (m->fromstore, m->frombase, flags, &mm->ex)))
+	if (!(fi = camel_store_get_folder_info (m->fromstore, m->frombase, flags, &m->base.ex)))
 		return;
 
 	pending = g_list_append (pending, fi);
@@ -156,8 +153,8 @@ emft_copy_folders__copy (struct _mail_msg *mm)
 			if ((info->flags & CAMEL_FOLDER_NOSELECT) == 0) {
 				d(printf ("this folder is selectable\n"));
 				if (m->tostore == m->fromstore && m->delete) {
-					camel_store_rename_folder (m->fromstore, info->full_name, toname->str, &mm->ex);
-					if (camel_exception_is_set (&mm->ex))
+					camel_store_rename_folder (m->fromstore, info->full_name, toname->str, &m->base.ex);
+					if (camel_exception_is_set (&m->base.ex))
 						goto exception;
 
 					/* this folder no longer exists, unsubscribe it */
@@ -166,16 +163,16 @@ emft_copy_folders__copy (struct _mail_msg *mm)
 
 					deleted = 1;
 				} else {
-					if (!(fromfolder = camel_store_get_folder (m->fromstore, info->full_name, 0, &mm->ex)))
+					if (!(fromfolder = camel_store_get_folder (m->fromstore, info->full_name, 0, &m->base.ex)))
 						goto exception;
 
-					if (!(tofolder = camel_store_get_folder (m->tostore, toname->str, CAMEL_STORE_FOLDER_CREATE, &mm->ex))) {
+					if (!(tofolder = camel_store_get_folder (m->tostore, toname->str, CAMEL_STORE_FOLDER_CREATE, &m->base.ex))) {
 						camel_object_unref (fromfolder);
 						goto exception;
 					}
 
 					uids = camel_folder_get_uids (fromfolder);
-					camel_folder_transfer_messages_to (fromfolder, uids, tofolder, NULL, m->delete, &mm->ex);
+					camel_folder_transfer_messages_to (fromfolder, uids, tofolder, NULL, m->delete, &m->base.ex);
 					camel_folder_free_uids (fromfolder, uids);
 
 					if (m->delete)
@@ -186,7 +183,7 @@ emft_copy_folders__copy (struct _mail_msg *mm)
 				}
 			}
 
-			if (camel_exception_is_set (&mm->ex))
+			if (camel_exception_is_set (&m->base.ex))
 				goto exception;
 			else if (m->delete && !deleted)
 				deleting = g_list_prepend (deleting, info);
@@ -227,10 +224,8 @@ emft_copy_folders__copy (struct _mail_msg *mm)
 }
 
 static void
-emft_copy_folders__free (struct _mail_msg *mm)
+emft_copy_folders__free (struct _EMCopyFolders *m)
 {
-	struct _EMCopyFolders *m = (struct _EMCopyFolders *) mm;
-
 	camel_object_unref (m->fromstore);
 	camel_object_unref (m->tostore);
 
@@ -238,11 +233,12 @@ emft_copy_folders__free (struct _mail_msg *mm)
 	g_free (m->tobase);
 }
 
-static struct _mail_msg_op copy_folders_op = {
-	emft_copy_folders__desc,
-	emft_copy_folders__copy,
-	NULL,
-	emft_copy_folders__free,
+static MailMsgInfo copy_folders_info = {
+	sizeof (struct _EMCopyFolders),
+	(MailMsgDescFunc) emft_copy_folders__desc,
+	(MailMsgExecFunc) emft_copy_folders__exec,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) emft_copy_folders__free
 };
 
 int
@@ -251,7 +247,7 @@ em_folder_utils_copy_folders(CamelStore *fromstore, const char *frombase, CamelS
 	struct _EMCopyFolders *m;
 	int seq;
 
-	m = mail_msg_new (&copy_folders_op, NULL, sizeof (struct _EMCopyFolders));
+	m = mail_msg_new (&copy_folders_info);
 	camel_object_ref (fromstore);
 	m->fromstore = fromstore;
 	camel_object_ref (tostore);
@@ -259,9 +255,9 @@ em_folder_utils_copy_folders(CamelStore *fromstore, const char *frombase, CamelS
 	m->frombase = g_strdup (frombase);
 	m->tobase = g_strdup (tobase);
 	m->delete = delete;
-	seq = m->msg.seq;
+	seq = m->base.seq;
 
-	e_thread_put (mail_thread_new, (EMsg *) m);
+	mail_msg_unordered_push (m);
 
 	return seq;
 }
@@ -558,7 +554,7 @@ em_folder_utils_rename_folder (CamelFolder *folder)
 }
 
 struct _EMCreateFolder {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	/* input data */
 	CamelStore *store;
@@ -582,41 +578,33 @@ struct _EMCreateFolderTempData
 	char *uri;
 };
 
-static char *
-emfu_create_folder__desc (struct _mail_msg *mm, int done)
+static gchar *
+emfu_create_folder__desc (struct _EMCreateFolder *m)
 {
-	struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
-
 	return g_strdup_printf (_("Creating folder `%s'"), m->full_name);
 }
 
 static void
-emfu_create_folder__create (struct _mail_msg *mm)
+emfu_create_folder__exec (struct _EMCreateFolder *m)
 {
-	struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
-
 	d(printf ("creating folder parent='%s' name='%s' full_name='%s'\n", m->parent, m->name, m->full_name));
 
-	if ((m->fi = camel_store_create_folder (m->store, m->parent, m->name, &mm->ex))) {
+	if ((m->fi = camel_store_create_folder (m->store, m->parent, m->name, &m->base.ex))) {
 		if (camel_store_supports_subscriptions (m->store))
-			camel_store_subscribe_folder (m->store, m->full_name, &mm->ex);
+			camel_store_subscribe_folder (m->store, m->full_name, &m->base.ex);
 	}
 }
 
 static void
-emfu_create_folder__created (struct _mail_msg *mm)
+emfu_create_folder__done (struct _EMCreateFolder *m)
 {
-	struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
-
 	if (m->done)
 		m->done (m->fi, m->user_data);
 }
 
 static void
-emfu_create_folder__free (struct _mail_msg *mm)
+emfu_create_folder__free (struct _EMCreateFolder *m)
 {
-	struct _EMCreateFolder *m = (struct _EMCreateFolder *) mm;
-
 	camel_store_free_folder_info (m->store, m->fi);
 	camel_object_unref (m->store);
 	g_free (m->full_name);
@@ -624,11 +612,12 @@ emfu_create_folder__free (struct _mail_msg *mm)
 	g_free (m->name);
 }
 
-static struct _mail_msg_op create_folder_op = {
-	emfu_create_folder__desc,
-	emfu_create_folder__create,
-	emfu_create_folder__created,
-	emfu_create_folder__free,
+static MailMsgInfo create_folder_info = {
+	sizeof (struct _EMCreateFolder),
+	(MailMsgDescFunc) emfu_create_folder__desc,
+	(MailMsgExecFunc) emfu_create_folder__exec,
+	(MailMsgDoneFunc) emfu_create_folder__done,
+	(MailMsgFreeFunc) emfu_create_folder__free
 };
 
 
@@ -649,7 +638,7 @@ emfu_create_folder_real (CamelStore *store, const char *full_name, void (* done)
 		parent = namebuf;
 	}
 
-	m = mail_msg_new (&create_folder_op, NULL, sizeof (struct _EMCreateFolder));
+	m = mail_msg_new (&create_folder_info);
 	camel_object_ref (store);
 	m->store = store;
 	m->full_name = g_strdup (full_name);
@@ -660,8 +649,8 @@ emfu_create_folder_real (CamelStore *store, const char *full_name, void (* done)
 
 	g_free (namebuf);
 
-	id = m->msg.seq;
-	e_thread_put (mail_thread_new, (EMsg *) m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 
 	return id;
 }
diff --git a/mail/em-folder-view.c b/mail/em-folder-view.c
index 2f77d96919..85d7334dcb 100644
--- a/mail/em-folder-view.c
+++ b/mail/em-folder-view.c
@@ -72,6 +72,7 @@
 #include <gtkhtml/gtkhtml-stream.h>
 
 #include <libedataserver/e-data-server-util.h>
+#include <libedataserver/e-msgport.h>
 
 #include "menus/gal-view-etable.h"
 #include "menus/gal-view-factory-etable.h"
@@ -778,7 +779,7 @@ emfv_got_folder(char *uri, CamelFolder *folder, void *data)
 static void
 emfv_set_folder_uri(EMFolderView *emfv, const char *uri)
 {
-	mail_get_folder(uri, 0, emfv_got_folder, emfv, mail_thread_queued);
+	mail_get_folder(uri, 0, emfv_got_folder, emfv, mail_msg_fast_ordered_push);
 }
 
 static void
@@ -1885,7 +1886,7 @@ filter_type_uid (CamelFolder *folder, const char *uid, const char *source, int t
 	data->type = type;
 	data->source = source;
 
-	mail_get_message (folder, uid, filter_type_got_message, data, mail_thread_new);
+	mail_get_message (folder, uid, filter_type_got_message, data, mail_msg_unordered_push);
 }
 
 static void
@@ -1983,7 +1984,7 @@ vfolder_type_uid (CamelFolder *folder, const char *uid, const char *uri, int typ
 	data->type = type;
 	data->uri = g_strdup (uri);
 
-	mail_get_message (folder, uid, vfolder_type_got_message, data, mail_thread_new);
+	mail_get_message (folder, uid, vfolder_type_got_message, data, mail_msg_unordered_push);
 }
 
 static void
@@ -2560,7 +2561,7 @@ emfv_message_selected_timeout(void *data)
 						       emfv->displayed_uid);
 			gtk_html_stream_close(hstream, GTK_HTML_STREAM_OK);
 */
-			mail_get_messagex(emfv->folder, emfv->displayed_uid, emfv_list_done_message_selected, emfv, mail_thread_queued);
+			mail_get_messagex(emfv->folder, emfv->displayed_uid, emfv_list_done_message_selected, emfv, mail_msg_fast_ordered_push);
 		} else {
 			e_profile_event_emit("goto.empty", "", 0);
 			g_free(emfv->priv->selected_uid);
diff --git a/mail/em-format-html-print.c b/mail/em-format-html-print.c
index 1663ddc89b..00ffc7b615 100644
--- a/mail/em-format-html-print.c
+++ b/mail/em-format-html-print.c
@@ -228,7 +228,7 @@ em_format_html_print_message (EMFormatHTMLPrint *efhp,
 	g_object_ref (efhp);
 
 	mail_get_message (
-		folder, uid, emfhp_got_message, efhp, mail_thread_new);
+		folder, uid, emfhp_got_message, efhp, mail_msg_unordered_push);
 }
 
 void
diff --git a/mail/em-format-html.c b/mail/em-format-html.c
index dc2109407d..1339aa8ec0 100644
--- a/mail/em-format-html.c
+++ b/mail/em-format-html.c
@@ -176,7 +176,7 @@ efh_gtkhtml_destroy(GtkHTML *html, EMFormatHTML *efh)
 	if (efh->priv->format_timeout_id != 0) {
 		g_source_remove(efh->priv->format_timeout_id);
 		efh->priv->format_timeout_id = 0;
-		mail_msg_free(efh->priv->format_timeout_msg);
+		mail_msg_unref(efh->priv->format_timeout_msg);
 		efh->priv->format_timeout_msg = NULL;
 	}
 
@@ -1205,7 +1205,7 @@ efh_builtin_init(EMFormatHTMLClass *efhc)
 
 /* Sigh, this is so we have a cancellable, async rendering thread */
 struct _format_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	EMFormatHTML *format;
 	EMFormat *format_source;
@@ -1215,14 +1215,15 @@ struct _format_msg {
 	CamelMimeMessage *message;
 };
 
-static char *efh_format_desc(struct _mail_msg *mm, int done)
+static gchar *
+efh_format_desc (struct _format_msg *m)
 {
 	return g_strdup(_("Formatting message"));
 }
 
-static void efh_format_do(struct _mail_msg *mm)
+static void
+efh_format_exec (struct _format_msg *m)
 {
-	struct _format_msg *m = (struct _format_msg *)mm;
 	struct _EMFormatHTMLJob *job;
 	struct _EMFormatPURITree *puri_level;
 	int cancelled = FALSE;
@@ -1307,10 +1308,9 @@ static void efh_format_do(struct _mail_msg *mm)
 	((EMFormat *)m->format)->pending_uri_level = puri_level;
 }
 
-static void efh_format_done(struct _mail_msg *mm)
+static void
+efh_format_done (struct _format_msg *m)
 {
-	struct _format_msg *m = (struct _format_msg *)mm;
-
 	d(printf("formatting finished\n"));
 
 	m->format->load_http_now = FALSE;
@@ -1318,10 +1318,9 @@ static void efh_format_done(struct _mail_msg *mm)
 	g_signal_emit_by_name(m->format, "complete");
 }
 
-static void efh_format_free(struct _mail_msg *mm)
+static void
+efh_format_free (struct _format_msg *m)
 {
-	struct _format_msg *m = (struct _format_msg *)mm;
-
 	d(printf("formatter freed\n"));
 	g_object_unref(m->format);
 	if (m->estream) {
@@ -1337,11 +1336,12 @@ static void efh_format_free(struct _mail_msg *mm)
 		g_object_unref(m->format_source);
 }
 
-static struct _mail_msg_op efh_format_op = {
-	efh_format_desc,
-	efh_format_do,
-	efh_format_done,
-	efh_format_free,
+static MailMsgInfo efh_format_info = {
+	sizeof (struct _format_msg),
+	(MailMsgDescFunc) efh_format_desc,
+	(MailMsgExecFunc) efh_format_exec,
+	(MailMsgDoneFunc) efh_format_done,
+	(MailMsgFreeFunc) efh_format_free
 };
 
 static gboolean
@@ -1352,7 +1352,7 @@ efh_format_timeout(struct _format_msg *m)
 	struct _EMFormatHTMLPrivate *p = efh->priv;
 
 	if (m->format->html == NULL) {
-		mail_msg_free(m);
+		mail_msg_unref(m);
 		return FALSE;
 	}
 
@@ -1380,7 +1380,7 @@ efh_format_timeout(struct _format_msg *m)
 	if (m->message == NULL) {
 		hstream = gtk_html_begin(efh->html);
 		gtk_html_stream_close(hstream, GTK_HTML_STREAM_OK);
-		mail_msg_free(m);
+		mail_msg_unref(m);
 		p->last_part = NULL;
 	} else {
 		if (p->last_part != m->message) {
@@ -1403,8 +1403,8 @@ efh_format_timeout(struct _format_msg *m)
 			p->last_part = m->message;
 		}
 
-		efh->priv->format_id = m->msg.seq;
-		e_thread_put(mail_thread_new, (EMsg *)m);
+		efh->priv->format_id = m->base.seq;
+		mail_msg_unordered_push (m);
 	}
 
 	efh->priv->format_timeout_id = 0;
@@ -1428,11 +1428,11 @@ static void efh_format_clone(EMFormat *emf, CamelFolder *folder, const char *uid
 		d(printf(" timeout for last still active, removing ...\n"));
 		g_source_remove(efh->priv->format_timeout_id);
 		efh->priv->format_timeout_id = 0;
-		mail_msg_free(efh->priv->format_timeout_msg);
+		mail_msg_unref(efh->priv->format_timeout_msg);
 		efh->priv->format_timeout_msg = NULL;
 	}
 
-	m = mail_msg_new(&efh_format_op, NULL, sizeof(*m));
+	m = mail_msg_new(&efh_format_info);
 	m->format = (EMFormatHTML *)emf;
 	g_object_ref(emf);
 	m->format_source = emfsource;
diff --git a/mail/em-subscribe-editor.c b/mail/em-subscribe-editor.c
index 28fc79bfde..60e0a921b0 100644
--- a/mail/em-subscribe-editor.c
+++ b/mail/em-subscribe-editor.c
@@ -173,7 +173,7 @@ sub_unref(EMSubscribe *sub)
 /* ** Subscribe folder operation **************************************** */
 
 struct _zsubscribe_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	EMSubscribe *sub;
 	EMSubscribeNode *node;
@@ -182,20 +182,18 @@ struct _zsubscribe_msg {
 };
 
 static void
-sub_folder_subscribe (struct _mail_msg *mm)
+sub_folder_exec (struct _zsubscribe_msg *m)
 {
-	struct _zsubscribe_msg *m = (struct _zsubscribe_msg *) mm;
-
 	if (m->subscribe)
-		camel_store_subscribe_folder (m->sub->store, m->node->info->full_name, &mm->ex);
+		camel_store_subscribe_folder (m->sub->store, m->node->info->full_name, &m->base.ex);
 	else
-		camel_store_unsubscribe_folder (m->sub->store, m->node->info->full_name, &mm->ex);
+		camel_store_unsubscribe_folder (m->sub->store, m->node->info->full_name, &m->base.ex);
 }
 
 static void
-sub_folder_subscribed (struct _mail_msg *mm)
+sub_folder_done (struct _zsubscribe_msg *m)
 {
-	struct _zsubscribe_msg *m = (struct _zsubscribe_msg *)mm, *next;
+	struct _zsubscribe_msg *next;
 	GtkTreeIter iter;
 	GtkTreeModel *model;
 	EMSubscribeNode *node;
@@ -205,7 +203,7 @@ sub_folder_subscribed (struct _mail_msg *mm)
 	if (m->sub->cancel)
 		return;
 
-	if (!camel_exception_is_set(&mm->ex)) {
+	if (!camel_exception_is_set(&m->base.ex)) {
 		if (m->subscribe)
 			m->node->info->flags |= CAMEL_FOLDER_SUBSCRIBED;
 		else
@@ -226,8 +224,8 @@ sub_folder_subscribed (struct _mail_msg *mm)
 	/* queue any further ones, or if out, update the ui */
 	next = (struct _zsubscribe_msg *)e_dlist_remhead(&m->sub->subscribe);
 	if (next) {
-		next->sub->subscribe_id = next->msg.seq;
-		e_thread_put(mail_thread_new, (EMsg *)next);
+		next->sub->subscribe_id = next->base.seq;
+		mail_msg_unordered_push (next);
 	} else {
 		/* should it go off the model instead? */
 		sub_selection_changed(gtk_tree_view_get_selection(m->sub->tree), m->sub);
@@ -235,19 +233,18 @@ sub_folder_subscribed (struct _mail_msg *mm)
 }
 
 static void
-sub_folder_free (struct _mail_msg *mm)
+sub_folder_free (struct _zsubscribe_msg *m)
 {
-	struct _zsubscribe_msg *m = (struct _zsubscribe_msg *) mm;
-
 	g_free(m->path);
 	sub_unref(m->sub);
 }
 
-static struct _mail_msg_op sub_subscribe_folder_op = {
-	NULL, /*subscribe_folder_desc,*/
-	sub_folder_subscribe,
-	sub_folder_subscribed,
-	sub_folder_free,
+static MailMsgInfo sub_subscribe_folder_info = {
+	sizeof (struct _zsubscribe_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) sub_folder_exec,
+	(MailMsgDoneFunc) sub_folder_done,
+	(MailMsgFreeFunc) sub_folder_free
 };
 
 /* spath is tree path in string form */
@@ -257,18 +254,18 @@ sub_subscribe_folder (EMSubscribe *sub, EMSubscribeNode *node, int state, const
 	struct _zsubscribe_msg *m;
 	int id;
 
-	m = mail_msg_new (&sub_subscribe_folder_op, NULL, sizeof(*m));
+	m = mail_msg_new (&sub_subscribe_folder_info);
 	m->sub = sub;
 	sub_ref(sub);
 	m->node = node;
 	m->subscribe = state;
 	m->path = g_strdup(spath);
 
-	id = m->msg.seq;
+	id = m->base.seq;
 	if (sub->subscribe_id == -1) {
 		sub->subscribe_id = id;
 		d(printf("running subscribe folder '%s'\n", spath));
-		e_thread_put (mail_thread_new, (EMsg *)m);
+		mail_msg_unordered_push (m);
 	} else {
 		d(printf("queueing subscribe folder '%s'\n", spath));
 		e_dlist_addtail(&sub->subscribe, (EDListNode *)m);
@@ -339,7 +336,7 @@ sub_fill_level(EMSubscribe *sub, CamelFolderInfo *info,  GtkTreeIter *parent, in
 /* async query of folderinfo */
 
 struct _emse_folderinfo_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	int seq;
 
@@ -349,31 +346,29 @@ struct _emse_folderinfo_msg {
 };
 
 static void
-sub_folderinfo_get (struct _mail_msg *mm)
+sub_folderinfo_exec (struct _emse_folderinfo_msg *m)
 {
-	struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
 	char *pub_full_name=NULL;
 
 	if (m->seq == m->sub->seq) {
-		camel_operation_register(mm->cancel);
-		m->info = camel_store_get_folder_info(m->sub->store, m->node?m->node->info->full_name:pub_full_name, CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, &mm->ex);
-		camel_operation_unregister(mm->cancel);
+		camel_operation_register(m->base.cancel);
+		m->info = camel_store_get_folder_info(m->sub->store, m->node?m->node->info->full_name:pub_full_name, CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, &m->base.ex);
+		camel_operation_unregister(m->base.cancel);
 	}
 }
 
 static void
-sub_folderinfo_got(struct _mail_msg *mm)
+sub_folderinfo_done (struct _emse_folderinfo_msg *m)
 {
-	struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
 	EMSubscribeNode *node;
 
 	m->sub->pending_id = -1;
 	if (m->sub->cancel || m->seq != m->sub->seq)
 		return;
 
-	if (camel_exception_is_set (&mm->ex)) {
+	if (camel_exception_is_set (&m->base.ex)) {
 		g_warning ("Error getting folder info from store: %s",
-			   camel_exception_get_description (&mm->ex));
+			   camel_exception_get_description (&m->base.ex));
 	}
 
 	if (m->info) {
@@ -394,10 +389,8 @@ sub_folderinfo_got(struct _mail_msg *mm)
 }
 
 static void
-sub_folderinfo_free(struct _mail_msg *mm)
+sub_folderinfo_free (struct _emse_folderinfo_msg *m)
 {
-	struct _emse_folderinfo_msg *m = (struct _emse_folderinfo_msg *) mm;
-
 	if (m->info)
 		m->sub->info_list = g_slist_prepend(m->sub->info_list, m->info);
 
@@ -413,11 +406,12 @@ sub_folderinfo_free(struct _mail_msg *mm)
 	sub_unref(m->sub);
 }
 
-static struct _mail_msg_op sub_folderinfo_op = {
-	NULL, /*sub_folderinfo_desc,  we do our own progress reporting/cancellation */
-	sub_folderinfo_get,
-	sub_folderinfo_got,
-	sub_folderinfo_free,
+static MailMsgInfo sub_folderinfo_info = {
+	sizeof (struct _emse_folderinfo_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) sub_folderinfo_exec,
+	(MailMsgDoneFunc) sub_folderinfo_done,
+	(MailMsgFreeFunc) sub_folderinfo_free
 };
 
 static int
@@ -429,19 +423,19 @@ sub_queue_fill_level(EMSubscribe *sub, EMSubscribeNode *node)
 	d(printf("%s:%d:%s: Starting get folderinfo of '%s'\n", __FILE__, __LINE__, __GNUC_PRETTY_FUNCTION__,
 		 node?node->info->full_name:"<root>"));
 
-	m = mail_msg_new (&sub_folderinfo_op, NULL, sizeof(*m));
+	m = mail_msg_new (&sub_folderinfo_info);
 	sub_ref(sub);
 	m->sub = sub;
 	m->node = node;
 	m->seq = sub->seq;
 
-	sub->pending_id = m->msg.seq;
+	sub->pending_id = m->base.seq;
 
 	sub_editor_busy(sub->editor, 1);
 
-	id = m->msg.seq;
+	id = m->base.seq;
 
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 	return id;
 }
 
@@ -571,7 +565,7 @@ sub_destroy(GtkWidget *w, EMSubscribe *sub)
 		mail_msg_cancel(sub->subscribe_id);
 
 	while ( (m = (struct _zsubscribe_msg *)e_dlist_remhead(&sub->subscribe)) )
-		mail_msg_free(m);
+		mail_msg_unref(m);
 
 	sub_unref(sub);
 }
diff --git a/mail/em-sync-stream.c b/mail/em-sync-stream.c
index 1224e468bd..afa8bef8ea 100644
--- a/mail/em-sync-stream.c
+++ b/mail/em-sync-stream.c
@@ -25,42 +25,17 @@
 #include <config.h>
 #endif
 
-#include <string.h>
+#include "em-sync-stream.h"
+
 #include <stdio.h>
-#include <camel/camel-stream.h>
+#include <string.h>
 #include <camel/camel-object.h>
-#include <gtk/gtkmain.h>
-#include "em-sync-stream.h"
+#include <libedataserver/e-flag.h>
 
 #include "mail-mt.h"
 
-#define LOG_STREAM
-
-#define d(x)
-
 #define EMSS_CLASS(x) ((EMSyncStreamClass *)(((CamelObject *)(x))->klass))
 
-struct _EMSyncStreamPrivate {
-	/* FIXME: use a single data port/gui channel for all instances */
-	/* TODO: possibly just use one of the mail-mt ports ... */
-	struct _EMsgPort *data_port, *reply_port;
-	struct _GIOChannel *gui_channel;
-	guint gui_watch;
-
-	char *buf_data;
-	int buf_used;
-	int buf_size;
-
-#ifdef LOG_STREAM
-	FILE *logfd;
-#endif
-};
-
-#ifdef LOG_STREAM
-static int dolog;
-#endif
-
-/* Should probably expose messages to outside world ... so subclasses can extend */
 enum _write_msg_t {
 	EMSS_WRITE,
 	EMSS_FLUSH,
@@ -68,275 +43,168 @@ enum _write_msg_t {
 };
 
 struct _write_msg {
-	EMsg msg;
+	EMSyncStream *emss;
+	EFlag *done;
 
 	enum _write_msg_t op;
 
-	const char *data;
-	size_t n;
+	const gchar *string;
+	gsize len;
 };
 
-static void em_sync_stream_class_init (EMSyncStreamClass *klass);
-static void em_sync_stream_init (CamelObject *object);
-static void em_sync_stream_finalize (CamelObject *object);
-
-static ssize_t stream_write(CamelStream *stream, const char *buffer, size_t n);
-static int stream_close(CamelStream *stream);
-static int stream_flush(CamelStream *stream);
-
 static CamelStreamClass *parent_class = NULL;
 
-CamelType
-em_sync_stream_get_type (void)
-{
-	static CamelType type = CAMEL_INVALID_TYPE;
-
-	if (type == CAMEL_INVALID_TYPE) {
-#ifdef LOG_STREAM
-		dolog = getenv("EVOLUTION_MAIL_LOG_HTML") != NULL;
-#endif
-		type = camel_type_register (CAMEL_STREAM_TYPE,
-					    "EMSyncStream",
-					    sizeof (EMSyncStream),
-					    sizeof (EMSyncStreamClass),
-					    (CamelObjectClassInitFunc) em_sync_stream_class_init,
-					    NULL,
-					    (CamelObjectInitFunc) em_sync_stream_init,
-					    (CamelObjectFinalizeFunc) em_sync_stream_finalize);
-	}
-
-	return type;
-}
-
-static void
-em_sync_stream_class_init (EMSyncStreamClass *klass)
-{
-	CamelStreamClass *stream_class = CAMEL_STREAM_CLASS (klass);
-
-	parent_class = (CamelStreamClass *) CAMEL_STREAM_TYPE;
-
-	/* virtual method overload */
-	stream_class->write = stream_write;
-	stream_class->flush = stream_flush;
-	stream_class->close = stream_close;
-}
-
 static gboolean
-emcs_gui_received(GIOChannel *source, GIOCondition cond, void *data)
+emss_process_message (struct _write_msg *msg)
 {
-	EMSyncStream *emss = data;
-	struct _EMSyncStreamPrivate *p = emss->priv;
-	struct _write_msg *msg;
-
-	d(printf("%p: gui sync op job waiting\n", emss));
-
-	msg = (struct _write_msg *)e_msgport_get(p->data_port);
-	/* Should never happen ... */
-	if (msg == NULL)
-		return TRUE;
-
-	d(printf("%p: running sync op %d\n", emss, msg->op));
-
-	/* force out any pending data before doing anything else */
-	if (p->buf_used > 0) {
-		EMSS_CLASS(emss)->sync_write((CamelStream *)emss, p->buf_data, p->buf_used);
-#ifdef LOG_STREAM
-		if (p->logfd)
-			fwrite(p->buf_data, 1, p->buf_used, p->logfd);
-#endif
-		p->buf_used = 0;
+	struct _EMSyncStream *emss = msg->emss;
+
+	/* Force out any pending data before doing anything else. */
+	if (emss->buffer != NULL && emss->buffer->len > 0) {
+		EMSS_CLASS (emss)->sync_write (
+			CAMEL_STREAM (emss), emss->buffer->str,
+			emss->buffer->len);
+		g_string_set_size (emss->buffer, 0);
 	}
 
-	/* FIXME: need to handle return values */
-
 	switch (msg->op) {
-	case EMSS_WRITE:
-		EMSS_CLASS(emss)->sync_write((CamelStream *)emss, msg->data, msg->n);
-#ifdef LOG_STREAM
-		if (p->logfd)
-			fwrite(msg->data, 1, msg->n, p->logfd);
-#endif
-		break;
-	case EMSS_FLUSH:
-		EMSS_CLASS(emss)->sync_flush((CamelStream *)emss);
-		break;
-	case EMSS_CLOSE:
-		EMSS_CLASS(emss)->sync_close((CamelStream *)emss);
-#ifdef LOG_STREAM
-		if (p->logfd) {
-			fclose(p->logfd);
-			p->logfd = NULL;
-		}
-#endif
-		break;
+		case EMSS_WRITE:
+			EMSS_CLASS (emss)->sync_write (
+				CAMEL_STREAM (emss), msg->string, msg->len);
+			break;
+		case EMSS_FLUSH:
+			EMSS_CLASS (emss)->sync_flush (
+				CAMEL_STREAM (emss));
+			break;
+		case EMSS_CLOSE:
+			EMSS_CLASS (emss)->sync_close (
+				CAMEL_STREAM (emss));
+			break;
 	}
 
-	e_msgport_reply((EMsg *)msg);
-	d(printf("%p: gui sync op jobs done\n", emss));
+	e_flag_set (msg->done);
 
-	return TRUE;
+	return FALSE;
 }
 
 static void
-em_sync_stream_init (CamelObject *object)
+emss_sync_op (EMSyncStream *emss, enum _write_msg_t op,
+	      const gchar *string, gsize len)
 {
-	EMSyncStream *emss = (EMSyncStream *)object;
-	struct _EMSyncStreamPrivate *p;
-
-	p = emss->priv = g_malloc0(sizeof(*p));
-
-	p->data_port = e_msgport_new();
-	p->reply_port = e_msgport_new();
-
-#ifndef G_OS_WIN32
-	p->gui_channel = g_io_channel_unix_new(e_msgport_fd(p->data_port));
-#else
-	p->gui_channel = g_io_channel_win32_new_socket(e_msgport_fd(p->data_port));
-#endif
-	p->gui_watch = g_io_add_watch(p->gui_channel, G_IO_IN, emcs_gui_received, emss);
-
-#ifdef LOG_STREAM
-	if (dolog) {
-		char name[32];
-		static int count;
-
-		sprintf(name, "sync-stream.%d.html", count++);
-		printf("Saving raw data stream to '%s'\n", name);
-		p->logfd = fopen(name, "w");
-	}
-#endif
-
-	d(printf("%p: new emss\n", emss));
-}
-
-static void
-sync_op(EMSyncStream *emss, enum _write_msg_t op, const char *data, size_t n)
-{
-	struct _EMSyncStreamPrivate *p = emss->priv;
 	struct _write_msg msg;
-	EMsg *reply_msg;
-
-	d(printf("%p: launching sync op %d\n", emss, op));
 
-	/* we do everything synchronous, we should never have any locks, and
-	   this prevents overflow from banked up data */
-
-	msg.msg.reply_port = p->reply_port;
+	msg.done = e_flag_new ();
+	msg.emss = emss;
 	msg.op = op;
-	msg.data = data;
-	msg.n = n;
+	msg.string = string;
+	msg.len = len;
 
-	e_msgport_put(p->data_port, &msg.msg);
-	reply_msg = e_msgport_wait(p->reply_port);
-	g_return_if_fail (reply_msg == &msg.msg);
+	camel_object_ref (emss);
 
-	d(printf("%p: returned sync op %d\n", emss, op));
-}
+	g_idle_add ((GSourceFunc) emss_process_message, &msg);
 
-static void
-em_sync_stream_finalize (CamelObject *object)
-{
-	EMSyncStream *emss = (EMSyncStream *)object;
-	struct _EMSyncStreamPrivate *p = emss->priv;
-
-	/* TODO: is this stuff safe to do in another thread? */
-	g_source_remove(p->gui_watch);
-	g_io_channel_unref(p->gui_channel);
-
-	e_msgport_destroy(p->data_port);
-	e_msgport_destroy(p->reply_port);
+	e_flag_wait (msg.done);
+	e_flag_free (msg.done);
 
-	p->data_port = NULL;
-	p->reply_port = NULL;
-
-	g_free(p->buf_data);
-
-#ifdef LOG_STREAM
-	if (p->logfd)
-		fclose(p->logfd);
-#endif
-
-	g_free(p);
+	camel_object_unref (emss);
 }
 
-static ssize_t
-stream_write (CamelStream *stream, const char *buffer, size_t n)
+static gssize
+emss_stream_write (CamelStream *stream, const gchar *string, gsize len)
 {
 	EMSyncStream *emss = EM_SYNC_STREAM (stream);
-	struct _EMSyncStreamPrivate *p = emss->priv;
 
 	if (emss->cancel)
 		return -1;
 
-	if (pthread_equal(pthread_self(), mail_gui_thread)) {
-		EMSS_CLASS(emss)->sync_write(stream, buffer, n);
-#ifdef LOG_STREAM
-		if (p->logfd)
-			fwrite(buffer, 1, n, p->logfd);
-#endif
-	} else if (p->buf_size > 0) {
-		size_t left = p->buf_size-p->buf_used;
-
-		if (n >= left) {
-			sync_op(emss, EMSS_WRITE, buffer, n);
-		} else {
-			memcpy(p->buf_data + p->buf_used, buffer, n);
-			p->buf_used += n;
-		}
+	if (mail_in_main_thread ()) {
+		EMSS_CLASS (emss)->sync_write (stream, string, len);
+	} else if (emss->buffer != NULL) {
+		if (len < (emss->buffer->allocated_len - emss->buffer->len))
+			g_string_append_len (emss->buffer, string, len);
+		else
+			emss_sync_op (emss, EMSS_WRITE, string, len);
 	} else {
-		sync_op(emss, EMSS_WRITE, buffer, n);
+		emss_sync_op(emss, EMSS_WRITE, string, len);
 	}
 
-	return (ssize_t) n;
+	return (gssize) len;
 }
 
 static int
-stream_flush(CamelStream *stream)
+emss_stream_flush (CamelStream *stream)
 {
-	EMSyncStream *emss = (EMSyncStream *)stream;
+	EMSyncStream *emss = EM_SYNC_STREAM (stream);
 
 	if (emss->cancel)
 		return -1;
 
-	if (pthread_equal(pthread_self(), mail_gui_thread))
-		return ((EMSyncStreamClass *)(((CamelObject *)emss)->klass))->sync_flush(stream);
+	if (mail_in_main_thread ())
+		return EMSS_CLASS (emss)->sync_flush (stream);
 	else
-		sync_op(emss, EMSS_FLUSH, NULL, 0);
+		emss_sync_op (emss, EMSS_FLUSH, NULL, 0);
 
 	return 0;
 }
 
 static int
-stream_close(CamelStream *stream)
+emss_stream_close (CamelStream *stream)
 {
-	EMSyncStream *emss = (EMSyncStream *)stream;
+	EMSyncStream *emss = EM_SYNC_STREAM (stream);
 
 	if (emss->cancel)
 		return -1;
 
-	d(printf("%p: closing stream\n", stream));
-
-	if (pthread_equal(pthread_self(), mail_gui_thread)) {
-#ifdef LOG_STREAM
-		if (emss->priv->logfd) {
-			fclose(emss->priv->logfd);
-			emss->priv->logfd = NULL;
-		}
-#endif
-		return ((EMSyncStreamClass *)(((CamelObject *)emss)->klass))->sync_close(stream);
-	} else
-		sync_op(emss, EMSS_CLOSE, NULL, 0);
+	if (mail_in_main_thread ())
+		return EMSS_CLASS (emss)->sync_close (stream);
+	else
+		emss_sync_op (emss, EMSS_CLOSE, NULL, 0);
 
 	return 0;
 }
 
-void
-em_sync_stream_set_buffer_size(EMSyncStream *emss, size_t size)
+static void
+em_sync_stream_class_init (EMSyncStreamClass *class)
+{
+	CamelStreamClass *stream_class = CAMEL_STREAM_CLASS (class);
+
+	parent_class = (CamelStreamClass *) CAMEL_STREAM_TYPE;
+
+	stream_class->write = emss_stream_write;
+	stream_class->flush = emss_stream_flush;
+	stream_class->close = emss_stream_close;
+}
+
+static void
+em_sync_stream_finalize (EMSyncStream *emss)
 {
-	struct _EMSyncStreamPrivate *p = emss->priv;
+	if (emss->buffer != NULL)
+		g_string_free (emss->buffer, TRUE);
+}
 
-	g_free(p->buf_data);
-	p->buf_data = g_malloc(size);
-	p->buf_size = size;
-	p->buf_used = 0;
+CamelType
+em_sync_stream_get_type (void)
+{
+	static CamelType type = CAMEL_INVALID_TYPE;
+
+	if (G_UNLIKELY (type == CAMEL_INVALID_TYPE))
+		type = camel_type_register (
+			CAMEL_STREAM_TYPE,
+			"EMSyncStream",
+			sizeof (EMSyncStream),
+			sizeof (EMSyncStreamClass),
+			(CamelObjectClassInitFunc) em_sync_stream_class_init,
+			NULL,
+			(CamelObjectInitFunc) NULL,
+			(CamelObjectFinalizeFunc) em_sync_stream_finalize);
+
+	return type;
+}
+
+void
+em_sync_stream_set_buffer_size (EMSyncStream *emss, gsize size)
+{
+	if (emss->buffer != NULL)
+		g_string_free (emss->buffer, TRUE);
+	emss->buffer = g_string_sized_new (size);
 }
diff --git a/mail/em-sync-stream.h b/mail/em-sync-stream.h
index 0cb79a468d..4b1077e558 100644
--- a/mail/em-sync-stream.h
+++ b/mail/em-sync-stream.h
@@ -29,41 +29,45 @@ requests are always handled in the main gui thread in the correct order.
 #ifndef EM_SYNC_STREAM_H
 #define EM_SYNC_STREAM_H
 
-#ifdef __cplusplus
-extern "C" {
-#pragma }
-#endif /* __cplusplus */
-
-#define EM_SYNC_STREAM_TYPE     (em_sync_stream_get_type ())
-#define EM_SYNC_STREAM(obj)     (CAMEL_CHECK_CAST((obj), EM_SYNC_STREAM_TYPE, EMSyncStream))
-#define EM_SYNC_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), EM_SYNC_STREAM_TYPE, EMSyncStreamClass))
-#define EM_IS_SYNC_STREAM(o)    (CAMEL_CHECK_TYPE((o), EM_SYNC_STREAM_TYPE))
-
 #include <glib.h>
 #include <camel/camel-stream.h>
 
-typedef struct _EMSyncStream {
-	CamelStream parent_stream;
+#define EM_SYNC_STREAM_TYPE \
+	(em_sync_stream_get_type ())
+#define EM_SYNC_STREAM(obj) \
+	(CAMEL_CHECK_CAST \
+	((obj), EM_SYNC_STREAM_TYPE, EMSyncStream))
+#define EM_SYNC_STREAM_CLASS(cls) \
+	(CAMEL_CHECK_CLASS_CAST \
+	((cls), EM_SYNC_STREAM_TYPE, EMSyncStreamClass))
+#define EM_IS_SYNC_STREAM(obj) \
+	(CAMEL_CHECK_TYPE ((obj), EM_SYNC_STREAM_TYPE))
 
-	struct _EMSyncStreamPrivate *priv;
+G_BEGIN_DECLS
 
-	int cancel;
-} EMSyncStream;
+typedef struct _EMSyncStream EMSyncStream;
+typedef struct _EMSyncStreamClass EMSyncStreamClass;
 
-typedef struct {
-	CamelStreamClass parent_class;
+struct _EMSyncStream {
+	CamelStream parent;
+	GString *buffer;
+	gboolean cancel;
+};
 
-	ssize_t   (*sync_write)      (CamelStream *stream, const char *buffer, size_t n);
-	int       (*sync_close)      (CamelStream *stream);
-	int       (*sync_flush)      (CamelStream *stream);
+struct _EMSyncStreamClass {
+	CamelStreamClass parent_class;
 
-} EMSyncStreamClass;
+	gssize		(*sync_write)		(CamelStream *stream,
+						 const gchar *string,
+						 gsize len);
+	int		(*sync_close)		(CamelStream *stream);
+	int		(*sync_flush)		(CamelStream *stream);
+};
 
-CamelType    em_sync_stream_get_type (void);
-void em_sync_stream_set_buffer_size(EMSyncStream *, size_t size);
+CamelType	em_sync_stream_get_type		(void);
+void		em_sync_stream_set_buffer_size	(EMSyncStream *stream,
+						 gsize size);
 
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+G_END_DECLS
 
 #endif /* EM_SYNC_STREAM_H */
diff --git a/mail/em-utils.c b/mail/em-utils.c
index 5aa09faf67..552f7cc609 100644
--- a/mail/em-utils.c
+++ b/mail/em-utils.c
@@ -1990,7 +1990,7 @@ em_utils_in_addressbook(CamelInternetAddress *iaddr)
 		ESource *source = s->data;
 		GList *contacts;
 		EBook *book;
-		void *hook;
+		GHook *hook;
 
 		d(printf(" checking '%s'\n", e_source_get_uri(source)));
 
diff --git a/mail/importers/elm-importer.c b/mail/importers/elm-importer.c
index 1fafedc0a2..b65ffe420f 100644
--- a/mail/importers/elm-importer.c
+++ b/mail/importers/elm-importer.c
@@ -51,7 +51,7 @@
 #define d(x) x
 
 struct _elm_import_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	EImport *import;
 	EImportTargetHome *target;
@@ -178,8 +178,8 @@ elm_supported(EImport *ei, EImportTarget *target, EImportImporter *im)
 	return mailexists;
 }
 
-static char *
-elm_import_describe (struct _mail_msg *mm, int complete)
+static gchar *
+elm_import_desc (struct _elm_import_msg *m)
 {
 	return g_strdup (_("Importing Elm data"));
 }
@@ -190,9 +190,8 @@ static MailImporterSpecial elm_special_folders[] = {
 };
 
 static void
-elm_import_import(struct _mail_msg *mm)
+elm_import_exec (struct _elm_import_msg *m)
 {
-	struct _elm_import_msg *m = (struct _elm_import_msg *) mm;
 	const char *maildir;
 	char *elmdir;
 
@@ -210,13 +209,11 @@ elm_import_import(struct _mail_msg *mm)
 }
 
 static void
-elm_import_imported(struct _mail_msg *mm)
+elm_import_done(struct _elm_import_msg *m)
 {
-	struct _elm_import_msg *m = (struct _elm_import_msg *)mm;
-
 	printf("importing complete\n");
 
-	if (!camel_exception_is_set(&mm->ex)) {
+	if (!camel_exception_is_set(&m->base.ex)) {
 		GConfClient *gconf;
 
 		gconf = gconf_client_get_default();
@@ -228,10 +225,8 @@ elm_import_imported(struct _mail_msg *mm)
 }
 
 static void
-elm_import_free(struct _mail_msg *mm)
+elm_import_free(struct _elm_import_msg *m)
 {
-	struct _elm_import_msg *m = (struct _elm_import_msg *)mm;
-
 	camel_operation_unref(m->status);
 
 	g_free(m->status_what);
@@ -280,11 +275,12 @@ elm_status_timeout(void *data)
 	return TRUE;
 }
 
-static struct _mail_msg_op elm_import_op = {
-	elm_import_describe,
-	elm_import_import,
-	elm_import_imported,
-	elm_import_free,
+static MailMsgInfo elm_import_info = {
+	sizeof (struct _elm_import_msg),
+	(MailMsgDescFunc) elm_import_desc,
+	(MailMsgExecFunc) elm_import_exec,
+	(MailMsgDoneFunc) elm_import_done,
+	(MailMsgFreeFunc) elm_import_free
 };
 
 static int
@@ -293,7 +289,7 @@ mail_importer_elm_import(EImport *ei, EImportTarget *target)
 	struct _elm_import_msg *m;
 	int id;
 
-	m = mail_msg_new(&elm_import_op, NULL, sizeof (*m));
+	m = mail_msg_new(&elm_import_info);
 	g_datalist_set_data(&target->data, "elm-msg", m);
 	m->import = ei;
 	g_object_ref(m->import);
@@ -302,9 +298,9 @@ mail_importer_elm_import(EImport *ei, EImportTarget *target)
 	m->status_lock = g_mutex_new();
 	m->status = camel_operation_new(elm_status, m);
 
-	id = m->msg.seq;
+	id = m->base.seq;
 
-	e_thread_put(mail_thread_queued, (EMsg *)m);
+	mail_msg_fast_ordered_push (m);
 
 	return id;
 }
diff --git a/mail/importers/mail-importer.c b/mail/importers/mail-importer.c
index 5905080735..99241d8ddb 100644
--- a/mail/importers/mail-importer.c
+++ b/mail/importers/mail-importer.c
@@ -132,7 +132,7 @@ struct _BonoboObject *mail_importer_factory_cb(struct _BonoboGenericFactory *fac
 }
 
 struct _import_mbox_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	char *path;
 	char *uri;
@@ -142,8 +142,8 @@ struct _import_mbox_msg {
 	void *done_data;
 };
 
-static char *
-import_mbox_describe(struct _mail_msg *mm, int complete)
+static gchar *
+import_mbox_desc (struct _import_mbox_msg *m)
 {
 	return g_strdup (_("Importing mailbox"));
 }
@@ -190,9 +190,8 @@ decode_mozilla_status(const char *tmp)
 }
 
 static void
-import_mbox_import(struct _mail_msg *mm)
+import_mbox_exec (struct _import_mbox_msg *m)
 {
-	struct _import_mbox_msg *m = (struct _import_mbox_msg *) mm;
 	CamelFolder *folder;
 	CamelMimeParser *mp = NULL;
 	struct stat st;
@@ -207,7 +206,7 @@ import_mbox_import(struct _mail_msg *mm)
 	if (m->uri == NULL || m->uri[0] == 0)
 		folder = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_INBOX);
 	else
-		folder = mail_tool_uri_to_folder(m->uri, CAMEL_STORE_FOLDER_CREATE, &mm->ex);
+		folder = mail_tool_uri_to_folder(m->uri, CAMEL_STORE_FOLDER_CREATE, &m->base.ex);
 
 	if (folder == NULL)
 		return;
@@ -262,11 +261,11 @@ import_mbox_import(struct _mail_msg *mm)
 				flags |= decode_status(tmp);
 
 			camel_message_info_set_flags(info, flags, ~0);
-			camel_folder_append_message(folder, msg, info, NULL, &mm->ex);
+			camel_folder_append_message(folder, msg, info, NULL, &m->base.ex);
 			camel_message_info_free(info);
 			camel_object_unref(msg);
 
-			if (camel_exception_is_set(&mm->ex))
+			if (camel_exception_is_set(&m->base.ex))
 				break;
 
 			camel_mime_parser_step(mp, NULL, NULL);
@@ -286,30 +285,27 @@ fail1:
 }
 
 static void
-import_mbox_done(struct _mail_msg *mm)
+import_mbox_done (struct _import_mbox_msg *m)
 {
-	struct _import_mbox_msg *m = (struct _import_mbox_msg *)mm;
-
 	if (m->done)
-		m->done(m->done_data, &mm->ex);
+		m->done(m->done_data, &m->base.ex);
 }
 
 static void
-import_mbox_free (struct _mail_msg *mm)
+import_mbox_free (struct _import_mbox_msg *m)
 {
-	struct _import_mbox_msg *m = (struct _import_mbox_msg *)mm;
-
 	if (m->cancel)
 		camel_operation_unref(m->cancel);
 	g_free(m->uri);
 	g_free(m->path);
 }
 
-static struct _mail_msg_op import_mbox_op = {
-	import_mbox_describe,
-	import_mbox_import,
-	import_mbox_done,
-	import_mbox_free,
+static MailMsgInfo import_mbox_info = {
+	sizeof (struct _import_mbox_msg),
+	(MailMsgDescFunc) import_mbox_desc,
+	(MailMsgExecFunc) import_mbox_exec,
+	(MailMsgDoneFunc) import_mbox_done,
+	(MailMsgFreeFunc) import_mbox_free
 };
 
 int
@@ -318,7 +314,7 @@ mail_importer_import_mbox(const char *path, const char *folderuri, CamelOperatio
 	struct _import_mbox_msg *m;
 	int id;
 
-	m = mail_msg_new(&import_mbox_op, NULL, sizeof (*m));
+	m = mail_msg_new(&import_mbox_info);
 	m->path = g_strdup(path);
 	m->uri = g_strdup(folderuri);
 	m->done = done;
@@ -328,8 +324,8 @@ mail_importer_import_mbox(const char *path, const char *folderuri, CamelOperatio
 		camel_operation_ref(cancel);
 	}
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_queued, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_fast_ordered_push (m);
 
 	return id;
 }
@@ -339,7 +335,7 @@ mail_importer_import_mbox_sync(const char *path, const char *folderuri, CamelOpe
 {
 	struct _import_mbox_msg *m;
 
-	m = mail_msg_new(&import_mbox_op, NULL, sizeof (*m));
+	m = mail_msg_new(&import_mbox_info);
 	m->path = g_strdup(path);
 	m->uri = g_strdup(folderuri);
 	if (cancel) {
@@ -347,9 +343,9 @@ mail_importer_import_mbox_sync(const char *path, const char *folderuri, CamelOpe
 		camel_operation_ref(cancel);
 	}
 
-	import_mbox_import(&m->msg);
-	import_mbox_done(&m->msg);
-	mail_msg_free(&m->msg);
+	import_mbox_exec(m);
+	import_mbox_done(m);
+	mail_msg_unref(m);
 }
 
 struct _import_folders_data {
diff --git a/mail/importers/pine-importer.c b/mail/importers/pine-importer.c
index 97f3349e66..afc7f7fb1c 100644
--- a/mail/importers/pine-importer.c
+++ b/mail/importers/pine-importer.c
@@ -56,7 +56,7 @@
 #define d(x) x
 
 struct _pine_import_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	EImport *import;
 	EImportTarget *target;
@@ -223,8 +223,8 @@ import_contacts(void)
 	g_object_unref(book);
 }
 
-static char *
-pine_import_describe (struct _mail_msg *mm, int complete)
+static gchar *
+pine_import_desc (struct _pine_import_msg *m)
 {
 	return g_strdup (_("Importing Pine data"));
 }
@@ -236,10 +236,8 @@ static MailImporterSpecial pine_special_folders[] = {
 };
 
 static void
-pine_import_import(struct _mail_msg *mm)
+pine_import_exec(struct _pine_import_msg *m)
 {
-	struct _pine_import_msg *m = (struct _pine_import_msg *) mm;
-
 	if (GPOINTER_TO_INT(g_datalist_get_data(&m->target->data, "pine-do-addr")))
 		import_contacts();
 
@@ -253,13 +251,11 @@ pine_import_import(struct _mail_msg *mm)
 }
 
 static void
-pine_import_imported(struct _mail_msg *mm)
+pine_import_done(struct _pine_import_msg *m)
 {
-	struct _pine_import_msg *m = (struct _pine_import_msg *)mm;
-
 	printf("importing complete\n");
 
-	if (!camel_exception_is_set(&mm->ex)) {
+	if (!camel_exception_is_set(&m->base.ex)) {
 		GConfClient *gconf;
 
 		gconf = gconf_client_get_default();
@@ -274,10 +270,8 @@ pine_import_imported(struct _mail_msg *mm)
 }
 
 static void
-pine_import_free(struct _mail_msg *mm)
+pine_import_free(struct _pine_import_msg *m)
 {
-	struct _pine_import_msg *m = (struct _pine_import_msg *)mm;
-
 	camel_operation_unref(m->status);
 
 	g_free(m->status_what);
@@ -326,11 +320,12 @@ pine_status_timeout(void *data)
 	return TRUE;
 }
 
-static struct _mail_msg_op pine_import_op = {
-	pine_import_describe,
-	pine_import_import,
-	pine_import_imported,
-	pine_import_free,
+static MailMsgInfo pine_import_info = {
+	sizeof (struct _pine_import_msg),
+	(MailMsgDescFunc) pine_import_desc,
+	(MailMsgExecFunc) pine_import_exec,
+	(MailMsgDoneFunc) pine_import_done,
+	(MailMsgFreeFunc) pine_import_free
 };
 
 static int
@@ -339,7 +334,7 @@ mail_importer_pine_import(EImport *ei, EImportTarget *target)
 	struct _pine_import_msg *m;
 	int id;
 
-	m = mail_msg_new(&pine_import_op, NULL, sizeof (*m));
+	m = mail_msg_new(&pine_import_info);
 	g_datalist_set_data(&target->data, "pine-msg", m);
 	m->import = ei;
 	g_object_ref(m->import);
@@ -348,9 +343,9 @@ mail_importer_pine_import(EImport *ei, EImportTarget *target)
 	m->status_lock = g_mutex_new();
 	m->status = camel_operation_new(pine_status, m);
 
-	id = m->msg.seq;
+	id = m->base.seq;
 
-	e_thread_put(mail_thread_queued, (EMsg *)m);
+	mail_msg_fast_ordered_push (m);
 
 	return id;
 }
diff --git a/mail/mail-component.c b/mail/mail-component.c
index b8ff1c2df9..e4e2cbb6c5 100644
--- a/mail/mail-component.c
+++ b/mail/mail-component.c
@@ -1010,7 +1010,7 @@ impl_handleURI (PortableServer_Servant servant, const char *uri, CORBA_Environme
 		if (camel_url_get_param(url, "uid") != NULL) {
 			char *curi = em_uri_to_camel(uri);
 
-			mail_get_folder(curi, 0, handleuri_got_folder, url, mail_thread_new);
+			mail_get_folder(curi, 0, handleuri_got_folder, url, mail_msg_unordered_push);
 			g_free(curi);
 		} else {
 			g_warning("email uri's must include a uid parameter");
diff --git a/mail/mail-folder-cache.c b/mail/mail-folder-cache.c
index 8d9b7a2fc9..5bd4bf5cf6 100644
--- a/mail/mail-folder-cache.c
+++ b/mail/mail-folder-cache.c
@@ -808,15 +808,14 @@ update_folders(CamelStore *store, CamelFolderInfo *fi, void *data)
 
 
 struct _ping_store_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelStore *store;
 };
 
-static char *
-ping_store_desc (struct _mail_msg *mm, int done)
+static gchar *
+ping_store_desc (struct _ping_store_msg *m)
 {
-	struct _ping_store_msg *m = (struct _ping_store_msg *) mm;
 	char *service_name = camel_service_get_name (CAMEL_SERVICE (m->store), TRUE);
 	char *msg;
 
@@ -827,10 +826,9 @@ ping_store_desc (struct _mail_msg *mm, int done)
 }
 
 static void
-ping_store_ping (struct _mail_msg *mm)
+ping_store_exec (struct _ping_store_msg *m)
 {
 	gboolean online = FALSE;
-	struct _ping_store_msg *m = (struct _ping_store_msg *) mm;
 
 	if (CAMEL_SERVICE (m->store)->status == CAMEL_SERVICE_CONNECTED) {
 		if (CAMEL_IS_DISCO_STORE (m->store) &&
@@ -841,22 +839,21 @@ ping_store_ping (struct _mail_msg *mm)
 			online = TRUE;
 	}
 	if (online)
-		camel_store_noop (m->store, &mm->ex);
+		camel_store_noop (m->store, &m->base.ex);
 }
 
 static void
-ping_store_free (struct _mail_msg *mm)
+ping_store_free (struct _ping_store_msg *m)
 {
-	struct _ping_store_msg *m = (struct _ping_store_msg *) mm;
-
 	camel_object_unref (m->store);
 }
 
-static struct _mail_msg_op ping_store_op = {
-	ping_store_desc,
-	ping_store_ping,
-	NULL,
-	ping_store_free
+static MailMsgInfo ping_store_info = {
+	sizeof (struct _ping_store_msg),
+	(MailMsgDescFunc) ping_store_desc,
+	(MailMsgExecFunc) ping_store_exec,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) ping_store_free
 };
 
 static void
@@ -868,11 +865,11 @@ ping_store (gpointer key, gpointer val, gpointer user_data)
 	if (CAMEL_SERVICE (store)->status != CAMEL_SERVICE_CONNECTED)
 		return;
 
-	m = mail_msg_new (&ping_store_op, NULL, sizeof (struct _ping_store_msg));
+	m = mail_msg_new (&ping_store_info);
 	m->store = store;
 	camel_object_ref (store);
 
-	e_thread_put (mail_thread_queued_slow, (EMsg *) m);
+	mail_msg_slow_ordered_push (m);
 }
 
 static gboolean
@@ -917,7 +914,7 @@ mail_note_store(CamelStore *store, CamelOperation *op,
 	int hook = 0;
 
 	g_return_if_fail (CAMEL_IS_STORE(store));
-	g_return_if_fail (pthread_equal(pthread_self(), mail_gui_thread));
+	g_return_if_fail (mail_in_main_thread());
 
 	LOCK(info_lock);
 
diff --git a/mail/mail-mt.c b/mail/mail-mt.c
index 686836ea72..77ae1bfa54 100644
--- a/mail/mail-mt.c
+++ b/mail/mail-mt.c
@@ -29,8 +29,8 @@
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
 
-#include <libedataserver/e-msgport.h>
 #include <libedataserver/e-data-server-util.h>
+#include <libedataserver/e-flag.h>
 
 #include <camel/camel-url.h>
 #include <camel/camel-operation.h>
@@ -63,7 +63,7 @@ static void mail_operation_status(struct _CamelOperation *op, const char *what,
 #endif
 
 /* background operation status stuff */
-struct _mail_msg_priv {
+struct _MailMsgPrivate {
 	int activity_state;	/* sigh sigh sigh, we need to keep track of the state external to the
 				   pointer itself for locking/race conditions */
 	int activity_id;
@@ -84,20 +84,12 @@ static GHashTable *mail_msg_active_table; /* table of active messages, must hold
 static pthread_mutex_t mail_msg_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t mail_msg_cond = PTHREAD_COND_INITIALIZER;
 
-pthread_t mail_gui_thread;
-
 MailAsyncEvent *mail_async_event;
 
-static void mail_msg_destroy(EThread *e, EMsg *msg, void *data);
-
-void mail_msg_set_cancelable (struct _mail_msg *msg, gboolean status)
-{
-	msg->priv->cancelable = status;
-}
-
-void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size)
+gpointer
+mail_msg_new (MailMsgInfo *info)
 {
-	struct _mail_msg *msg;
+	MailMsg *msg;
 
 	MAIL_MT_LOCK(mail_msg_lock);
 
@@ -119,7 +111,6 @@ void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size)
 					fprintf(log, "Logging async operations\n");
 
 				if (log_locks) {
-					fprintf(log, "Logging lock operations, mail_gui_thread = %" G_GINT64_MODIFIER "x\n\n", e_util_pthread_id(mail_gui_thread));
 					fprintf(log, "%" G_GINT64_MODIFIER "x: lock mail_msg_lock\n", e_util_pthread_id(pthread_self()));
 				}
 			} else {
@@ -129,13 +120,13 @@ void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size)
 		}
 	}
 #endif
-	msg = g_malloc0(size);
-	msg->ops = ops;
+	msg = g_slice_alloc0 (info->size);
+	msg->info = info;
+	msg->ref_count = 1;
 	msg->seq = mail_msg_seq++;
-	msg->msg.reply_port = reply_port;
 	msg->cancel = camel_operation_new(mail_operation_status, GINT_TO_POINTER(msg->seq));
 	camel_exception_init(&msg->ex);
-	msg->priv = g_malloc0(sizeof(*msg->priv));
+	msg->priv = g_slice_new0 (MailMsgPrivate);
 	msg->priv->cancelable = TRUE;
 
 	g_hash_table_insert(mail_msg_active_table, GINT_TO_POINTER(msg->seq), msg);
@@ -151,18 +142,20 @@ void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size)
 	return msg;
 }
 
-
-static void end_event_callback (CamelObject *o, void *event_data, void *error)
+static void
+end_event_callback (CamelObject *o, void *event_data, void *error)
 {
-	EActivityHandler *activity_handler = mail_component_peek_activity_handler (mail_component_peek ());
+	MailComponent *component;
+	EActivityHandler *activity_handler;
 	guint activity_id = GPOINTER_TO_INT (event_data);
 
+	component = mail_component_peek ();
+	activity_handler = mail_component_peek_activity_handler (component);
 	if (!error) {
 		e_activity_handler_operation_finished (activity_handler, activity_id);
 	} else {
 		d(printf("Yahooooo, we got it nonintrusively\n"));
 		e_activity_handler_operation_set_error (activity_handler, activity_id, error);
-
 	}
 }
 
@@ -191,43 +184,81 @@ checkmem(void *p)
 }
 #endif
 
-void mail_msg_free(void *msg)
+static void
+mail_msg_free (MailMsg *mail_msg)
 {
-	struct _mail_msg *m = msg;
-	int activity_id;
+	if (mail_msg->cancel != NULL) {
+		camel_operation_mute (mail_msg->cancel);
+		camel_operation_unref (mail_msg->cancel);
+	}
+
+	camel_exception_clear (&mail_msg->ex);
+	g_slice_free (MailMsgPrivate, mail_msg->priv);
+	g_slice_free1 (mail_msg->info->size, mail_msg);
+}
+
+gpointer
+mail_msg_ref (gpointer msg)
+{
+	MailMsg *mail_msg = msg;
+
+	g_return_val_if_fail (mail_msg != NULL, msg);
+	g_return_val_if_fail (mail_msg->ref_count > 0, msg);
+
+	g_atomic_int_add (&mail_msg->ref_count, 1);
+	return msg;
+}
+
+void
+mail_msg_unref (gpointer msg)
+{
+	MailMsg *mail_msg = msg;
+	gint activity_id;
 	GtkWidget *error = NULL;
 
+	g_return_if_fail (mail_msg != NULL);
+	g_return_if_fail (mail_msg->ref_count > 0);
+
+	if (g_atomic_int_exchange_and_add (&mail_msg->ref_count, -1) > 1)
+		return;
+
 #ifdef MALLOC_CHECK
-	checkmem(m);
-	checkmem(m->cancel);
-	checkmem(m->priv);
+	checkmem(mail_msg);
+	checkmem(mail_msg->cancel);
+	checkmem(mail_msg->priv);
 #endif
 	d(printf("Free message %p\n", msg));
 
-	if (m->ops->destroy_msg)
-		m->ops->destroy_msg(m);
+	if (mail_msg->info->free)
+		mail_msg->info->free(mail_msg);
 
 	MAIL_MT_LOCK(mail_msg_lock);
 
 #ifdef LOG_OPS
-	if (log_ops)
-		fprintf(log, "%p: Free  (exception `%s')\n", msg,
-			camel_exception_get_description(&m->ex)?camel_exception_get_description(&m->ex):"None");
+	if (log_ops) {
+		const gchar *description;
+
+		description = camel_exception_get_description (&mail_msg->ex);
+		if (description == NULL)
+			description = "None";
+		fprintf(log, "%p: Free  (exception `%s')\n", msg, description);
+	}
 #endif
-	g_hash_table_remove(mail_msg_active_table, GINT_TO_POINTER(m->seq));
-	pthread_cond_broadcast(&mail_msg_cond);
+	g_hash_table_remove (
+		mail_msg_active_table, GINT_TO_POINTER (mail_msg->seq));
+	pthread_cond_broadcast (&mail_msg_cond);
 
 	/* We need to make sure we dont lose a reference here YUCK YUCK */
 	/* This is tightly integrated with the code in do_op_status,
 	   as it closely relates to the CamelOperation setup in msg_new() above */
-	if (m->priv->activity_state == 1) {
-		m->priv->activity_state = 3; /* tell the other thread
-					      * to free it itself (yuck yuck) */
+	if (mail_msg->priv->activity_state == 1) {
+		/* tell the other to free it itself */
+		mail_msg->priv->activity_state = 3;
 		MAIL_MT_UNLOCK(mail_msg_lock);
 		return;
 	} else {
-		activity_id = m->priv->activity_id;
-		error = m->priv->error;
+		activity_id = mail_msg->priv->activity_id;
+		error = mail_msg->priv->error;
 		if (error && !activity_id) {
 			e_activity_handler_make_error (mail_component_peek_activity_handler (mail_component_peek ()), "mail",
 							g_object_get_data ((GObject *) error, "primary"), error);
@@ -238,19 +269,13 @@ void mail_msg_free(void *msg)
 
 	MAIL_MT_UNLOCK(mail_msg_lock);
 
-	if (m->cancel) {
-		camel_operation_mute(m->cancel);
-		camel_operation_unref(m->cancel);
-	}
-
-	camel_exception_clear(&m->ex);
-	/*g_free(m->priv->what);*/
-	g_free(m->priv);
-	g_free(m);
+	mail_msg_free (mail_msg);
 
 	if (activity_id != 0)
-		mail_async_event_emit(mail_async_event, MAIL_ASYNC_GUI, (MailAsyncFunc) end_event_callback,
-				      NULL, GINT_TO_POINTER (activity_id), error);
+		mail_async_event_emit (
+			mail_async_event, MAIL_ASYNC_GUI,
+			(MailAsyncFunc) end_event_callback,
+			NULL, GINT_TO_POINTER (activity_id), error);
 }
 
 /* hash table of ops->dialogue of active errors */
@@ -266,9 +291,10 @@ static void error_response(GtkObject *o, int button, void *data)
 	gtk_widget_destroy((GtkWidget *)o);
 }
 
-void mail_msg_check_error(void *msg)
+void
+mail_msg_check_error (gpointer msg)
 {
-	struct _mail_msg *m = msg;
+	MailMsg *m = msg;
 	char *what;
 	GtkDialog *gd;
 
@@ -293,21 +319,21 @@ void mail_msg_check_error(void *msg)
 	/* check to see if we have dialogue already running for this operation */
 	/* we key on the operation pointer, which is at least accurate enough
 	   for the operation type, although it could be on a different object. */
-	if (g_hash_table_lookup(active_errors, m->ops)) {
+	if (g_hash_table_lookup(active_errors, m->info)) {
 		g_warning("Error occurred while existing dialogue active:\n%s", camel_exception_get_description(&m->ex));
 		return;
 	}
 
-	if (m->ops->describe_msg
-	    && (what = m->ops->describe_msg(m, FALSE))) {
+	if (m->info->desc
+	    && (what = m->info->desc (m))) {
 		gd = (GtkDialog *)e_error_new(NULL, "mail:async-error", what, camel_exception_get_description(&m->ex), NULL);
 		g_free(what);
 	} else
 		gd = (GtkDialog *)e_error_new(NULL, "mail:async-error-nodescribe", camel_exception_get_description(&m->ex), NULL);
 
-	g_hash_table_insert(active_errors, m->ops, gd);
-	g_signal_connect(gd, "response", G_CALLBACK(error_response), m->ops);
-	g_signal_connect(gd, "destroy", G_CALLBACK(error_destroy), m->ops);
+	g_hash_table_insert(active_errors, m->info, gd);
+	g_signal_connect(gd, "response", G_CALLBACK(error_response), m->info);
+	g_signal_connect(gd, "destroy", G_CALLBACK(error_destroy), m->info);
 	if (m->priv->cancelable)
 		m->priv->error = (GtkWidget *) gd;
 	else
@@ -316,7 +342,7 @@ void mail_msg_check_error(void *msg)
 
 void mail_msg_cancel(unsigned int msgid)
 {
-	struct _mail_msg *m;
+	MailMsg *m;
 
 	MAIL_MT_LOCK(mail_msg_lock);
 	m = g_hash_table_lookup(mail_msg_active_table, GINT_TO_POINTER(msgid));
@@ -329,13 +355,12 @@ void mail_msg_cancel(unsigned int msgid)
 
 
 /* waits for a message to be finished processing (freed)
-   the messageid is from struct _mail_msg->seq */
+   the messageid is from MailMsg->seq */
 void mail_msg_wait(unsigned int msgid)
 {
-	struct _mail_msg *m;
-	int ismain = pthread_equal(pthread_self(), mail_gui_thread);
+	MailMsg *m;
 
-	if (ismain) {
+	if (mail_in_main_thread ()) {
 		MAIL_MT_LOCK(mail_msg_lock);
 		m = g_hash_table_lookup(mail_msg_active_table, GINT_TO_POINTER(msgid));
 		while (m) {
@@ -372,9 +397,7 @@ int mail_msg_active(unsigned int msgid)
 
 void mail_msg_wait_all(void)
 {
-	int ismain = pthread_equal(pthread_self(), mail_gui_thread);
-
-	if (ismain) {
+	if (mail_in_main_thread ()) {
 		MAIL_MT_LOCK(mail_msg_lock);
 		while (g_hash_table_size(mail_msg_active_table) > 0) {
 			MAIL_MT_UNLOCK(mail_msg_lock);
@@ -392,294 +415,244 @@ void mail_msg_wait_all(void)
 }
 
 /* **************************************** */
-struct _cancel_hook_data {
-	struct _cancel_hook_data *next;
-	struct _cancel_hook_data *prev;
-
-	GDestroyNotify func;
-	void *data;
-};
 
-static EDList cancel_hook_list = E_DLIST_INITIALISER(cancel_hook_list);
+static GHookList cancel_hook_list;
 
-void *mail_cancel_hook_add(GDestroyNotify func, void *data)
+GHook *
+mail_cancel_hook_add (GHookFunc func, gpointer data)
 {
-	struct _cancel_hook_data *d;
+	GHook *hook;
 
-	d = g_malloc0(sizeof(*d));
-	d->func = func;
-	d->data = data;
+	MAIL_MT_LOCK (mail_msg_lock);
 
-	MAIL_MT_LOCK(mail_msg_lock);
-	e_dlist_addtail(&cancel_hook_list, (EDListNode *)d);
-	MAIL_MT_UNLOCK(mail_msg_lock);
+	if (!cancel_hook_list.is_setup)
+		g_hook_list_init (&cancel_hook_list, sizeof (GHook));
 
-	return (void *)d;
-}
+	hook = g_hook_alloc (&cancel_hook_list);
+	hook->func = func;
+	hook->data = data;
 
-void mail_cancel_hook_remove(void *handle)
-{
-	struct _cancel_hook_data *d = handle;
+	g_hook_append (&cancel_hook_list, hook);
 
-	MAIL_MT_LOCK(mail_msg_lock);
-	e_dlist_remove((EDListNode *)d);
-	MAIL_MT_UNLOCK(mail_msg_lock);
-	g_free(d);
+	MAIL_MT_UNLOCK (mail_msg_lock);
+
+	return hook;
 }
 
-void mail_cancel_all(void)
+void
+mail_cancel_hook_remove (GHook *hook)
 {
-	struct _cancel_hook_data *d, *n;
+	MAIL_MT_LOCK (mail_msg_lock);
 
-	camel_operation_cancel(NULL);
+	g_return_if_fail (cancel_hook_list.is_setup);
+	g_hook_destroy_link (&cancel_hook_list, hook);
 
-	/* I can ssee a deadlock coming on ... */
-	MAIL_MT_LOCK(mail_msg_lock);
-	d = (struct _cancel_hook_data *)cancel_hook_list.head;
-	n = d->next;
-	while (n) {
-		d->func(d->data);
-		d = n;
-		n = n->next;
-	}
-	MAIL_MT_UNLOCK(mail_msg_lock);
+	MAIL_MT_UNLOCK (mail_msg_lock);
 }
 
-EMsgPort		*mail_gui_port;
-static GIOChannel	*mail_gui_channel;
-static guint		 mail_gui_watch;
-
-/* TODO: Merge these, gui_port2 doesn't do any mail_msg processing on the request (replies, forwards, frees) */
-EMsgPort		*mail_gui_port2;
-static GIOChannel	*mail_gui_channel2;
-static guint		 mail_gui_watch2;
+void
+mail_cancel_all (void)
+{
+	camel_operation_cancel (NULL);
 
-EMsgPort		*mail_gui_reply_port;
-static GIOChannel	*mail_gui_reply_channel;
+	MAIL_MT_LOCK (mail_msg_lock);
 
-/* a couple of global threads available */
-#ifdef G_OS_WIN32
-#undef mail_thread_queued
-static
-#endif
-EThread *mail_thread_queued;	/* for operations that can (or should) be queued */
-EThread *mail_thread_queued_slow;	/* for operations that can (or should) be queued, but take a long time */
-EThread *mail_thread_new;	/* for operations that should run in a new thread each time */
+	if (cancel_hook_list.is_setup)
+		g_hook_list_invoke (&cancel_hook_list, FALSE);
 
-#ifdef G_OS_WIN32
-EThread *
-mail_win32_get_mail_thread_queued (void)
-{
-	return mail_thread_queued;
+	MAIL_MT_UNLOCK (mail_msg_lock);
 }
-#endif
 
-static gboolean
-mail_msgport_replied(GIOChannel *source, GIOCondition cond, void *d)
+void
+mail_msg_set_cancelable (gpointer msg, gboolean status)
 {
-	EMsgPort *port = (EMsgPort *)d;
-	mail_msg_t *m;
+	MailMsg *mail_msg = msg;
 
-	while (( m = (mail_msg_t *)e_msgport_get(port))) {
+	mail_msg->priv->cancelable = status;
+}
 
-#ifdef MALLOC_CHECK
-		checkmem(m);
-		checkmem(m->cancel);
-		checkmem(m->priv);
-#endif
+static guint idle_source_id = 0;
+G_LOCK_DEFINE_STATIC (idle_source_id);
+static GAsyncQueue *main_loop_queue = NULL;
+static GAsyncQueue *msg_reply_queue = NULL;
+static GThread *main_thread = NULL;
 
-#ifdef LOG_OPS
-		if (log_ops)
-			fprintf(log, "%p: Replied to GUI thread (exception `%s'\n", m,
-				camel_exception_get_description(&m->ex)?camel_exception_get_description(&m->ex):"None");
-#endif
+static gboolean
+mail_msg_idle_cb (void)
+{
+	MailMsg *msg;
+
+	g_return_val_if_fail (main_loop_queue != NULL, FALSE);
+	g_return_val_if_fail (msg_reply_queue != NULL, FALSE);
+
+	G_LOCK (idle_source_id);
+	idle_source_id = 0;
+	G_UNLOCK (idle_source_id);
+
+	/* check the main loop queue */
+	while ((msg = g_async_queue_try_pop (main_loop_queue)) != NULL) {
+		if (msg->info->exec != NULL)
+			msg->info->exec (msg);
+		if (msg->info->done != NULL)
+			msg->info->done (msg);
+		mail_msg_unref (msg);
+	}
 
-		if (m->ops->reply_msg)
-			m->ops->reply_msg(m);
-		mail_msg_check_error(m);
-		mail_msg_free(m);
+	/* check the reply queue */
+	while ((msg = g_async_queue_try_pop (msg_reply_queue)) != NULL) {
+		if (msg->info->done != NULL)
+			msg->info->done (msg);
+		mail_msg_check_error (msg);
+		mail_msg_unref (msg);
 	}
 
-	return TRUE;
+	return FALSE;
 }
 
-static gboolean
-mail_msgport_received(GIOChannel *source, GIOCondition cond, void *d)
+static void
+mail_msg_proxy (MailMsg *msg)
 {
-	EMsgPort *port = (EMsgPort *)d;
-	mail_msg_t *m;
-
-	while (( m = (mail_msg_t *)e_msgport_get(port))) {
-#ifdef MALLOC_CHECK
-		checkmem(m);
-		checkmem(m->cancel);
-		checkmem(m->priv);
-#endif
+	if (msg->info->desc != NULL) {
+		gchar *text = msg->info->desc (msg);
+		camel_operation_register (msg->cancel);
+		camel_operation_start (msg->cancel, "%s", text);
+		g_free (text);
+	}
 
-#ifdef LOG_OPS
-		if (log_ops)
-			fprintf(log, "%p: Received at GUI thread\n", m);
-#endif
+	if (msg->info->exec != NULL) {
+		mail_enable_stop ();
+		msg->info->exec (msg);
+		mail_disable_stop ();
+	}
 
-		if (m->ops->receive_msg)
-			m->ops->receive_msg(m);
-		if (m->msg.reply_port)
-			e_msgport_reply((EMsg *)m);
-		else {
-			if (m->ops->reply_msg)
-				m->ops->reply_msg(m);
-			mail_msg_free(m);
-		}
+	if (msg->info->desc != NULL) {
+		camel_operation_end (msg->cancel);
+		camel_operation_unregister (msg->cancel);
+		MAIL_MT_LOCK (mail_msg_lock);
+		camel_operation_unref (msg->cancel);
+		msg->cancel = NULL;
+		MAIL_MT_UNLOCK (mail_msg_lock);
 	}
 
-	return TRUE;
+	g_async_queue_push (msg_reply_queue, msg);
+
+	G_LOCK (idle_source_id);
+	if (idle_source_id == 0)
+		idle_source_id = g_idle_add (
+			(GSourceFunc) mail_msg_idle_cb, NULL);
+	G_UNLOCK (idle_source_id);
 }
 
-/* Test code, lighterwight, more configurable calls */
-static gboolean
-mail_msgport_received2(GIOChannel *source, GIOCondition cond, void *d)
+void
+mail_msg_cleanup (void)
 {
-	EMsgPort *port = (EMsgPort *)d;
-	mail_msg_t *m;
+	mail_msg_wait_all();
 
-	while (( m = (mail_msg_t *)e_msgport_get(port))) {
-#ifdef LOG_OPS
-		if (log_ops)
-			fprintf(log, "%p: Received at GUI2 thread\n", m);
-#endif
+	G_LOCK (idle_source_id);
+	if (idle_source_id != 0) {
+		GSource *source;
 
-		if (m->ops->receive_msg)
-			m->ops->receive_msg(m);
-		else
-			mail_msg_free(m);
+		/* Cancel the idle source. */
+		source = g_main_context_find_source_by_id (
+			g_main_context_default (), idle_source_id);
+		g_source_destroy (source);
+		idle_source_id = 0;
 	}
+	G_UNLOCK (idle_source_id);
 
-	return TRUE;
-}
+	g_async_queue_unref (main_loop_queue);
+	main_loop_queue = NULL;
 
+	g_async_queue_unref (msg_reply_queue);
+	msg_reply_queue = NULL;
+}
 
-static void
-mail_msg_destroy(EThread *e, EMsg *msg, void *data)
+void
+mail_msg_init (void)
 {
-	mail_msg_t *m = (mail_msg_t *)msg;
+	main_loop_queue = g_async_queue_new ();
+	msg_reply_queue = g_async_queue_new ();
 
-#ifdef MALLOC_CHECK
-	checkmem(m);
-	checkmem(m->cancel);
-	checkmem(m->priv);
-#endif
+	mail_msg_active_table = g_hash_table_new (NULL, NULL);
+	main_thread = g_thread_self ();
 
-	mail_msg_free(m);
+	mail_async_event = mail_async_event_new ();
 }
 
-static void
-mail_msg_received(EThread *e, EMsg *msg, void *data)
+static gint
+mail_msg_compare (const MailMsg *msg1, const MailMsg *msg2)
 {
-	mail_msg_t *m = (mail_msg_t *)msg;
+	gint priority1 = msg1->priority;
+	gint priority2 = msg2->priority;
 
-#ifdef MALLOC_CHECK
-	checkmem(m);
-	checkmem(m->cancel);
-	checkmem(m->priv);
-#endif
+	if (priority1 == priority2)
+		return 0;
 
-	if (m->ops->describe_msg) {
-		char *text = m->ops->describe_msg(m, FALSE);
+	return (priority1 < priority2) ? 1 : -1;
+}
 
-#ifdef LOG_OPS
-		if (log_ops)
-			fprintf(log, "%p: Received at thread %" G_GINT64_MODIFIER "x: '%s'\n", m, e_util_pthread_id(pthread_self()), text);
-#endif
+static gpointer
+create_thread_pool (gpointer data)
+{
+	GThreadPool *thread_pool;
+	gint max_threads = GPOINTER_TO_INT (data);
 
-		d(printf("message received at thread\n"));
-		camel_operation_register(m->cancel);
-		camel_operation_start(m->cancel, "%s", text);
-		g_free(text);
-	}
-#ifdef LOG_OPS
-	else
-		if (log_ops)
-			fprintf(log, "%p: Received at thread %" G_GINT64_MODIFIER "x\n", m, e_util_pthread_id(pthread_self()));
-#endif
+	/* once created, run forever */
+	thread_pool = g_thread_pool_new (
+		(GFunc) mail_msg_proxy, NULL, max_threads, FALSE, NULL);
+	g_thread_pool_set_sort_function (
+		thread_pool, (GCompareDataFunc) mail_msg_compare, NULL);
 
-	if (m->ops->receive_msg) {
-		mail_enable_stop();
-		m->ops->receive_msg(m);
-		mail_disable_stop();
-	}
+	return thread_pool;
+}
 
-	if (m->ops->describe_msg) {
-		camel_operation_end(m->cancel);
-		camel_operation_unregister(m->cancel);
-		MAIL_MT_LOCK(mail_msg_lock);
-		camel_operation_unref(m->cancel);
-		m->cancel = NULL;
-		MAIL_MT_UNLOCK(mail_msg_lock);
-	}
+void
+mail_msg_main_loop_push (gpointer msg)
+{
+	g_async_queue_push_sorted (main_loop_queue, msg,
+		(GCompareDataFunc) mail_msg_compare, NULL);
+
+	G_LOCK (idle_source_id);
+	if (idle_source_id == 0)
+		idle_source_id = g_idle_add (
+			(GSourceFunc) mail_msg_idle_cb, NULL);
+	G_UNLOCK (idle_source_id);
 }
 
-void mail_msg_cleanup(void)
+void
+mail_msg_unordered_push (gpointer msg)
 {
-	mail_msg_wait_all();
+	static GOnce once = G_ONCE_INIT;
+
+	g_once (&once, (GThreadFunc) create_thread_pool, GINT_TO_POINTER (10));
 
-	e_thread_destroy(mail_thread_queued_slow);
-	e_thread_destroy(mail_thread_queued);
-	e_thread_destroy(mail_thread_new);
+	g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
+}
+
+void
+mail_msg_fast_ordered_push (gpointer msg)
+{
+	static GOnce once = G_ONCE_INIT;
 
-	g_io_channel_unref(mail_gui_channel);
-	g_io_channel_unref(mail_gui_reply_channel);
+	g_once (&once, (GThreadFunc) create_thread_pool, GINT_TO_POINTER (1));
 
-	e_msgport_destroy(mail_gui_port);
-	e_msgport_destroy(mail_gui_reply_port);
+	g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
 }
 
-static guint
-em_channel_setup(EMsgPort **port, GIOChannel **channel, GIOFunc func)
+void
+mail_msg_slow_ordered_push (gpointer msg)
 {
-	GSource *source;
-	guint id;
+	static GOnce once = G_ONCE_INIT;
 
-	*port = e_msgport_new();
-#ifndef G_OS_WIN32
-	*channel = g_io_channel_unix_new(e_msgport_fd(*port));
-#else
-	*channel = g_io_channel_win32_new_socket(e_msgport_fd(*port));
-#endif
-	source = g_io_create_watch(*channel, G_IO_IN);
-	g_source_set_callback(source, (GSourceFunc)func, *port, NULL);
-	g_source_set_can_recurse(source, FALSE);
-	id = g_source_attach(source, NULL);
-	g_source_unref(source);
+	g_once (&once, (GThreadFunc) create_thread_pool, GINT_TO_POINTER (1));
 
-	return id;
+	g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);
 }
 
-void mail_msg_init(void)
+gboolean
+mail_in_main_thread (void)
 {
-	em_channel_setup(&mail_gui_reply_port, &mail_gui_reply_channel, mail_msgport_replied);
-	mail_gui_watch = em_channel_setup(&mail_gui_port, &mail_gui_channel, mail_msgport_received);
-	mail_gui_watch2 = em_channel_setup(&mail_gui_port2, &mail_gui_channel2, mail_msgport_received2);
-
-	mail_thread_queued = e_thread_new(E_THREAD_QUEUE);
-	e_thread_set_msg_destroy(mail_thread_queued, mail_msg_destroy, NULL);
-	e_thread_set_msg_received(mail_thread_queued, mail_msg_received, NULL);
-	e_thread_set_reply_port(mail_thread_queued, mail_gui_reply_port);
-
-	mail_thread_queued_slow = e_thread_new(E_THREAD_QUEUE);
-	e_thread_set_msg_destroy(mail_thread_queued_slow, mail_msg_destroy, NULL);
-	e_thread_set_msg_received(mail_thread_queued_slow, mail_msg_received, NULL);
-	e_thread_set_reply_port(mail_thread_queued_slow, mail_gui_reply_port);
-
-	mail_thread_new = e_thread_new(E_THREAD_NEW);
-	e_thread_set_msg_destroy(mail_thread_new, mail_msg_destroy, NULL);
-	e_thread_set_msg_received(mail_thread_new, mail_msg_received, NULL);
-	e_thread_set_reply_port(mail_thread_new, mail_gui_reply_port);
-	e_thread_set_queue_limit(mail_thread_new, 10);
-
-	mail_msg_active_table = g_hash_table_new(NULL, NULL);
-	mail_gui_thread = pthread_self();
-
-	mail_async_event = mail_async_event_new();
+	return (g_thread_self () == main_thread);
 }
 
 /* ********************************************************************** */
@@ -690,7 +663,8 @@ static pthread_mutex_t status_lock = PTHREAD_MUTEX_INITIALIZER;
 /* ********************************************************************** */
 
 struct _proxy_msg {
-	struct _mail_msg msg;
+	MailMsg base;
+
 	MailAsyncEvent *ea;
 	mail_async_event_t type;
 
@@ -704,10 +678,8 @@ struct _proxy_msg {
 };
 
 static void
-do_async_event(struct _mail_msg *mm)
+do_async_event(struct _proxy_msg *m)
 {
-	struct _proxy_msg *m = (struct _proxy_msg *)mm;
-
 	m->thread = pthread_self();
 	m->have_thread = TRUE;
 	m->func(m->o, m->event_data, m->data);
@@ -722,16 +694,17 @@ static int
 idle_async_event(void *mm)
 {
 	do_async_event(mm);
-	mail_msg_free(mm);
+	mail_msg_unref(mm);
 
 	return FALSE;
 }
 
-static struct _mail_msg_op async_event_op = {
-	NULL,
-	do_async_event,
-	NULL,
-	NULL,
+static MailMsgInfo async_event_info = {
+	sizeof (struct _proxy_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) do_async_event,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) NULL
 };
 
 MailAsyncEvent *mail_async_event_new(void)
@@ -748,10 +721,9 @@ int mail_async_event_emit(MailAsyncEvent *ea, mail_async_event_t type, MailAsync
 {
 	struct _proxy_msg *m;
 	int id;
-	int ismain = pthread_equal(pthread_self(), mail_gui_thread);
 
 	/* we dont have a reply port for this, we dont care when/if it gets executed, just queue it */
-	m = mail_msg_new(&async_event_op, NULL, sizeof(*m));
+	m = mail_msg_new(&async_event_info);
 	m->func = func;
 	m->o = o;
 	m->event_data = event_data;
@@ -760,7 +732,7 @@ int mail_async_event_emit(MailAsyncEvent *ea, mail_async_event_t type, MailAsync
 	m->type = type;
 	m->have_thread = FALSE;
 
-	id = m->msg.seq;
+	id = m->base.seq;
 	g_mutex_lock(ea->lock);
 	ea->tasks = g_slist_prepend(ea->tasks, m);
 	g_mutex_unlock(ea->lock);
@@ -768,12 +740,12 @@ int mail_async_event_emit(MailAsyncEvent *ea, mail_async_event_t type, MailAsync
 	/* We use an idle function instead of our own message port only because the
 	   gui message ports's notification buffer might overflow and deadlock us */
 	if (type == MAIL_ASYNC_GUI) {
-		if (ismain)
+		if (mail_in_main_thread ())
 			g_idle_add(idle_async_event, m);
 		else
-			e_msgport_put(mail_gui_port, (EMsg *)m);
+			mail_msg_main_loop_push(m);
 	} else
-		e_thread_put(mail_thread_queued, (EMsg *)m);
+		mail_msg_fast_ordered_push (m);
 
 	return id;
 }
@@ -787,7 +759,7 @@ int mail_async_event_destroy(MailAsyncEvent *ea)
 	g_mutex_lock(ea->lock);
 	while (ea->tasks) {
 		m = ea->tasks->data;
-		id = m->msg.seq;
+		id = m->base.seq;
 		if (m->have_thread && pthread_equal(m->thread, thread)) {
 			g_warning("Destroying async event from inside an event, returning EDEADLK");
 			g_mutex_unlock(ea->lock);
@@ -809,17 +781,18 @@ int mail_async_event_destroy(MailAsyncEvent *ea)
 /* ********************************************************************** */
 
 struct _call_msg {
-	struct _mail_msg msg;
+	MailMsg base;
+
 	mail_call_t type;
 	MailMainFunc func;
 	void *ret;
 	va_list ap;
+	EFlag *done;
 };
 
 static void
-do_call(struct _mail_msg *mm)
+do_call(struct _call_msg *m)
 {
-	struct _call_msg *m = (struct _call_msg *)mm;
 	void *p1, *p2, *p3, *p4, *p5;
 	int i1;
 	va_list ap;
@@ -867,45 +840,47 @@ do_call(struct _mail_msg *mm)
 		m->ret = m->func(p1, p2, i1, p3, p4, p5);
 		break;
 	}
+
+	if (m->done != NULL)
+		e_flag_set (m->done);
 }
 
-static struct _mail_msg_op mail_call_op = {
-	NULL,
-	do_call,
-	NULL,
-	NULL,
+static MailMsgInfo mail_call_info = {
+	sizeof (struct _call_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) do_call,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) NULL
 };
 
-void *mail_call_main(mail_call_t type, MailMainFunc func, ...)
+void *
+mail_call_main (mail_call_t type, MailMainFunc func, ...)
 {
 	struct _call_msg *m;
 	void *ret;
 	va_list ap;
-	EMsgPort *reply = NULL;
-	int ismain = pthread_equal(pthread_self(), mail_gui_thread);
 
 	va_start(ap, func);
 
-	if (!ismain)
-		reply = e_msgport_new();
-
-	m = mail_msg_new(&mail_call_op, reply, sizeof(*m));
+	m = mail_msg_new (&mail_call_info);
 	m->type = type;
 	m->func = func;
 	G_VA_COPY(m->ap, ap);
 
-	if (!ismain) {
-		e_msgport_put(mail_gui_port, (EMsg *)m);
-		e_msgport_wait(reply);
-		e_msgport_destroy(reply);
-	} else {
-		do_call(&m->msg);
+	if (mail_in_main_thread ())
+		do_call (m);
+	else {
+		mail_msg_ref (m);
+		m->done = e_flag_new ();
+		mail_msg_main_loop_push (m);
+		e_flag_wait (m->done);
+		e_flag_free (m->done);
 	}
 
 	va_end(ap);
 
 	ret = m->ret;
-	mail_msg_free(m);
+	mail_msg_unref (m);
 
 	return ret;
 }
@@ -914,40 +889,42 @@ void *mail_call_main(mail_call_t type, MailMainFunc func, ...)
 /* locked via status_lock */
 static int busy_state;
 
-static void do_set_busy(struct _mail_msg *mm)
+static void
+do_set_busy(MailMsg *mm)
 {
 	set_stop(busy_state > 0);
 }
 
-static struct _mail_msg_op set_busy_op = {
-	NULL,
-	do_set_busy,
-	NULL,
-	NULL,
+static MailMsgInfo set_busy_info = {
+	sizeof (MailMsg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) do_set_busy,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) NULL
 };
 
 void mail_enable_stop(void)
 {
-	struct _mail_msg *m;
+	MailMsg *m;
 
 	MAIL_MT_LOCK(status_lock);
 	busy_state++;
 	if (busy_state == 1) {
-		m = mail_msg_new(&set_busy_op, NULL, sizeof(*m));
-		e_msgport_put(mail_gui_port, (EMsg *)m);
+		m = mail_msg_new(&set_busy_info);
+		mail_msg_main_loop_push(m);
 	}
 	MAIL_MT_UNLOCK(status_lock);
 }
 
 void mail_disable_stop(void)
 {
-	struct _mail_msg *m;
+	MailMsg *m;
 
 	MAIL_MT_LOCK(status_lock);
 	busy_state--;
 	if (busy_state == 0) {
-		m = mail_msg_new(&set_busy_op, NULL, sizeof(*m));
-		e_msgport_put(mail_gui_port, (EMsg *)m);
+		m = mail_msg_new(&set_busy_info);
+		mail_msg_main_loop_push(m);
 	}
 	MAIL_MT_UNLOCK(status_lock);
 }
@@ -955,7 +932,7 @@ void mail_disable_stop(void)
 /* ******************************************************************************** */
 
 struct _op_status_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	struct _CamelOperation *op;
 	char *what;
@@ -963,16 +940,16 @@ struct _op_status_msg {
 	void *data;
 };
 
-static void do_op_status(struct _mail_msg *mm)
+static void
+op_status_exec (struct _op_status_msg *m)
 {
 	EActivityHandler *activity_handler = mail_component_peek_activity_handler (mail_component_peek ());
-	struct _op_status_msg *m = (struct _op_status_msg *)mm;
-	struct _mail_msg *msg;
-	struct _mail_msg_priv *data;
+	MailMsg *msg;
+	MailMsgPrivate *data;
 	char *out, *p, *o, c;
 	int pc;
 
-	g_return_if_fail (pthread_equal(mail_gui_thread, pthread_self ()));
+	g_return_if_fail (mail_in_main_thread ());
 
 	MAIL_MT_LOCK (mail_msg_lock);
 
@@ -1011,8 +988,8 @@ static void do_op_status(struct _mail_msg *mm)
 				progress_icon = e_icon_factory_get_icon ("mail-unread", E_ICON_SIZE_MENU);
 
 			MAIL_MT_UNLOCK (mail_msg_lock);
-			if (msg->ops->describe_msg)
-				what = msg->ops->describe_msg (msg, FALSE);
+			if (msg->info->desc)
+				what = msg->info->desc (msg);
 			else if (m->what)
 				what = g_strdup (m->what);
 			/* uncommenting because message is not very useful for a user, see bug 271734*/
@@ -1028,13 +1005,7 @@ static void do_op_status(struct _mail_msg *mm)
 				int activity_id = data->activity_id;
 
 				MAIL_MT_UNLOCK (mail_msg_lock);
-				if (msg->cancel) {
-					camel_operation_mute (msg->cancel);
-					camel_operation_unref (msg->cancel);
-				}
-				camel_exception_clear (&msg->ex);
-				g_free (msg->priv);
-				g_free (msg);
+				mail_msg_free (msg);
 
 				if (activity_id != 0)
 					mail_async_event_emit (mail_async_event, MAIL_ASYNC_GUI, (MailAsyncFunc) end_event_callback,
@@ -1054,18 +1025,17 @@ static void do_op_status(struct _mail_msg *mm)
 }
 
 static void
-do_op_status_free (struct _mail_msg *mm)
+op_status_free (struct _op_status_msg *m)
 {
-	struct _op_status_msg *m = (struct _op_status_msg *)mm;
-
 	g_free (m->what);
 }
 
-static struct _mail_msg_op op_status_op = {
-	NULL,
-	do_op_status,
-	NULL,
-	do_op_status_free,
+static MailMsgInfo op_status_info = {
+	sizeof (struct _op_status_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) op_status_exec,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) op_status_free
 };
 
 static void
@@ -1075,7 +1045,7 @@ mail_operation_status (struct _CamelOperation *op, const char *what, int pc, voi
 
 	d(printf("got operation statys: %s %d%%\n", what, pc));
 
-	m = mail_msg_new(&op_status_op, NULL, sizeof(*m));
+	m = mail_msg_new(&op_status_info);
 	m->op = op;
 	m->what = g_strdup(what);
 	switch (pc) {
@@ -1088,7 +1058,7 @@ mail_operation_status (struct _CamelOperation *op, const char *what, int pc, voi
 	}
 	m->pc = pc;
 	m->data = data;
-	e_msgport_put(mail_gui_port, (EMsg *)m);
+	mail_msg_main_loop_push(m);
 }
 
 /* ******************** */
diff --git a/mail/mail-mt.h b/mail/mail-mt.h
index a508b87d46..f0da44da0f 100644
--- a/mail/mail-mt.h
+++ b/mail/mail-mt.h
@@ -23,48 +23,65 @@
 #ifndef _MAIL_MT
 #define _MAIL_MT
 
-#include <pthread.h>
 #include "camel/camel-exception.h"
-#include "libedataserver/e-msgport.h"
 #include "camel/camel-object.h"
 #include "camel/camel-operation.h"
 
-typedef struct _mail_msg {
-	EMsg msg;		/* parent type */
-	struct _mail_msg_op *ops; /* operation functions */
+typedef struct _MailMsg MailMsg;
+typedef struct _MailMsgInfo MailMsgInfo;
+typedef struct _MailMsgPrivate MailMsgPrivate;
+
+typedef gchar *	(*MailMsgDescFunc)	(MailMsg *msg);
+typedef void	(*MailMsgExecFunc)	(MailMsg *msg);
+typedef void	(*MailMsgDoneFunc)	(MailMsg *msg);
+typedef void	(*MailMsgFreeFunc)	(MailMsg *msg);
+typedef void	(*MailMsgDispatchFunc)	(gpointer msg);
+
+struct _MailMsg {
+	MailMsgInfo *info;
+	volatile gint ref_count;
 	unsigned int seq;	/* seq number for synchronisation */
+	gint priority;		/* priority (default = 0) */
 	CamelOperation *cancel;	/* a cancellation/status handle */
 	CamelException ex;	/* an initialised camel exception, upto the caller to use this */
-	struct _mail_msg_priv *priv; /* private for internal use */
-} mail_msg_t;
-
-/* callback functions for thread message */
-typedef struct _mail_msg_op {
-	char *(*describe_msg)(struct _mail_msg *msg, int complete);
+	MailMsgPrivate *priv;
+};
 
-	void (*receive_msg)(struct _mail_msg *msg);	/* message received */
-	void (*reply_msg)(struct _mail_msg *msg);	/* message replied */
-	void (*destroy_msg)(struct _mail_msg *msg);	/* finalise message */
-} mail_msg_op_t;
+struct _MailMsgInfo {
+	gsize size;
+	MailMsgDescFunc desc;
+	MailMsgExecFunc exec;
+	MailMsgDoneFunc done;
+	MailMsgFreeFunc free;
+};
 
 /* setup ports */
 void mail_msg_init(void);
 void mail_msg_cleanup (void);
 
+gboolean mail_in_main_thread (void);
+
 /* allocate a new message */
-void *mail_msg_new(mail_msg_op_t *ops, EMsgPort *reply_port, size_t size);
-void mail_msg_free(void *msg);
-void mail_msg_check_error(void *msg);
+gpointer mail_msg_new (MailMsgInfo *info);
+gpointer mail_msg_ref (gpointer msg);
+void mail_msg_unref (gpointer msg);
+void mail_msg_check_error (gpointer msg);
 void mail_msg_cancel(unsigned int msgid);
 void mail_msg_wait(unsigned int msgid);
 void mail_msg_wait_all(void);
 int mail_msg_active(unsigned int msgid);
 
+/* dispatch a message */
+void mail_msg_main_loop_push (gpointer msg);
+void mail_msg_unordered_push (gpointer msg);
+void mail_msg_fast_ordered_push (gpointer msg);
+void mail_msg_slow_ordered_push (gpointer msg);
+
 /* To implement the stop button */
-void *mail_cancel_hook_add(GDestroyNotify func, void *data);
-void mail_cancel_hook_remove(void *handle);
-void mail_cancel_all(void);
-void mail_msg_set_cancelable (struct _mail_msg *msg, gboolean status);
+GHook * mail_cancel_hook_add (GHookFunc func, gpointer data);
+void mail_cancel_hook_remove (GHook *hook);
+void mail_cancel_all (void);
+void mail_msg_set_cancelable (gpointer msg, gboolean status);
 
 /* request a string/password */
 char *mail_get_password (CamelService *service, const char *prompt,
@@ -113,24 +130,6 @@ void *mail_call_main(mail_call_t type, MailMainFunc func, ...);
 void mail_enable_stop(void);
 void mail_disable_stop(void);
 
-/* a message port that receives messages in the gui thread, used for sending port */
-extern EMsgPort *mail_gui_port;
-/* a message port that receives messages in the gui thread, used for the reply port */
-extern EMsgPort *mail_gui_reply_port;
-
-/* some globally available threads */
-#ifndef G_OS_WIN32
-extern EThread *mail_thread_queued;	/* for operations that can (or should) be queued */
-#else
-EThread *mail_win32_get_mail_thread_queued (void);
-#define mail_thread_queued mail_win32_get_mail_thread_queued ()
-#endif
-extern EThread *mail_thread_new;	/* for operations that should run in a new thread each time */
-extern EThread *mail_thread_queued_slow;	/* for operations that can (or should) be queued, but take a long time */
-
-/* The main thread. */
-extern pthread_t mail_gui_thread;
-
 /* A generic proxy event for anything that can be proxied during the life of the mailer (almost nothing) */
 /* Note that almost all objects care about the lifecycle of their events, so this cannot be used */
 extern MailAsyncEvent *mail_async_event;
diff --git a/mail/mail-ops.c b/mail/mail-ops.c
index 46a781f9ac..82fb0af912 100644
--- a/mail/mail-ops.c
+++ b/mail/mail-ops.c
@@ -75,7 +75,7 @@
 /* used for both just filtering a folder + uid's, and for filtering a whole folder */
 /* used both for fetching mail, and for filtering mail */
 struct _filter_mail_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *source_folder; /* where they come from */
 	GPtrArray *source_uids;	/* uids to copy, or NULL == copy all */
@@ -99,8 +99,8 @@ struct _fetch_mail_msg {
 	void *data;
 };
 
-static char *
-em_filter_folder_element_describe (struct _mail_msg *mm, int complete)
+static gchar *
+em_filter_folder_element_desc (struct _filter_mail_msg *m)
 {
 	return g_strdup (_("Filtering Selected Messages"));
 }
@@ -108,9 +108,8 @@ em_filter_folder_element_describe (struct _mail_msg *mm, int complete)
 /* filter a folder, or a subset thereof, uses source_folder/source_uids */
 /* this is shared with fetch_mail */
 static void
-em_filter_folder_element_filter (struct _mail_msg *mm)
+em_filter_folder_element_exec (struct _filter_mail_msg *m)
 {
-	struct _filter_mail_msg *m = (struct _filter_mail_msg *)mm;
 	CamelFolder *folder;
 	GPtrArray *uids, *folder_uids = NULL;
 
@@ -137,15 +136,15 @@ em_filter_folder_element_filter (struct _mail_msg *mm)
 	else
 		folder_uids = uids = camel_folder_get_uids (folder);
 
-	camel_filter_driver_filter_folder (m->driver, folder, m->cache, uids, m->delete, &mm->ex);
-	camel_filter_driver_flush (m->driver, &mm->ex);
+	camel_filter_driver_filter_folder (m->driver, folder, m->cache, uids, m->delete, &m->base.ex);
+	camel_filter_driver_flush (m->driver, &m->base.ex);
 
 	if (folder_uids)
 		camel_folder_free_uids (folder, folder_uids);
 
 	/* sync our source folder */
 	if (!m->cache)
-		camel_folder_sync (folder, FALSE, camel_exception_is_set (&mm->ex) ? NULL : &mm->ex);
+		camel_folder_sync (folder, FALSE, camel_exception_is_set (&m->base.ex) ? NULL : &m->base.ex);
 	camel_folder_thaw (folder);
 
 	if (m->destination)
@@ -161,15 +160,13 @@ em_filter_folder_element_filter (struct _mail_msg *mm)
 }
 
 static void
-em_filter_folder_element_filtered (struct _mail_msg *mm)
+em_filter_folder_element_done (struct _filter_mail_msg *m)
 {
 }
 
 static void
-em_filter_folder_element_free (struct _mail_msg *mm)
+em_filter_folder_element_free (struct _filter_mail_msg *m)
 {
-	struct _filter_mail_msg *m = (struct _filter_mail_msg *)mm;
-
 	if (m->source_folder)
 		camel_object_unref (m->source_folder);
 
@@ -188,11 +185,12 @@ em_filter_folder_element_free (struct _mail_msg *mm)
 	mail_session_flush_filter_log ();
 }
 
-static struct _mail_msg_op em_filter_folder_element_op = {
-	em_filter_folder_element_describe,  /* we do our own progress reporting? */
-	em_filter_folder_element_filter,
-	em_filter_folder_element_filtered,
-	em_filter_folder_element_free,
+static MailMsgInfo em_filter_folder_element_info = {
+	sizeof (struct _filter_mail_msg),
+	(MailMsgDescFunc) em_filter_folder_element_desc,  /* we do our own progress reporting? */
+	(MailMsgExecFunc) em_filter_folder_element_exec,
+	(MailMsgDoneFunc) em_filter_folder_element_done,
+	(MailMsgFreeFunc) em_filter_folder_element_free
 };
 
 void
@@ -202,7 +200,7 @@ mail_filter_folder (CamelFolder *source_folder, GPtrArray *uids,
 {
 	struct _filter_mail_msg *m;
 
-	m = mail_msg_new (&em_filter_folder_element_op, NULL, sizeof (*m));
+	m = mail_msg_new (&em_filter_folder_element_info);
 	m->source_folder = source_folder;
 	camel_object_ref (source_folder);
 	m->source_uids = uids;
@@ -221,7 +219,7 @@ mail_filter_folder (CamelFolder *source_folder, GPtrArray *uids,
 		camel_filter_driver_remove_rule_by_name (m->driver, "new-mail-notification");
 	}
 
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 }
 
 /* convenience functions for it */
@@ -260,17 +258,16 @@ uid_cachename_hack (CamelStore *store)
 	return filename;
 }
 
-static char *
-fetch_mail_describe (struct _mail_msg *mm, int complete)
+static gchar *
+fetch_mail_desc (struct _fetch_mail_msg *m)
 {
 	return g_strdup (_("Fetching Mail"));
 }
 
 static void
-fetch_mail_fetch (struct _mail_msg *mm)
+fetch_mail_exec (struct _fetch_mail_msg *m)
 {
-	struct _fetch_mail_msg *m = (struct _fetch_mail_msg *)mm;
-	struct _filter_mail_msg *fm = (struct _filter_mail_msg *)mm;
+	struct _filter_mail_msg *fm = (struct _filter_mail_msg *)m;
 	int i;
 
 	if (m->cancel)
@@ -283,20 +280,20 @@ fetch_mail_fetch (struct _mail_msg *mm)
 	/* FIXME: this should support keep_on_server too, which would then perform a spool
 	   access thingy, right?  problem is matching raw messages to uid's etc. */
 	if (!strncmp (m->source_uri, "mbox:", 5)) {
-		char *path = mail_tool_do_movemail (m->source_uri, &mm->ex);
+		char *path = mail_tool_do_movemail (m->source_uri, &fm->base.ex);
 
-		if (path && !camel_exception_is_set (&mm->ex)) {
+		if (path && !camel_exception_is_set (&fm->base.ex)) {
 			camel_folder_freeze (fm->destination);
 			camel_filter_driver_set_default_folder (fm->driver, fm->destination);
-			camel_filter_driver_filter_mbox (fm->driver, path, m->source_uri, &mm->ex);
+			camel_filter_driver_filter_mbox (fm->driver, path, m->source_uri, &fm->base.ex);
 			camel_folder_thaw (fm->destination);
 
-			if (!camel_exception_is_set (&mm->ex))
+			if (!camel_exception_is_set (&fm->base.ex))
 				g_unlink (path);
 		}
 		g_free (path);
 	} else {
-		CamelFolder *folder = fm->source_folder = mail_tool_get_inbox (m->source_uri, &mm->ex);
+		CamelFolder *folder = fm->source_folder = mail_tool_get_inbox (m->source_uri, &fm->base.ex);
 
 		if (folder) {
 			/* this handles 'keep on server' stuff, if we have any new uid's to copy
@@ -322,17 +319,17 @@ fetch_mail_fetch (struct _mail_msg *mm)
 					camel_uid_cache_free_uids (cache_uids);
 
 					fm->cache = cache;
-					em_filter_folder_element_filter (mm);
+					em_filter_folder_element_exec (fm);
 
 					/* need to uncancel so writes/etc. don't fail */
-					if (mm->ex.id == CAMEL_EXCEPTION_USER_CANCEL)
+					if (fm->base.ex.id == CAMEL_EXCEPTION_USER_CANCEL)
 						camel_operation_uncancel(NULL);
 
 					/* save the cache of uids that we've just downloaded */
 					camel_uid_cache_save (cache);
 				}
 
-				if (fm->delete && mm->ex.id == CAMEL_EXCEPTION_NONE) {
+				if (fm->delete && !camel_exception_is_set (&fm->base.ex)) {
 					/* not keep on server - just delete all the actual messages on the server */
 					for (i=0;i<folder_uids->len;i++) {
 						d(printf("force delete uid '%s'\n", (char *)folder_uids->pdata[i]));
@@ -348,7 +345,7 @@ fetch_mail_fetch (struct _mail_msg *mm)
 				camel_uid_cache_destroy (cache);
 				camel_folder_free_uids (folder, folder_uids);
 			} else {
-				em_filter_folder_element_filter (mm);
+				em_filter_folder_element_exec (fm);
 			}
 
 			/* we unref the source folder here since we
@@ -372,31 +369,28 @@ fail:
 }
 
 static void
-fetch_mail_fetched (struct _mail_msg *mm)
+fetch_mail_done (struct _fetch_mail_msg *m)
 {
-	struct _fetch_mail_msg *m = (struct _fetch_mail_msg *)mm;
-
 	if (m->done)
 		m->done (m->source_uri, m->data);
 }
 
 static void
-fetch_mail_free (struct _mail_msg *mm)
+fetch_mail_free (struct _fetch_mail_msg *m)
 {
-	struct _fetch_mail_msg *m = (struct _fetch_mail_msg *)mm;
-
 	g_free (m->source_uri);
 	if (m->cancel)
 		camel_operation_unref (m->cancel);
 
-	em_filter_folder_element_free (mm);
+	em_filter_folder_element_free ((struct _filter_mail_msg *) m);
 }
 
-static struct _mail_msg_op fetch_mail_op = {
-	fetch_mail_describe, /* we do our own progress reporting */
-	fetch_mail_fetch,
-	fetch_mail_fetched,
-	fetch_mail_free,
+static MailMsgInfo fetch_mail_info = {
+	sizeof (struct _fetch_mail_msg),
+	(MailMsgDescFunc) fetch_mail_desc,
+	(MailMsgExecFunc) fetch_mail_exec,
+	(MailMsgDoneFunc) fetch_mail_done,
+	(MailMsgFreeFunc) fetch_mail_free
 };
 
 /* ouch, a 'do everything' interface ... */
@@ -409,7 +403,7 @@ mail_fetch_mail (const char *source, int keep, const char *type, CamelOperation
 	struct _fetch_mail_msg *m;
 	struct _filter_mail_msg *fm;
 
-	m = mail_msg_new (&fetch_mail_op, NULL, sizeof (*m));
+	m = mail_msg_new (&fetch_mail_info);
 	fm = (struct _filter_mail_msg *)m;
 	m->source_uri = g_strdup (source);
 	fm->delete = !keep;
@@ -426,7 +420,7 @@ mail_fetch_mail (const char *source, int keep, const char *type, CamelOperation
 	if (status)
 		camel_filter_driver_set_status_func (fm->driver, status, status_data);
 
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 }
 
 /* ********************************************************************** */
@@ -657,7 +651,7 @@ exit:
 /* ** SEND MAIL QUEUE ***************************************************** */
 
 struct _send_queue_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *queue;
 	char *destination;
@@ -689,9 +683,8 @@ report_status (struct _send_queue_msg *m, enum camel_filter_status_t status, int
 }
 
 static void
-send_queue_send(struct _mail_msg *mm)
+send_queue_exec (struct _send_queue_msg *m)
 {
-	struct _send_queue_msg *m = (struct _send_queue_msg *)mm;
 	CamelFolder *sent_folder = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_SENT);
 	GPtrArray *uids, *send_uids = NULL;
 	CamelException ex;
@@ -725,7 +718,7 @@ send_queue_send(struct _mail_msg *mm)
 	if (m->cancel)
 		camel_operation_register (m->cancel);
  	else
- 		camel_operation_register (mm->cancel);
+ 		camel_operation_register (m->base.cancel);
  
  	if (!m->cancel)
  		camel_operation_start (NULL, _("Sending message"));
@@ -746,17 +739,17 @@ send_queue_send(struct _mail_msg *mm)
 		if (camel_exception_is_set (&ex)) {
 			if (ex.id != CAMEL_EXCEPTION_USER_CANCEL) {
 				/* merge exceptions into one */
-				if (camel_exception_is_set (&mm->ex))
-					camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM, "%s\n\n%s", mm->ex.desc, ex.desc);
+				if (camel_exception_is_set (&m->base.ex))
+					camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM, "%s\n\n%s", m->base.ex.desc, ex.desc);
 				else
-					camel_exception_xfer (&mm->ex, &ex);
+					camel_exception_xfer (&m->base.ex, &ex);
 				camel_exception_clear (&ex);
 
 				/* keep track of the number of failures */
 				j++;
 			} else {
 				/* transfer the USER_CANCEL exeption to the async op exception and then break */
-				camel_exception_xfer (&mm->ex, &ex);
+				camel_exception_xfer (&m->base.ex, &ex);
 				break;
 			}
 		}
@@ -766,7 +759,7 @@ send_queue_send(struct _mail_msg *mm)
 
 	if (j > 0)
 		report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Failed to send %d of %d messages"), j, send_uids->len);
-	else if (mm->ex.id == CAMEL_EXCEPTION_USER_CANCEL)
+	else if (m->base.ex.id == CAMEL_EXCEPTION_USER_CANCEL)
 		report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Canceled."));
 	else
 		report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Complete."));
@@ -793,24 +786,20 @@ send_queue_send(struct _mail_msg *mm)
 	if (m->cancel)
 		camel_operation_unregister (m->cancel);
  	else
- 		camel_operation_unregister (mm->cancel);
+ 		camel_operation_unregister (m->base.cancel);
  
 }
 
 static void
-send_queue_sent(struct _mail_msg *mm)
+send_queue_done (struct _send_queue_msg *m)
 {
-	struct _send_queue_msg *m = (struct _send_queue_msg *)mm;
-
 	if (m->done)
 		m->done(m->destination, m->data);
 }
 
 static void
-send_queue_free(struct _mail_msg *mm)
+send_queue_free (struct _send_queue_msg *m)
 {
-	struct _send_queue_msg *m = (struct _send_queue_msg *)mm;
-
 	if (m->driver)
 		camel_object_unref(m->driver);
 	camel_object_unref(m->queue);
@@ -819,11 +808,12 @@ send_queue_free(struct _mail_msg *mm)
 		camel_operation_unref(m->cancel);
 }
 
-static struct _mail_msg_op send_queue_op = {
-	NULL,			/* do our own reporting, as with fetch mail */
-	send_queue_send,
-	send_queue_sent,
-	send_queue_free,
+static MailMsgInfo send_queue_info = {
+	sizeof (struct _send_queue_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) send_queue_exec,
+	(MailMsgDoneFunc) send_queue_done,
+	(MailMsgFreeFunc) send_queue_free
 };
 
 /* same interface as fetch_mail, just 'cause i'm lazy today (and we need to run it from the same spot?) */
@@ -836,17 +826,17 @@ mail_send_queue(CamelFolder *queue, const char *destination,
 {
 	struct _send_queue_msg *m;
 
-	m = mail_msg_new(&send_queue_op, NULL, sizeof(*m));
+	m = mail_msg_new(&send_queue_info);
 	m->queue = queue;
 	camel_object_ref(queue);
 	m->destination = g_strdup(destination);
 	if (cancel) {
 		m->cancel = cancel;
 		camel_operation_ref(cancel);
-		camel_operation_unref (((struct _mail_msg *) m)->cancel);
-		mail_msg_set_cancelable ((struct _mail_msg *)m, FALSE);
+		camel_operation_unref (m->base.cancel);
+		mail_msg_set_cancelable (m, FALSE);
 
-		((struct _mail_msg *) m)->cancel = NULL;
+		m->base.cancel = NULL;
 	}
 	m->status = status;
 	m->status_data = status_data;
@@ -856,13 +846,13 @@ mail_send_queue(CamelFolder *queue, const char *destination,
 	m->driver = camel_session_get_filter_driver (session, type, NULL);
 	camel_filter_driver_set_folder_func (m->driver, get_folder, get_data);
 
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 }
 
 /* ** APPEND MESSAGE TO FOLDER ******************************************** */
 
 struct _append_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
         CamelFolder *folder;
 	CamelMimeMessage *message;
@@ -873,45 +863,40 @@ struct _append_msg {
 	void *data;
 };
 
-static char *
-append_mail_desc (struct _mail_msg *mm, int done)
+static gchar *
+append_mail_desc (struct _append_msg *m)
 {
 	return g_strdup (_("Saving message to folder"));
 }
 
 static void
-append_mail_append (struct _mail_msg *mm)
+append_mail_exec (struct _append_msg *m)
 {
-	struct _append_msg *m = (struct _append_msg *)mm;
-
 	camel_mime_message_set_date(m->message, CAMEL_MESSAGE_DATE_CURRENT, 0);
-	camel_folder_append_message(m->folder, m->message, m->info, &m->appended_uid, &mm->ex);
+	camel_folder_append_message(m->folder, m->message, m->info, &m->appended_uid, &m->base.ex);
 }
 
 static void
-append_mail_appended (struct _mail_msg *mm)
+append_mail_done (struct _append_msg *m)
 {
-	struct _append_msg *m = (struct _append_msg *)mm;
-
 	if (m->done)
-		m->done(m->folder, m->message, m->info, !camel_exception_is_set(&mm->ex), m->appended_uid, m->data);
+		m->done(m->folder, m->message, m->info, !camel_exception_is_set(&m->base.ex), m->appended_uid, m->data);
 }
 
 static void
-append_mail_free (struct _mail_msg *mm)
+append_mail_free (struct _append_msg *m)
 {
-	struct _append_msg *m = (struct _append_msg *)mm;
-
 	camel_object_unref(m->message);
 	camel_object_unref(m->folder);
 	g_free (m->appended_uid);
 }
 
-static struct _mail_msg_op append_mail_op = {
-	append_mail_desc,
-	append_mail_append,
-	append_mail_appended,
-	append_mail_free
+static MailMsgInfo append_mail_info = {
+	sizeof (struct _append_msg),
+	(MailMsgDescFunc) append_mail_desc,
+	(MailMsgExecFunc) append_mail_exec,
+	(MailMsgDoneFunc) append_mail_done,
+	(MailMsgFreeFunc) append_mail_free
 };
 
 void
@@ -928,7 +913,7 @@ mail_append_mail (CamelFolder *folder, CamelMimeMessage *message, CamelMessageIn
 		camel_medium_set_header (CAMEL_MEDIUM (message), "X-Mailer",
 					 "Evolution " VERSION SUB_VERSION " " VERSION_COMMENT);
 
-	m = mail_msg_new (&append_mail_op, NULL, sizeof (*m));
+	m = mail_msg_new (&append_mail_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->message = message;
@@ -938,13 +923,13 @@ mail_append_mail (CamelFolder *folder, CamelMimeMessage *message, CamelMessageIn
 	m->done = done;
 	m->data = data;
 
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 }
 
 /* ** TRANSFER MESSAGES **************************************************** */
 
 struct _transfer_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *source;
 	GPtrArray *uids;
@@ -956,24 +941,21 @@ struct _transfer_msg {
 	void *data;
 };
 
-static char *
-transfer_messages_desc (struct _mail_msg *mm, int done)
+static gchar *
+transfer_messages_desc (struct _transfer_msg *m)
 {
-	struct _transfer_msg *m = (struct _transfer_msg *)mm;
-
 	return g_strdup_printf(m->delete?_("Moving messages to %s"):_("Copying messages to %s"),
 			       m->dest_uri);
 
 }
 
 static void
-transfer_messages_transfer (struct _mail_msg *mm)
+transfer_messages_exec (struct _transfer_msg *m)
 {
-	struct _transfer_msg *m = (struct _transfer_msg *)mm;
 	CamelFolder *dest;
 
-	dest = mail_tool_uri_to_folder (m->dest_uri, m->dest_flags, &mm->ex);
-	if (camel_exception_is_set (&mm->ex))
+	dest = mail_tool_uri_to_folder (m->dest_uri, m->dest_flags, &m->base.ex);
+	if (camel_exception_is_set (&m->base.ex))
 		return;
 
 	if (dest == m->source) {
@@ -985,7 +967,7 @@ transfer_messages_transfer (struct _mail_msg *mm)
 	camel_folder_freeze (m->source);
 	camel_folder_freeze (dest);
 
-	camel_folder_transfer_messages_to (m->source, m->uids, dest, NULL, m->delete, &mm->ex);
+	camel_folder_transfer_messages_to (m->source, m->uids, dest, NULL, m->delete, &m->base.ex);
 
 	/* make sure all deleted messages are marked as seen */
 
@@ -1004,29 +986,26 @@ transfer_messages_transfer (struct _mail_msg *mm)
 }
 
 static void
-transfer_messages_transferred (struct _mail_msg *mm)
+transfer_messages_done (struct _transfer_msg *m)
 {
-	struct _transfer_msg *m = (struct _transfer_msg *)mm;
-
 	if (m->done)
-		m->done (!camel_exception_is_set (&mm->ex), m->data);
+		m->done (!camel_exception_is_set (&m->base.ex), m->data);
 }
 
 static void
-transfer_messages_free (struct _mail_msg *mm)
+transfer_messages_free (struct _transfer_msg *m)
 {
-	struct _transfer_msg *m = (struct _transfer_msg *)mm;
-
 	camel_object_unref (m->source);
 	g_free (m->dest_uri);
 	em_utils_uids_free (m->uids);
 }
 
-static struct _mail_msg_op transfer_messages_op = {
-	transfer_messages_desc,
-	transfer_messages_transfer,
-	transfer_messages_transferred,
-	transfer_messages_free,
+static MailMsgInfo transfer_messages_info = {
+	sizeof (struct _transfer_msg),
+	(MailMsgDescFunc) transfer_messages_desc,
+	(MailMsgExecFunc) transfer_messages_exec,
+	(MailMsgDoneFunc) transfer_messages_done,
+	(MailMsgFreeFunc) transfer_messages_free
 };
 
 void
@@ -1043,7 +1022,7 @@ mail_transfer_messages (CamelFolder *source, GPtrArray *uids,
 	g_return_if_fail (uids != NULL);
 	g_return_if_fail (dest_uri != NULL);
 
-	m = mail_msg_new(&transfer_messages_op, NULL, sizeof(*m));
+	m = mail_msg_new(&transfer_messages_info);
 	m->source = source;
 	camel_object_ref (source);
 	m->uids = uids;
@@ -1053,13 +1032,13 @@ mail_transfer_messages (CamelFolder *source, GPtrArray *uids,
 	m->done = done;
 	m->data = data;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ** SCAN SUBFOLDERS ***************************************************** */
 
 struct _get_folderinfo_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelStore *store;
 	CamelFolderInfo *info;
@@ -1067,10 +1046,9 @@ struct _get_folderinfo_msg {
 	void *data;
 };
 
-static char *
-get_folderinfo_desc (struct _mail_msg *mm, int done)
+static gchar *
+get_folderinfo_desc (struct _get_folderinfo_msg *m)
 {
-	struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
 	char *ret, *name;
 
 	name = camel_service_get_name((CamelService *)m->store, TRUE);
@@ -1080,25 +1058,22 @@ get_folderinfo_desc (struct _mail_msg *mm, int done)
 }
 
 static void
-get_folderinfo_get (struct _mail_msg *mm)
+get_folderinfo_exec (struct _get_folderinfo_msg *m)
 {
-	struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
 	guint32 flags = CAMEL_STORE_FOLDER_INFO_RECURSIVE|CAMEL_STORE_FOLDER_INFO_FAST | CAMEL_STORE_FOLDER_INFO_SUBSCRIBED;
 
-	m->info = camel_store_get_folder_info (m->store, NULL, flags, &mm->ex);
+	m->info = camel_store_get_folder_info (m->store, NULL, flags, &m->base.ex);
 }
 
 static void
-get_folderinfo_got (struct _mail_msg *mm)
+get_folderinfo_done (struct _get_folderinfo_msg *m)
 {
-	struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
-
-	if (!m->info && camel_exception_is_set (&mm->ex)) {
+	if (!m->info && camel_exception_is_set (&m->base.ex)) {
 		char *url;
 
 		url = camel_service_get_url (CAMEL_SERVICE (m->store));
 		w(g_warning ("Error getting folder info from store at %s: %s",
-			     url, camel_exception_get_description (&mm->ex)));
+			     url, camel_exception_get_description (&m->base.ex)));
 		g_free (url);
 	}
 
@@ -1107,20 +1082,19 @@ get_folderinfo_got (struct _mail_msg *mm)
 }
 
 static void
-get_folderinfo_free (struct _mail_msg *mm)
+get_folderinfo_free (struct _get_folderinfo_msg *m)
 {
-	struct _get_folderinfo_msg *m = (struct _get_folderinfo_msg *)mm;
-
 	if (m->info)
 		camel_store_free_folder_info(m->store, m->info);
 	camel_object_unref(m->store);
 }
 
-static struct _mail_msg_op get_folderinfo_op = {
-	get_folderinfo_desc,
-	get_folderinfo_get,
-	get_folderinfo_got,
-	get_folderinfo_free,
+static MailMsgInfo get_folderinfo_info = {
+	sizeof (struct _get_folderinfo_msg),
+	(MailMsgDescFunc) get_folderinfo_desc,
+	(MailMsgExecFunc) get_folderinfo_exec,
+	(MailMsgDoneFunc) get_folderinfo_done,
+	(MailMsgFreeFunc) get_folderinfo_free
 };
 
 int
@@ -1129,19 +1103,19 @@ mail_get_folderinfo (CamelStore *store, CamelOperation *op, void (*done)(CamelSt
 	struct _get_folderinfo_msg *m;
 	int id;
 
-	m = mail_msg_new(&get_folderinfo_op, NULL, sizeof(*m));
+	m = mail_msg_new(&get_folderinfo_info);
 	if (op) {
-		camel_operation_unref(m->msg.cancel);
-		m->msg.cancel = op;
+		camel_operation_unref(m->base.cancel);
+		m->base.cancel = op;
 		camel_operation_ref(op);
 	}
 	m->store = store;
 	camel_object_ref(store);
 	m->done = done;
 	m->data = data;
-	id = m->msg.seq;
+	id = m->base.seq;
 
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 
 	return id;
 }
@@ -1213,7 +1187,7 @@ mail_build_attachment(CamelFolder *folder, GPtrArray *uids,
    presumably create a folder ... */
 
 struct _get_folder_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	char *uri;
 	guint32 flags;
@@ -1222,71 +1196,64 @@ struct _get_folder_msg {
 	void *data;
 };
 
-static char *
-get_folder_desc (struct _mail_msg *mm, int done)
+static gchar *
+get_folder_desc (struct _get_folder_msg *m)
 {
-	struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
-
 	return g_strdup_printf(_("Opening folder %s"), m->uri);
 }
 
 static void
-get_folder_get (struct _mail_msg *mm)
+get_folder_exec (struct _get_folder_msg *m)
 {
-	struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
-
-	m->folder = mail_tool_uri_to_folder (m->uri, m->flags, &mm->ex);
+	m->folder = mail_tool_uri_to_folder (m->uri, m->flags, &m->base.ex);
 }
 
 static void
-get_folder_got (struct _mail_msg *mm)
+get_folder_done (struct _get_folder_msg *m)
 {
-	struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
-
 	if (m->done)
 		m->done (m->uri, m->folder, m->data);
 }
 
 static void
-get_folder_free (struct _mail_msg *mm)
+get_folder_free (struct _get_folder_msg *m)
 {
-	struct _get_folder_msg *m = (struct _get_folder_msg *)mm;
-
 	g_free (m->uri);
 	if (m->folder)
 		camel_object_unref (m->folder);
 }
 
-static struct _mail_msg_op get_folder_op = {
-	get_folder_desc,
-	get_folder_get,
-	get_folder_got,
-	get_folder_free,
+static MailMsgInfo get_folder_info = {
+	sizeof (struct _get_folder_msg),
+	(MailMsgDescFunc) get_folder_desc,
+	(MailMsgExecFunc) get_folder_exec,
+	(MailMsgDoneFunc) get_folder_done,
+	(MailMsgFreeFunc) get_folder_free
 };
 
 int
 mail_get_folder (const char *uri, guint32 flags,
 		 void (*done)(char *uri, CamelFolder *folder, void *data),
-		 void *data, EThread *thread)
+		 void *data, MailMsgDispatchFunc dispatch)
 {
 	struct _get_folder_msg *m;
 	int id;
 
-	m = mail_msg_new(&get_folder_op, NULL, sizeof(*m));
+	m = mail_msg_new(&get_folder_info);
 	m->uri = g_strdup (uri);
 	m->flags = flags;
 	m->data = data;
 	m->done = done;
 
-	id = m->msg.seq;
-	e_thread_put(thread, (EMsg *)m);
+	id = m->base.seq;
+	dispatch (m);
 	return id;
 }
 
 /* ** GET STORE ******************************************************* */
 
 struct _get_store_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	char *uri;
 	CamelStore *store;
@@ -1294,50 +1261,43 @@ struct _get_store_msg {
 	void *data;
 };
 
-static char *
-get_store_desc (struct _mail_msg *mm, int done)
+static gchar *
+get_store_desc (struct _get_store_msg *m)
 {
-	struct _get_store_msg *m = (struct _get_store_msg *)mm;
-
 	return g_strdup_printf(_("Opening store %s"), m->uri);
 }
 
 static void
-get_store_get (struct _mail_msg *mm)
+get_store_exec (struct _get_store_msg *m)
 {
-	struct _get_store_msg *m = (struct _get_store_msg *)mm;
-
 	/*camel_session_get_store connects us, which we don't want to do on startup. */
 
 	m->store = (CamelStore *) camel_session_get_service (session, m->uri,
 							     CAMEL_PROVIDER_STORE,
-							     &mm->ex);
+							     &m->base.ex);
 }
 
 static void
-get_store_got (struct _mail_msg *mm)
+get_store_done (struct _get_store_msg *m)
 {
-	struct _get_store_msg *m = (struct _get_store_msg *)mm;
-
 	if (m->done)
 		m->done (m->uri, m->store, m->data);
 }
 
 static void
-get_store_free (struct _mail_msg *mm)
+get_store_free (struct _get_store_msg *m)
 {
-	struct _get_store_msg *m = (struct _get_store_msg *)mm;
-
 	g_free (m->uri);
 	if (m->store)
 		camel_object_unref (m->store);
 }
 
-static struct _mail_msg_op get_store_op = {
-	get_store_desc,
-	get_store_get,
-	get_store_got,
-	get_store_free,
+static MailMsgInfo get_store_info = {
+	sizeof (struct _get_store_msg),
+	(MailMsgDescFunc) get_store_desc,
+	(MailMsgExecFunc) get_store_exec,
+	(MailMsgDoneFunc) get_store_done,
+	(MailMsgFreeFunc) get_store_free
 };
 
 int
@@ -1346,25 +1306,25 @@ mail_get_store (const char *uri, CamelOperation *op, void (*done) (char *uri, Ca
 	struct _get_store_msg *m;
 	int id;
 
-	m = mail_msg_new (&get_store_op, NULL, sizeof (*m));
+	m = mail_msg_new (&get_store_info);
 	if (op) {
-		camel_operation_unref(m->msg.cancel);
-		m->msg.cancel = op;
+		camel_operation_unref(m->base.cancel);
+		m->base.cancel = op;
 		camel_operation_ref(op);
 	}
 	m->uri = g_strdup (uri);
 	m->data = data;
 	m->done = done;
 
-	id = m->msg.seq;
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 	return id;
 }
 
 /* ** REMOVE FOLDER ******************************************************* */
 
 struct _remove_folder_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	char *uri;
 	gboolean removed;
@@ -1372,18 +1332,15 @@ struct _remove_folder_msg {
 	void *data;
 };
 
-static char *
-remove_folder_desc (struct _mail_msg *mm, int done)
+static gchar *
+remove_folder_desc (struct _remove_folder_msg *m)
 {
-	struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
-
 	return g_strdup_printf (_("Removing folder %s"), m->uri);
 }
 
 static void
-remove_folder_get (struct _mail_msg *mm)
+remove_folder_exec (struct _remove_folder_msg *m)
 {
-	struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
 	CamelStore *store;
 	CamelFolder *folder;
 	GPtrArray *uids;
@@ -1391,7 +1348,7 @@ remove_folder_get (struct _mail_msg *mm)
 
 	m->removed = FALSE;
 
-	folder = mail_tool_uri_to_folder (m->uri, 0, &mm->ex);
+	folder = mail_tool_uri_to_folder (m->uri, 0, &m->base.ex);
 	if (!folder)
 		return;
 
@@ -1411,16 +1368,14 @@ remove_folder_get (struct _mail_msg *mm)
 		camel_store_unsubscribe_folder (store, folder->full_name, NULL);
 
 	/* Then delete the folder from the store */
-	camel_store_delete_folder (store, folder->full_name, &mm->ex);
-	m->removed = !camel_exception_is_set (&mm->ex);
+	camel_store_delete_folder (store, folder->full_name, &m->base.ex);
+	m->removed = !camel_exception_is_set (&m->base.ex);
 	camel_object_unref (folder);
 }
 
 static void
-remove_folder_got (struct _mail_msg *mm)
+remove_folder_done (struct _remove_folder_msg *m)
 {
-	struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
-
 	if (m->removed) {
 		/* FIXME: Remove this folder from the folder cache ??? */
 	}
@@ -1430,18 +1385,17 @@ remove_folder_got (struct _mail_msg *mm)
 }
 
 static void
-remove_folder_free (struct _mail_msg *mm)
+remove_folder_free (struct _remove_folder_msg *m)
 {
-	struct _remove_folder_msg *m = (struct _remove_folder_msg *)mm;
-
 	g_free (m->uri);
 }
 
-static struct _mail_msg_op remove_folder_op = {
-	remove_folder_desc,
-	remove_folder_get,
-	remove_folder_got,
-	remove_folder_free,
+static MailMsgInfo remove_folder_info = {
+	sizeof (struct _remove_folder_msg),
+	(MailMsgDescFunc) remove_folder_desc,
+	(MailMsgExecFunc) remove_folder_exec,
+	(MailMsgDoneFunc) remove_folder_done,
+	(MailMsgFreeFunc) remove_folder_free
 };
 
 void
@@ -1449,59 +1403,56 @@ mail_remove_folder (const char *uri, void (*done) (char *uri, gboolean removed,
 {
 	struct _remove_folder_msg *m;
 
-	m = mail_msg_new (&remove_folder_op, NULL, sizeof (*m));
+	m = mail_msg_new (&remove_folder_info);
 	m->uri = g_strdup (uri);
 	m->data = data;
 	m->done = done;
 
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 }
 
 /* ** SYNC FOLDER ********************************************************* */
 
 struct _sync_folder_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *folder;
 	void (*done) (CamelFolder *folder, void *data);
 	void *data;
 };
 
-static char *sync_folder_desc(struct _mail_msg *mm, int done)
+static gchar *
+sync_folder_desc (struct _sync_folder_msg *m)
 {
-	struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
-
 	return g_strdup_printf (_("Storing folder \'%s\'"),
 			       camel_folder_get_full_name (m->folder));
 }
 
-static void sync_folder_sync(struct _mail_msg *mm)
+static void
+sync_folder_exec (struct _sync_folder_msg *m)
 {
-	struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
-
-	camel_folder_sync(m->folder, FALSE, &mm->ex);
+	camel_folder_sync(m->folder, FALSE, &m->base.ex);
 }
 
-static void sync_folder_synced(struct _mail_msg *mm)
+static void
+sync_folder_done (struct _sync_folder_msg *m)
 {
-	struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
-
 	if (m->done)
 		m->done(m->folder, m->data);
 }
 
-static void sync_folder_free(struct _mail_msg *mm)
+static void
+sync_folder_free (struct _sync_folder_msg *m)
 {
-	struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
-
 	camel_object_unref((CamelObject *)m->folder);
 }
 
-static struct _mail_msg_op sync_folder_op = {
-	sync_folder_desc,
-	sync_folder_sync,
-	sync_folder_synced,
-	sync_folder_free,
+static MailMsgInfo sync_folder_info = {
+	sizeof (struct _sync_folder_msg),
+	(MailMsgDescFunc) sync_folder_desc,
+	(MailMsgExecFunc) sync_folder_exec,
+	(MailMsgDoneFunc) sync_folder_done,
+	(MailMsgFreeFunc) sync_folder_free
 };
 
 void
@@ -1509,19 +1460,19 @@ mail_sync_folder(CamelFolder *folder, void (*done) (CamelFolder *folder, void *d
 {
 	struct _sync_folder_msg *m;
 
-	m = mail_msg_new(&sync_folder_op, NULL, sizeof(*m));
+	m = mail_msg_new(&sync_folder_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ** SYNC STORE ********************************************************* */
 
 struct _sync_store_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelStore *store;
 	int expunge;
@@ -1529,9 +1480,9 @@ struct _sync_store_msg {
 	void *data;
 };
 
-static char *sync_store_desc(struct _mail_msg *mm, int done)
+static gchar *
+sync_store_desc (struct _sync_store_msg *m)
 {
-	struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
 	char *uri, *res;
 
 	uri = camel_url_to_string(((CamelService *)m->store)->url, CAMEL_URL_HIDE_ALL);
@@ -1544,33 +1495,31 @@ static char *sync_store_desc(struct _mail_msg *mm, int done)
 	return res;
 }
 
-static void sync_store_sync(struct _mail_msg *mm)
+static void
+sync_store_exec (struct _sync_store_msg *m)
 {
-	struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
-
-	camel_store_sync(m->store, m->expunge, &mm->ex);
+	camel_store_sync(m->store, m->expunge, &m->base.ex);
 }
 
-static void sync_store_synced(struct _mail_msg *mm)
+static void
+sync_store_done (struct _sync_store_msg *m)
 {
-	struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
-
 	if (m->done)
 		m->done(m->store, m->data);
 }
 
-static void sync_store_free(struct _mail_msg *mm)
+static void
+sync_store_free (struct _sync_store_msg *m)
 {
-	struct _sync_store_msg *m = (struct _sync_store_msg *)mm;
-
 	camel_object_unref(m->store);
 }
 
-static struct _mail_msg_op sync_store_op = {
-	sync_store_desc,
-	sync_store_sync,
-	sync_store_synced,
-	sync_store_free,
+static MailMsgInfo sync_store_info = {
+	sizeof (struct _sync_store_msg),
+	(MailMsgDescFunc) sync_store_desc,
+	(MailMsgExecFunc) sync_store_exec,
+	(MailMsgDoneFunc) sync_store_done,
+	(MailMsgFreeFunc) sync_store_free
 };
 
 void
@@ -1578,36 +1527,37 @@ mail_sync_store(CamelStore *store, int expunge, void (*done) (CamelStore *store,
 {
 	struct _sync_store_msg *m;
 
-	m = mail_msg_new(&sync_store_op, NULL, sizeof(*m));
+	m = mail_msg_new(&sync_store_info);
 	m->store = store;
 	m->expunge = expunge;
 	camel_object_ref(store);
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ******************************************************************************** */
 
-static char *refresh_folder_desc(struct _mail_msg *mm, int done)
+static gchar *
+refresh_folder_desc (struct _sync_folder_msg *m)
 {
 	return g_strdup(_("Refreshing folder"));
 }
 
-static void refresh_folder_refresh(struct _mail_msg *mm)
+static void
+refresh_folder_exec (struct _sync_folder_msg *m)
 {
-	struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
-
-	camel_folder_refresh_info(m->folder, &mm->ex);
+	camel_folder_refresh_info(m->folder, &m->base.ex);
 }
 
 /* we just use the sync stuff where we can, since it would be the same */
-static struct _mail_msg_op refresh_folder_op = {
-	refresh_folder_desc,
-	refresh_folder_refresh,
-	sync_folder_synced,
-	sync_folder_free,
+static MailMsgInfo refresh_folder_info = {
+	sizeof (struct _sync_folder_msg),
+	(MailMsgDescFunc) refresh_folder_desc,
+	(MailMsgExecFunc) refresh_folder_exec,
+	(MailMsgDoneFunc) sync_folder_done,
+	(MailMsgFreeFunc) sync_folder_free
 };
 
 void
@@ -1615,35 +1565,36 @@ mail_refresh_folder(CamelFolder *folder, void (*done) (CamelFolder *folder, void
 {
 	struct _sync_folder_msg *m;
 
-	m = mail_msg_new(&refresh_folder_op, NULL, sizeof(*m));
+	m = mail_msg_new(&refresh_folder_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ******************************************************************************** */
 
-static char *expunge_folder_desc(struct _mail_msg *mm, int done)
+static gchar *
+expunge_folder_desc (struct _sync_folder_msg *m)
 {
 	return g_strdup(_("Expunging folder"));
 }
 
-static void expunge_folder_expunge(struct _mail_msg *mm)
+static void
+expunge_folder_exec (struct _sync_folder_msg *m)
 {
-	struct _sync_folder_msg *m = (struct _sync_folder_msg *)mm;
-
-	camel_folder_expunge(m->folder, &mm->ex);
+	camel_folder_expunge(m->folder, &m->base.ex);
 }
 
 /* we just use the sync stuff where we can, since it would be the same */
-static struct _mail_msg_op expunge_folder_op = {
-	expunge_folder_desc,
-	expunge_folder_expunge,
-	sync_folder_synced,
-	sync_folder_free,
+static MailMsgInfo expunge_folder_info = {
+	sizeof (struct _sync_folder_msg),
+	(MailMsgDescFunc) expunge_folder_desc,
+	(MailMsgExecFunc) expunge_folder_exec,
+	(MailMsgDoneFunc) sync_folder_done,
+	(MailMsgFreeFunc) sync_folder_free
 };
 
 void
@@ -1651,31 +1602,30 @@ mail_expunge_folder(CamelFolder *folder, void (*done) (CamelFolder *folder, void
 {
 	struct _sync_folder_msg *m;
 
-	m = mail_msg_new(&expunge_folder_op, NULL, sizeof(*m));
+	m = mail_msg_new(&expunge_folder_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ******************************************************************************** */
 
 struct _empty_trash_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	EAccount *account;
 	void (*done) (EAccount *account, void *data);
 	void *data;
 };
 
-static char *empty_trash_desc(struct _mail_msg *mm, int done)
+static gchar *
+empty_trash_desc (struct _empty_trash_msg *m)
 {
 	/* FIXME after 1.4 is out and we're not in string freeze any more. */
 #if 0
-	struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
-
 	return g_strdup_printf (_("Emptying trash in \'%s\'"),
 				m->account ? m->account->name : _("Local Folders"));
 #else
@@ -1683,49 +1633,48 @@ static char *empty_trash_desc(struct _mail_msg *mm, int done)
 #endif
 }
 
-static void empty_trash_empty(struct _mail_msg *mm)
+static void
+empty_trash_exec (struct _empty_trash_msg *m)
 {
-	struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
 	const char *evolution_dir;
 	CamelFolder *trash;
 	char *uri;
 
 	if (m->account) {
-		trash = mail_tool_get_trash (m->account->source->url, FALSE, &mm->ex);
+		trash = mail_tool_get_trash (m->account->source->url, FALSE, &m->base.ex);
 	} else {
 		evolution_dir = mail_component_peek_base_directory (mail_component_peek ());
 		uri = g_strdup_printf ("mbox:%s/mail/local", evolution_dir);
-		trash = mail_tool_get_trash (uri, TRUE, &mm->ex);
+		trash = mail_tool_get_trash (uri, TRUE, &m->base.ex);
 		g_free (uri);
 	}
 
 	if (trash)
-		camel_folder_expunge (trash, &mm->ex);
+		camel_folder_expunge (trash, &m->base.ex);
 
 	camel_object_unref (trash);
 }
 
-static void empty_trash_emptied(struct _mail_msg *mm)
+static void
+empty_trash_done (struct _empty_trash_msg *m)
 {
-	struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
-
 	if (m->done)
 		m->done(m->account, m->data);
 }
 
-static void empty_trash_free(struct _mail_msg *mm)
+static void
+empty_trash_free (struct _empty_trash_msg *m)
 {
-	struct _empty_trash_msg *m = (struct _empty_trash_msg *)mm;
-
 	if (m->account)
 		g_object_unref(m->account);
 }
 
-static struct _mail_msg_op empty_trash_op = {
-	empty_trash_desc,
-	empty_trash_empty,
-	empty_trash_emptied,
-	empty_trash_free,
+static MailMsgInfo empty_trash_info = {
+	sizeof (struct _empty_trash_msg),
+	(MailMsgDescFunc) empty_trash_desc,
+	(MailMsgExecFunc) empty_trash_exec,
+	(MailMsgDoneFunc) empty_trash_done,
+	(MailMsgFreeFunc) empty_trash_free
 };
 
 void
@@ -1733,20 +1682,20 @@ mail_empty_trash(EAccount *account, void (*done) (EAccount *account, void *data)
 {
 	struct _empty_trash_msg *m;
 
-	m = mail_msg_new(&empty_trash_op, NULL, sizeof(*m));
+	m = mail_msg_new(&empty_trash_info);
 	m->account = account;
 	if (account)
 		g_object_ref(account);
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ** GET MESSAGE(s) ***************************************************** */
 
 struct _get_message_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *folder;
 	char *uid;
@@ -1756,32 +1705,28 @@ struct _get_message_msg {
 	CamelOperation *cancel;
 };
 
-static char *get_message_desc(struct _mail_msg *mm, int done)
+static gchar *
+get_message_desc (struct _get_message_msg *m)
 {
-	struct _get_message_msg *m = (struct _get_message_msg *)mm;
-
 	return g_strdup_printf(_("Retrieving message %s"), m->uid);
 }
 
-static void get_message_get(struct _mail_msg *mm)
+static void
+get_message_exec (struct _get_message_msg *m)
 {
-	struct _get_message_msg *m = (struct _get_message_msg *)mm;
-
-	m->message = camel_folder_get_message(m->folder, m->uid, &mm->ex);
+	m->message = camel_folder_get_message(m->folder, m->uid, &m->base.ex);
 }
 
-static void get_message_got(struct _mail_msg *mm)
+static void
+get_message_done (struct _get_message_msg *m)
 {
-	struct _get_message_msg *m = (struct _get_message_msg *)mm;
-
 	if (m->done)
 		m->done(m->folder, m->uid, m->message, m->data);
 }
 
-static void get_message_free(struct _mail_msg *mm)
+static void
+get_message_free (struct _get_message_msg *m)
 {
-	struct _get_message_msg *m = (struct _get_message_msg *)mm;
-
 	g_free (m->uid);
 	camel_object_unref (m->folder);
 	camel_operation_unref (m->cancel);
@@ -1790,21 +1735,22 @@ static void get_message_free(struct _mail_msg *mm)
 		camel_object_unref (m->message);
 }
 
-static struct _mail_msg_op get_message_op = {
-	get_message_desc,
-	get_message_get,
-	get_message_got,
-	get_message_free,
+static MailMsgInfo get_message_info = {
+	sizeof (struct _get_message_msg),
+	(MailMsgDescFunc) get_message_desc,
+	(MailMsgExecFunc) get_message_exec,
+	(MailMsgDoneFunc) get_message_done,
+	(MailMsgFreeFunc) get_message_free
 };
 
 void
 mail_get_message(CamelFolder *folder, const char *uid, void (*done) (CamelFolder *folder, const char *uid,
 								     CamelMimeMessage *msg, void *data),
-		 void *data, EThread *thread)
+		 void *data, MailMsgDispatchFunc dispatch)
 {
 	struct _get_message_msg *m;
 
-	m = mail_msg_new(&get_message_op, NULL, sizeof(*m));
+	m = mail_msg_new(&get_message_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->uid = g_strdup(uid);
@@ -1812,37 +1758,37 @@ mail_get_message(CamelFolder *folder, const char *uid, void (*done) (CamelFolder
 	m->done = (void (*) (CamelFolder *, const char *, CamelMimeMessage *, void *)) done;
 	m->cancel = camel_operation_new(NULL, NULL);
 
-	e_thread_put(thread, (EMsg *)m);
+	dispatch (m);
 }
 
 typedef void (*get_done)(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data, CamelException *);
 
-static void get_messagex_got(struct _mail_msg *mm)
+static void
+get_messagex_done (struct _get_message_msg *m)
 {
-	struct _get_message_msg *m = (struct _get_message_msg *)mm;
-
 	if (m->done) {
 		get_done done = (get_done)m->done;
-		done(m->folder, m->uid, m->message, m->data, &mm->ex);
+		done(m->folder, m->uid, m->message, m->data, &m->base.ex);
 	}
 }
 
-static struct _mail_msg_op get_messagex_op = {
-	get_message_desc,
-	get_message_get,
-	get_messagex_got,
-	get_message_free,
+static MailMsgInfo get_messagex_info = {
+	sizeof (struct _get_message_msg),
+	(MailMsgDescFunc) get_message_desc,
+	(MailMsgExecFunc) get_message_exec,
+	(MailMsgDoneFunc) get_messagex_done,
+	(MailMsgFreeFunc) get_message_free
 };
 
 /* This is temporary, to avoid having to rewrite everything that uses
    mail_get_message; it adds an exception argument to the callback */
 void
 mail_get_messagex(CamelFolder *folder, const char *uid, void (*done) (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data, CamelException *),
-		 void *data, EThread *thread)
+		 void *data, MailMsgDispatchFunc dispatch)
 {
 	struct _get_message_msg *m;
 
-	m = mail_msg_new(&get_messagex_op, NULL, sizeof(*m));
+	m = mail_msg_new(&get_messagex_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->uid = g_strdup(uid);
@@ -1850,13 +1796,13 @@ mail_get_messagex(CamelFolder *folder, const char *uid, void (*done) (CamelFolde
 	m->done = (void (*) (CamelFolder *, const char *, CamelMimeMessage *, void *)) done;
 	m->cancel = camel_operation_new(NULL, NULL);
 
-	e_thread_put(thread, (EMsg *)m);
+	dispatch (m);
 }
 
 /* ********************************************************************** */
 
 struct _get_messages_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *folder;
 	GPtrArray *uids;
@@ -1866,26 +1812,25 @@ struct _get_messages_msg {
 	void *data;
 };
 
-static char * get_messages_desc(struct _mail_msg *mm, int done)
+static gchar *
+get_messages_desc (struct _get_messages_msg *m)
 {
-	struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
-
 	return g_strdup_printf(ngettext("Retrieving %d message",
 					"Retrieving %d messages", m->uids->len),
 			       m->uids->len);
 }
 
-static void get_messages_get(struct _mail_msg *mm)
+static void
+get_messages_exec (struct _get_messages_msg *m)
 {
-	struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
 	int i;
 	CamelMimeMessage *message;
 
 	for (i=0; i<m->uids->len; i++) {
 		int pc = ((i+1) * 100) / m->uids->len;
 
-		message = camel_folder_get_message(m->folder, m->uids->pdata[i], &mm->ex);
-		camel_operation_progress(mm->cancel, pc);
+		message = camel_folder_get_message(m->folder, m->uids->pdata[i], &m->base.ex);
+		camel_operation_progress(m->base.cancel, pc);
 		if (message == NULL)
 			break;
 
@@ -1893,17 +1838,16 @@ static void get_messages_get(struct _mail_msg *mm)
 	}
 }
 
-static void get_messages_got(struct _mail_msg *mm)
+static void
+get_messages_done (struct _get_messages_msg *m)
 {
-	struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
-
 	if (m->done)
 		m->done(m->folder, m->uids, m->messages, m->data);
 }
 
-static void get_messages_free(struct _mail_msg *mm)
+static void
+get_messages_free (struct _get_messages_msg *m)
 {
-	struct _get_messages_msg *m = (struct _get_messages_msg *)mm;
 	int i;
 
 	em_utils_uids_free (m->uids);
@@ -1915,11 +1859,12 @@ static void get_messages_free(struct _mail_msg *mm)
 	camel_object_unref(m->folder);
 }
 
-static struct _mail_msg_op get_messages_op = {
-	get_messages_desc,
-	get_messages_get,
-	get_messages_got,
-	get_messages_free,
+static MailMsgInfo get_messages_info = {
+	sizeof (struct _get_messages_msg),
+	(MailMsgDescFunc) get_messages_desc,
+	(MailMsgExecFunc) get_messages_exec,
+	(MailMsgDoneFunc) get_messages_done,
+	(MailMsgFreeFunc) get_messages_free
 };
 
 void
@@ -1929,7 +1874,7 @@ mail_get_messages(CamelFolder *folder, GPtrArray *uids,
 {
 	struct _get_messages_msg *m;
 
-	m = mail_msg_new(&get_messages_op, NULL, sizeof(*m));
+	m = mail_msg_new(&get_messages_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->uids = uids;
@@ -1937,13 +1882,13 @@ mail_get_messages(CamelFolder *folder, GPtrArray *uids,
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	mail_msg_unordered_push (m);
 }
 
 /* ** SAVE MESSAGES ******************************************************* */
 
 struct _save_messages_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *folder;
 	GPtrArray *uids;
@@ -1952,10 +1897,9 @@ struct _save_messages_msg {
 	void *data;
 };
 
-static char *save_messages_desc(struct _mail_msg *mm, int done)
+static gchar *
+save_messages_desc (struct _save_messages_msg *m)
 {
-	struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
-
 	return g_strdup_printf(ngettext("Saving %d message",
 					"Saving %d messsages", m->uids->len),
 			       m->uids->len);
@@ -1994,9 +1938,8 @@ save_prepare_part (CamelMimePart *mime_part)
 }
 
 static void
-save_messages_save (struct _mail_msg *mm)
+save_messages_exec (struct _save_messages_msg *m)
 {
-	struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
 	CamelStreamFilter *filtered_stream;
 	CamelMimeFilterFrom *from_filter;
 	CamelStream *stream;
@@ -2013,8 +1956,8 @@ save_messages_save (struct _mail_msg *mm)
 		CamelMimeMessage *message;
 		int pc = ((i+1) * 100) / m->uids->len;
 
-		message = camel_folder_get_message(m->folder, m->uids->pdata[i], &mm->ex);
-		camel_operation_progress(mm->cancel, pc);
+		message = camel_folder_get_message(m->folder, m->uids->pdata[i], &m->base.ex);
+		camel_operation_progress(m->base.cancel, pc);
 		if (message == NULL)
 			break;
 
@@ -2026,7 +1969,7 @@ save_messages_save (struct _mail_msg *mm)
 		    || camel_stream_flush(stream) == -1
 		    || camel_data_wrapper_write_to_stream((CamelDataWrapper *)message, (CamelStream *)filtered_stream) == -1
 		    || camel_stream_flush((CamelStream *)filtered_stream) == -1) {
-			camel_exception_setv(&mm->ex, CAMEL_EXCEPTION_SYSTEM,
+			camel_exception_setv(&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
 					     _("Error saving messages to: %s:\n %s"), m->path, strerror(errno));
 			g_free(from);
 			camel_object_unref((CamelObject *)message);
@@ -2040,28 +1983,27 @@ save_messages_save (struct _mail_msg *mm)
 	camel_object_unref(stream);
 }
 
-static void save_messages_saved(struct _mail_msg *mm)
+static void
+save_messages_done (struct _save_messages_msg *m)
 {
-	struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
-
 	if (m->done)
 		m->done(m->folder, m->uids, m->path, m->data);
 }
 
-static void save_messages_free(struct _mail_msg *mm)
+static void
+save_messages_free (struct _save_messages_msg *m)
 {
-	struct _save_messages_msg *m = (struct _save_messages_msg *)mm;
-
 	em_utils_uids_free (m->uids);
 	camel_object_unref(m->folder);
 	g_free(m->path);
 }
 
-static struct _mail_msg_op save_messages_op = {
-	save_messages_desc,
-	save_messages_save,
-	save_messages_saved,
-	save_messages_free,
+static MailMsgInfo save_messages_info = {
+	sizeof (struct _save_messages_msg),
+	(MailMsgDescFunc) save_messages_desc,
+	(MailMsgExecFunc) save_messages_exec,
+	(MailMsgDoneFunc) save_messages_done,
+	(MailMsgFreeFunc) save_messages_free
 };
 
 int
@@ -2071,7 +2013,7 @@ mail_save_messages(CamelFolder *folder, GPtrArray *uids, const char *path,
 	struct _save_messages_msg *m;
 	int id;
 
-	m = mail_msg_new(&save_messages_op, NULL, sizeof(*m));
+	m = mail_msg_new(&save_messages_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->uids = uids;
@@ -2079,8 +2021,8 @@ mail_save_messages(CamelFolder *folder, GPtrArray *uids, const char *path,
 	m->data = data;
 	m->done = done;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 
 	return id;
 }
@@ -2088,7 +2030,7 @@ mail_save_messages(CamelFolder *folder, GPtrArray *uids, const char *path,
 /* ** SAVE PART ******************************************************* */
 
 struct _save_part_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelMimePart *part;
 	char *path;
@@ -2097,27 +2039,27 @@ struct _save_part_msg {
 	gboolean readonly;
 };
 
-static char *save_part_desc(struct _mail_msg *mm, int done)
+static gchar *
+save_part_desc (struct _save_part_msg *m)
 {
 	return g_strdup(_("Saving attachment"));
 }
 
 static void
-save_part_save (struct _mail_msg *mm)
+save_part_exec (struct _save_part_msg *m)
 {
-	struct _save_part_msg *m = (struct _save_part_msg *)mm;
 	CamelDataWrapper *content;
 	CamelStream *stream;
 
 	if(!m->readonly){
 		if (!(stream = camel_stream_vfs_new_with_uri (m->path, O_WRONLY | O_CREAT | O_TRUNC, 0644))) {
-			camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
+			camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
 					      _("Cannot create output file: %s:\n %s"),
 					      m->path, g_strerror (errno));
 			return;
 		}
 	} else if (!(stream = camel_stream_vfs_new_with_uri (m->path, O_WRONLY | O_CREAT | O_TRUNC, 0444))) {
-		camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
+		camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Cannot create output file: %s:\n %s"),
 				      m->path, g_strerror (errno));
 		return;
@@ -2127,7 +2069,7 @@ save_part_save (struct _mail_msg *mm)
 
 	if (camel_data_wrapper_decode_to_stream (content, stream) == -1
 	    || camel_stream_flush (stream) == -1)
-		camel_exception_setv (&mm->ex, CAMEL_EXCEPTION_SYSTEM,
+		camel_exception_setv (&m->base.ex, CAMEL_EXCEPTION_SYSTEM,
 				      _("Could not write data: %s"),
 				      g_strerror (errno));
 
@@ -2135,27 +2077,25 @@ save_part_save (struct _mail_msg *mm)
 }
 
 static void
-save_part_saved (struct _mail_msg *mm)
+save_part_done (struct _save_part_msg *m)
 {
-	struct _save_part_msg *m = (struct _save_part_msg *)mm;
-
 	if (m->done)
-		m->done (m->part, m->path, !camel_exception_is_set (&mm->ex), m->data);
+		m->done (m->part, m->path, !camel_exception_is_set (&m->base.ex), m->data);
 }
 
 static void
-save_part_free (struct _mail_msg *mm)
+save_part_free (struct _save_part_msg *m)
 {
-	struct _save_part_msg *m = (struct _save_part_msg *)mm;
 	camel_object_unref (m->part);
 	g_free (m->path);
 }
 
-static struct _mail_msg_op save_part_op = {
-	save_part_desc,
-	save_part_save,
-	save_part_saved,
-	save_part_free,
+static MailMsgInfo save_part_info = {
+	sizeof (struct _save_part_msg),
+	(MailMsgDescFunc) save_part_desc,
+	(MailMsgExecFunc) save_part_exec,
+	(MailMsgDoneFunc) save_part_done,
+	(MailMsgFreeFunc) save_part_free
 };
 
 int
@@ -2164,7 +2104,7 @@ mail_save_part (CamelMimePart *part, const char *path,
 {
 	struct _save_part_msg *m;
 	int id;
-	m = mail_msg_new (&save_part_op, NULL, sizeof (*m));
+	m = mail_msg_new (&save_part_info);
 	m->part = part;
 	camel_object_ref (part);
 	m->path = g_strdup (path);
@@ -2172,8 +2112,8 @@ mail_save_part (CamelMimePart *part, const char *path,
 	m->done = done;
 	m->readonly = readonly;
 
-	id = m->msg.seq;
-	e_thread_put (mail_thread_new, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 
 	return id;
 }
@@ -2182,7 +2122,7 @@ mail_save_part (CamelMimePart *part, const char *path,
 /* ** PREPARE OFFLINE ***************************************************** */
 
 struct _prep_offline_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelOperation *cancel;
 	char *uri;
@@ -2190,22 +2130,22 @@ struct _prep_offline_msg {
 	void *data;
 };
 
-static void prep_offline_do(struct _mail_msg *mm)
+static void
+prep_offline_exec (struct _prep_offline_msg *m)
 {
-	struct _prep_offline_msg *m = (struct _prep_offline_msg *)mm;
 	CamelFolder *folder;
 
 	if (m->cancel)
 		camel_operation_register(m->cancel);
 
-	folder = mail_tool_uri_to_folder(m->uri, 0, &mm->ex);
+	folder = mail_tool_uri_to_folder(m->uri, 0, &m->base.ex);
 	if (folder) {
 		if (CAMEL_IS_DISCO_FOLDER(folder)) {
 			camel_disco_folder_prepare_for_offline((CamelDiscoFolder *)folder,
 							       "(match-all)",
-							       &mm->ex);
+							       &m->base.ex);
 		} else if (CAMEL_IS_OFFLINE_FOLDER (folder)) {
-			camel_offline_folder_downsync ((CamelOfflineFolder *) folder, "(match-all)", &mm->ex);
+			camel_offline_folder_downsync ((CamelOfflineFolder *) folder, "(match-all)", &m->base.ex);
 		}
 		/* prepare_for_offline should do this? */
 		/* of course it should all be atomic, but ... */
@@ -2217,28 +2157,27 @@ static void prep_offline_do(struct _mail_msg *mm)
 		camel_operation_unregister(m->cancel);
 }
 
-static void prep_offline_done(struct _mail_msg *mm)
+static void
+prep_offline_done (struct _prep_offline_msg *m)
 {
-	struct _prep_offline_msg *m = (struct _prep_offline_msg *)mm;
-
 	if (m->done)
 		m->done(m->uri, m->data);
 }
 
-static void prep_offline_free(struct _mail_msg *mm)
+static void
+prep_offline_free (struct _prep_offline_msg *m)
 {
-	struct _prep_offline_msg *m = (struct _prep_offline_msg *)mm;
-
 	if (m->cancel)
 		camel_operation_unref(m->cancel);
 	g_free(m->uri);
 }
 
-static struct _mail_msg_op prep_offline_op = {
-	NULL, /* DO NOT CHANGE THIS, IT MUST BE NULL FOR CANCELLATION TO WORK */
-	prep_offline_do,
-	prep_offline_done,
-	prep_offline_free,
+static MailMsgInfo prep_offline_info = {
+	sizeof (struct _prep_offline_msg),
+	(MailMsgDescFunc) NULL, /* DO NOT CHANGE THIS, IT MUST BE NULL FOR CANCELLATION TO WORK */
+	(MailMsgExecFunc) prep_offline_exec,
+	(MailMsgDoneFunc) prep_offline_done,
+	(MailMsgFreeFunc) prep_offline_free
 };
 
 void
@@ -2249,7 +2188,7 @@ mail_prep_offline(const char *uri,
 {
 	struct _prep_offline_msg *m;
 
-	m = mail_msg_new(&prep_offline_op, NULL, sizeof(*m));
+	m = mail_msg_new(&prep_offline_info);
 	m->cancel = cancel;
 	if (cancel)
 		camel_operation_ref(cancel);
@@ -2257,13 +2196,13 @@ mail_prep_offline(const char *uri,
 	m->data = data;
 	m->done = done;
 
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	mail_msg_slow_ordered_push (m);
 }
 
 /* ** GO OFFLINE ***************************************************** */
 
 struct _set_offline_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelStore *store;
 	gboolean offline;
@@ -2271,9 +2210,9 @@ struct _set_offline_msg {
 	void *data;
 };
 
-static char *set_offline_desc(struct _mail_msg *mm, int done)
+static gchar *
+set_offline_desc (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
 	char *service_name = camel_service_get_name (CAMEL_SERVICE (m->store), TRUE);
 	char *msg;
 
@@ -2283,61 +2222,59 @@ static char *set_offline_desc(struct _mail_msg *mm, int done)
 	return msg;
 }
 
-static void set_offline_do(struct _mail_msg *mm)
+static void
+set_offline_exec (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
-
 	if (CAMEL_IS_DISCO_STORE (m->store)) {
 		if (!m->offline) {
 			camel_disco_store_set_status (CAMEL_DISCO_STORE (m->store),
 						      CAMEL_DISCO_STORE_ONLINE,
-						      &mm->ex);
+						      &m->base.ex);
 			return;
 		} else if (camel_disco_store_can_work_offline (CAMEL_DISCO_STORE (m->store))) {
 			camel_disco_store_set_status (CAMEL_DISCO_STORE (m->store),
 						      CAMEL_DISCO_STORE_OFFLINE,
-						      &mm->ex);
+						      &m->base.ex);
 			return;
 		}
 	} else if (CAMEL_IS_OFFLINE_STORE (m->store)) {
 		if (!m->offline) {
 			camel_offline_store_set_network_state (CAMEL_OFFLINE_STORE (m->store),
 							       CAMEL_OFFLINE_STORE_NETWORK_AVAIL,
-							       &mm->ex);
+							       &m->base.ex);
 			return;
 		} else {
 			camel_offline_store_set_network_state (CAMEL_OFFLINE_STORE (m->store),
 							       CAMEL_OFFLINE_STORE_NETWORK_UNAVAIL,
-							       &mm->ex);
+							       &m->base.ex);
 			return;
 		}
 	}
 
 	if (m->offline)
 		camel_service_disconnect (CAMEL_SERVICE (m->store),
-					  TRUE, &mm->ex);
+					  TRUE, &m->base.ex);
 }
 
-static void set_offline_done(struct _mail_msg *mm)
+static void
+set_offline_done (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
-
 	if (m->done)
 		m->done(m->store, m->data);
 }
 
-static void set_offline_free(struct _mail_msg *mm)
+static void
+set_offline_free (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
-
 	camel_object_unref(m->store);
 }
 
-static struct _mail_msg_op set_offline_op = {
-	set_offline_desc,
-	set_offline_do,
-	set_offline_done,
-	set_offline_free,
+static MailMsgInfo set_offline_info = {
+	sizeof (struct _set_offline_msg),
+	(MailMsgDescFunc) set_offline_desc,
+	(MailMsgExecFunc) set_offline_exec,
+	(MailMsgDoneFunc) set_offline_done,
+	(MailMsgFreeFunc) set_offline_free
 };
 
 int
@@ -2354,61 +2291,59 @@ mail_store_set_offline (CamelStore *store, gboolean offline,
 	if (offline)
 		camel_service_cancel_connect (CAMEL_SERVICE (store));
 
-	m = mail_msg_new(&set_offline_op, NULL, sizeof(*m));
+	m = mail_msg_new(&set_offline_info);
 	m->store = store;
 	camel_object_ref(store);
 	m->offline = offline;
 	m->data = data;
 	m->done = done;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 
 	return id;
 }
 
 /* ** Prepare OFFLINE ***************************************************** */
 
-static char *prepare_offline_desc(struct _mail_msg *mm, int done)
+static char *
+prepare_offline_desc (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
 	char *service_name = camel_service_get_name (CAMEL_SERVICE (m->store), TRUE);
 	char *msg;
 
-	msg = g_strdup_printf(_("Preparing account '%s' for offline"), service_name);
+	msg = g_strdup_printf (_("Preparing account '%s' for offline"), service_name);
 	g_free(service_name);
 
 	return msg;
 }
 
-static void prepare_offline_do(struct _mail_msg *mm)
+static void
+prepare_offline_exec (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
-
 	camel_disco_store_prepare_for_offline (CAMEL_DISCO_STORE (m->store),
-				      	       &mm->ex);
+				      	       &m->base.ex);
 }
 
-static void prepare_offline_done(struct _mail_msg *mm)
+static void
+prepare_offline_done (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
-
 	if (m->done)
-		m->done(m->store, m->data);
+		m->done (m->store, m->data);
 }
 
-static void prepare_offline_free(struct _mail_msg *mm)
+static void
+prepare_offline_free (struct _set_offline_msg *m)
 {
-	struct _set_offline_msg *m = (struct _set_offline_msg *)mm;
-
-	camel_object_unref(m->store);
+	camel_object_unref (m->store);
 }
 
-static struct _mail_msg_op prepare_offline_op = {
-	prepare_offline_desc,
-	prepare_offline_do,
-	prepare_offline_done,
-	prepare_offline_free,
+static MailMsgInfo prepare_offline_info = {
+	sizeof (struct _set_offline_msg),
+	(MailMsgDescFunc) prepare_offline_desc,
+	(MailMsgExecFunc) prepare_offline_exec,
+	(MailMsgDoneFunc) prepare_offline_done,
+	(MailMsgFreeFunc) prepare_offline_free
 };
 
 int
@@ -2421,14 +2356,14 @@ mail_store_prepare_offline (CamelStore *store)
 	 * thread won't get queued behind a hung connect op.
 	 */
 
-	m = mail_msg_new(&prepare_offline_op, NULL, sizeof(*m));
+	m = mail_msg_new(&prepare_offline_info);
 	m->store = store;
 	camel_object_ref(store);
 	m->data = NULL;
 	m->done = NULL;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 
 	return id;
 }
@@ -2445,7 +2380,7 @@ mail_execute_shell_command (CamelFilterDriver *driver, int argc, char **argv, vo
 
 /* Async service-checking/authtype-lookup code. */
 struct _check_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	char *url;
 	CamelProviderType type;
@@ -2455,51 +2390,47 @@ struct _check_msg {
 	void *data;
 };
 
-static char *
-check_service_describe(struct _mail_msg *mm, int complete)
+static gchar *
+check_service_desc (struct _check_msg *m)
 {
 	return g_strdup(_("Checking Service"));
 }
 
 static void
-check_service_check(struct _mail_msg *mm)
+check_service_exec (struct _check_msg *m)
 {
-	struct _check_msg *m = (struct _check_msg *)mm;
 	CamelService *service;
 
-	service = camel_session_get_service(session, m->url, m->type, &mm->ex);
+	service = camel_session_get_service(session, m->url, m->type, &m->base.ex);
 	if (!service) {
-		camel_operation_unregister(mm->cancel);
+		camel_operation_unregister(m->base.cancel);
 		return;
 	}
 
-	m->authtypes = camel_service_query_auth_types(service, &mm->ex);
+	m->authtypes = camel_service_query_auth_types(service, &m->base.ex);
 	camel_object_unref(service);
 }
 
 static void
-check_service_done(struct _mail_msg *mm)
+check_service_done (struct _check_msg *m)
 {
-	struct _check_msg *m = (struct _check_msg *)mm;
-
 	if (m->done)
 		m->done(m->url, m->type, m->authtypes, m->data);
 }
 
 static void
-check_service_free(struct _mail_msg *mm)
+check_service_free (struct _check_msg *m)
 {
-	struct _check_msg *m = (struct _check_msg *)mm;
-
 	g_free(m->url);
 	g_list_free(m->authtypes);
 }
 
-static struct _mail_msg_op check_service_op = {
-	check_service_describe,
-	check_service_check,
-	check_service_done,
-	check_service_free,
+static MailMsgInfo check_service_info = {
+	sizeof (struct _check_msg),
+	(MailMsgDescFunc) check_service_desc,
+	(MailMsgExecFunc) check_service_exec,
+	(MailMsgDoneFunc) check_service_done,
+	(MailMsgFreeFunc) check_service_free
 };
 
 int
@@ -2508,14 +2439,14 @@ mail_check_service(const char *url, CamelProviderType type, void (*done)(const c
 	struct _check_msg *m;
 	int id;
 
-	m = mail_msg_new (&check_service_op, NULL, sizeof(*m));
+	m = mail_msg_new (&check_service_info);
 	m->url = g_strdup(url);
 	m->type = type;
 	m->done = done;
 	m->data = data;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_new, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_unordered_push (m);
 
 	return id;
 }
diff --git a/mail/mail-ops.h b/mail/mail-ops.h
index 18fca3be5c..e23e775645 100644
--- a/mail/mail-ops.h
+++ b/mail/mail-ops.h
@@ -30,13 +30,14 @@ extern "C" {
 #pragma }
 #endif /* __cplusplus */
 
+#include "mail-mt.h"
+
 #include "camel/camel-store.h"
 #include "camel/camel-folder.h"
 #include "camel/camel-filter-driver.h"
 #include "camel/camel-mime-message.h"
 #include "camel/camel-operation.h"
 
-#include "libedataserver/e-msgport.h"
 #include "libedataserver/e-account.h"
 
 void mail_append_mail (CamelFolder *folder, CamelMimeMessage *message, CamelMessageInfo *info,
@@ -55,12 +56,12 @@ void mail_transfer_messages (CamelFolder *source, GPtrArray *uids,
 void mail_get_message (CamelFolder *folder, const char *uid,
 		       void (*done) (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data),
 		       void *data,
-		       EThread *thread);
+		       MailMsgDispatchFunc dispatch);
 
 void
 mail_get_messagex(CamelFolder *folder, const char *uid,
 		  void (*done) (CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *data, CamelException *),
-		  void *data, EThread *thread);
+		  void *data, MailMsgDispatchFunc dispatch);
 
 /* get several messages */
 void mail_get_messages (CamelFolder *folder, GPtrArray *uids,
@@ -70,7 +71,7 @@ void mail_get_messages (CamelFolder *folder, GPtrArray *uids,
 /* same for a folder */
 int mail_get_folder (const char *uri, guint32 flags,
 		     void (*done) (char *uri, CamelFolder *folder, void *data), void *data,
-		     EThread *thread);
+		     MailMsgDispatchFunc dispatch);
 
 /* and for a store */
 int mail_get_store (const char *uri, CamelOperation *op,
diff --git a/mail/mail-send-recv.c b/mail/mail-send-recv.c
index 9c20da4634..6cead72700 100644
--- a/mail/mail-send-recv.c
+++ b/mail/mail-send-recv.c
@@ -779,23 +779,22 @@ receive_get_folder(CamelFilterDriver *d, const char *uri, void *data, CamelExcep
 /* ********************************************************************** */
 
 struct _refresh_folders_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	struct _send_info *info;
 	GPtrArray *folders;
 	CamelStore *store;
 };
 
-static char *
-refresh_folders_desc (struct _mail_msg *mm, int done)
+static gchar *
+refresh_folders_desc (struct _refresh_folders_msg *m)
 {
 	return g_strdup_printf(_("Checking for new mail"));
 }
 
 static void
-refresh_folders_get (struct _mail_msg *mm)
+refresh_folders_exec (struct _refresh_folders_msg *m)
 {
-	struct _refresh_folders_msg *m = (struct _refresh_folders_msg *)mm;
 	int i;
 	CamelFolder *folder;
 	CamelException ex = CAMEL_EXCEPTION_INITIALISER;
@@ -817,17 +816,14 @@ refresh_folders_get (struct _mail_msg *mm)
 }
 
 static void
-refresh_folders_got (struct _mail_msg *mm)
+refresh_folders_done (struct _refresh_folders_msg *m)
 {
-	struct _refresh_folders_msg *m = (struct _refresh_folders_msg *)mm;
-
 	receive_done("", m->info);
 }
 
 static void
-refresh_folders_free (struct _mail_msg *mm)
+refresh_folders_free (struct _refresh_folders_msg *m)
 {
-	struct _refresh_folders_msg *m = (struct _refresh_folders_msg *)mm;
 	int i;
 
 	for (i=0;i<m->folders->len;i++)
@@ -836,11 +832,12 @@ refresh_folders_free (struct _mail_msg *mm)
 	camel_object_unref(m->store);
 }
 
-static struct _mail_msg_op refresh_folders_op = {
-	refresh_folders_desc,
-	refresh_folders_get,
-	refresh_folders_got,
-	refresh_folders_free,
+static MailMsgInfo refresh_folders_info = {
+	sizeof (struct _refresh_folders_msg),
+	(MailMsgDescFunc) refresh_folders_desc,
+	(MailMsgExecFunc) refresh_folders_exec,
+	(MailMsgDoneFunc) refresh_folders_done,
+	(MailMsgFreeFunc) refresh_folders_free
 };
 
 static void
@@ -870,13 +867,13 @@ receive_update_got_folderinfo(CamelStore *store, CamelFolderInfo *info, void *da
 
 		get_folders(store, folders, info);
 
-		m = mail_msg_new(&refresh_folders_op, NULL, sizeof(*m));
+		m = mail_msg_new(&refresh_folders_info);
 		m->store = store;
 		camel_object_ref(store);
 		m->folders = folders;
 		m->info = sinfo;
 
-		e_thread_put(mail_thread_new, (EMsg *)m);
+		mail_msg_unordered_push (m);
 	} else {
 		receive_done ("", data);
 	}
diff --git a/mail/mail-session.c b/mail/mail-session.c
index c833b6a849..6dd7d5a8cd 100644
--- a/mail/mail-session.c
+++ b/mail/mail-session.c
@@ -35,7 +35,7 @@
 #include <libgnome/gnome-sound.h>
 
 #include <libedataserverui/e-passwords.h>
-#include <libedataserver/e-msgport.h>
+#include <libedataserver/e-flag.h>
 
 #include <camel/camel.h>	/* FIXME: this is where camel_init is defined, it shouldn't include everything else */
 #include <camel/camel-filter-driver.h>
@@ -265,21 +265,22 @@ forget_password (CamelSession *session, CamelService *service, const char *domai
 
 /* ********************************************************************** */
 
-static GtkDialog *message_dialog;
-static EDList message_list = E_DLIST_INITIALISER(message_list);
+static gpointer user_message_dialog;
+static GQueue user_message_queue = { NULL, NULL, 0 };
 
 struct _user_message_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelSessionAlertType type;
 	char *prompt;
+	EFlag *done;
 
 	unsigned int allow_cancel:1;
 	unsigned int result:1;
 	unsigned int ismain:1;
 };
 
-static void do_user_message (struct _mail_msg *mm);
+static void user_message_exec (struct _user_message_msg *m);
 
 /* clicked, send back the reply */
 static void
@@ -287,126 +288,122 @@ user_message_response (GtkDialog *dialog, int button, struct _user_message_msg *
 {
 	gtk_widget_destroy ((GtkWidget *) dialog);
 
-	message_dialog = NULL;
+	user_message_dialog = NULL;
 
 	/* if !allow_cancel, then we've already replied */
 	if (m->allow_cancel) {
 		m->result = button == GTK_RESPONSE_OK;
-		e_msgport_reply((EMsg *)m);
+		e_flag_set (m->done);
 	}
 
 	/* check for pendings */
-	if ((m = (struct _user_message_msg *)e_dlist_remhead(&message_list)))
-		do_user_message((struct _mail_msg *)m);
+	if (!g_queue_is_empty (&user_message_queue)) {
+		m = g_queue_pop_head (&user_message_queue);
+		user_message_exec (m);
+		mail_msg_unref (m);
+	}
 }
 
 static void
-user_message_destroy_notify (struct _user_message_msg *m, GObject *deadbeef)
+user_message_exec (struct _user_message_msg *m)
 {
-	message_dialog = NULL;
-}
-
-/* This is kinda ugly/inefficient, but oh well, it works */
-static const char *error_type[] = {
-	"mail:session-message-info", "mail:session-message-warning", "mail:session-message-error",
-	"mail:session-message-info-cancel", "mail:session-message-warning-cancel", "mail:session-message-error-cancel"
-};
+	const gchar *error_type;
 
-static void
-do_user_message (struct _mail_msg *mm)
-{
-	struct _user_message_msg *m = (struct _user_message_msg *)mm;
-	int type;
-
-	if (!m->ismain && message_dialog != NULL) {
-		e_dlist_addtail (&message_list, (EDListNode *)m);
+	if (!m->ismain && user_message_dialog != NULL) {
+		g_queue_push_tail (&user_message_queue, mail_msg_ref (m));
 		return;
 	}
 
 	switch (m->type) {
-	case CAMEL_SESSION_ALERT_INFO:
-		type = 0;
-		break;
-	case CAMEL_SESSION_ALERT_WARNING:
-		type = 1;
-		break;
-	case CAMEL_SESSION_ALERT_ERROR:
-		type = 2;
-		break;
-	default:
-		type = 0;
+		case CAMEL_SESSION_ALERT_INFO:
+			error_type = m->allow_cancel ?
+				"mail:session-message-info-cancel" :
+				"mail:session-message-info";
+			break;
+		case CAMEL_SESSION_ALERT_WARNING:
+			error_type = m->allow_cancel ?
+				"mail:session-message-warning-cancel" :
+				"mail:session-message-warning";
+			break;
+		case CAMEL_SESSION_ALERT_ERROR:
+			error_type = m->allow_cancel ?
+				"mail:session-message-error-cancel" :
+				"mail:session-message-error";
+			break;
+		default:
+			g_assert_not_reached ();
 	}
 
-	if (m->allow_cancel)
-		type += 3;
-
-	message_dialog = (GtkDialog *)e_error_new(NULL, error_type[type], m->prompt, NULL);
-	g_object_set ((GObject *) message_dialog, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
+	user_message_dialog = e_error_new (NULL, error_type, m->prompt, NULL);
+	g_object_set (
+		user_message_dialog, "allow_shrink", TRUE,
+		"allow_grow", TRUE, NULL);
 
-	/* We only need to wait for the result if we allow cancel otherwise show but send result back instantly */
-	if (m->allow_cancel) {
-		if (m->ismain) {
-			user_message_response(message_dialog, gtk_dialog_run (message_dialog), m);
-		} else {
-			g_signal_connect (message_dialog, "response", G_CALLBACK (user_message_response), m);
-			gtk_widget_show ((GtkWidget *) message_dialog);
-		}
+	/* We only need to wait for the result if we allow cancel
+	 * otherwise show but send result back instantly */
+	if (m->allow_cancel && m->ismain) {
+		gint response = gtk_dialog_run (user_message_dialog);
+		user_message_response (user_message_dialog, response, m);
 	} else {
-		g_signal_connect (message_dialog, "response", G_CALLBACK (gtk_widget_destroy), message_dialog);
-		g_object_weak_ref ((GObject *) message_dialog, (GWeakNotify) user_message_destroy_notify, m);
-		gtk_widget_show ((GtkWidget *) message_dialog);
-		mail_msg_free(m);
+		g_signal_connect (
+			user_message_dialog, "response",
+			G_CALLBACK (user_message_response), m);
+		gtk_widget_show (user_message_dialog);
 	}
 }
 
 static void
-free_user_message(struct _mail_msg *mm)
+user_message_free (struct _user_message_msg *m)
 {
-	struct _user_message_msg *m = (struct _user_message_msg *)mm;
-
 	g_free(m->prompt);
+	e_flag_free(m->done);
 }
 
-static struct _mail_msg_op user_message_op = { NULL, do_user_message, NULL, free_user_message };
+static MailMsgInfo user_message_info = {
+	sizeof (struct _user_message_msg),
+	(MailMsgDescFunc) NULL,
+	(MailMsgExecFunc) user_message_exec,
+	(MailMsgDoneFunc) NULL,
+	(MailMsgFreeFunc) user_message_free
+};
 
 static gboolean
 alert_user(CamelSession *session, CamelSessionAlertType type, const char *prompt, gboolean cancel)
 {
 	MailSession *mail_session = MAIL_SESSION (session);
-	struct _user_message_msg *m, *r;
-	EMsgPort *user_message_reply = NULL;
-	gboolean ret;
+	struct _user_message_msg *m;
+	gboolean result = TRUE;
 
 	if (!mail_session->interactive)
 		return FALSE;
 
-	if (cancel)
-		user_message_reply = e_msgport_new ();
-	m = mail_msg_new (&user_message_op, user_message_reply, sizeof (*m));
-	m->ismain = pthread_equal(pthread_self(), mail_gui_thread);
+	m = mail_msg_new (&user_message_info);
+	m->ismain = mail_in_main_thread ();
 	m->type = type;
-	m->prompt = g_strdup(prompt);
+	m->prompt = g_strdup (prompt);
+	m->done = e_flag_new ();
 	m->allow_cancel = cancel;
 
-	if (m->ismain)
-		do_user_message((struct _mail_msg *)m);
-	else {
-		extern EMsgPort *mail_gui_port2;
+	if (cancel)
+		mail_msg_ref (m);
 
-		e_msgport_put(mail_gui_port2, (EMsg *)m);
-	}
+	if (m->ismain)
+		user_message_exec (m);
+	else
+		mail_msg_main_loop_push (m);
 
 	if (cancel) {
-		r = (struct _user_message_msg *)e_msgport_wait(user_message_reply);
-		g_return_val_if_fail (m == r, FALSE);
+		e_flag_wait (m->done);
+		result = m->result;
+		mail_msg_unref (m);
+	}
 
-		ret = m->result;
-		mail_msg_free(m);
-		e_msgport_destroy(user_message_reply);
-	} else
-		ret = TRUE;
+	if (m->ismain) {
+		user_message_free (m);
+		mail_msg_unref (m);
+	}
 
-	return ret;
+	return result;
 }
 
 static CamelFolder *
@@ -542,7 +539,7 @@ get_filter_driver (CamelSession *session, const char *type, CamelException *ex)
 /* TODO: This is very temporary, until we have a better way to do the progress reporting,
    we just borrow a dummy mail-mt thread message and hook it onto out camel thread message */
 
-static mail_msg_op_t ms_thread_ops_dummy = { NULL };
+static MailMsgInfo ms_thread_info_dummy = { sizeof (MailMsg) };
 
 static void *ms_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops, unsigned int size)
 {
@@ -551,7 +548,7 @@ static void *ms_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops
 	/* We create a dummy mail_msg, and then copy its cancellation port over to ours, so
 	   we get cancellation and progress in common with hte existing mail code, for free */
 	if (msg) {
-		struct _mail_msg *m = mail_msg_new(&ms_thread_ops_dummy, NULL, sizeof(struct _mail_msg));
+		MailMsg *m = mail_msg_new(&ms_thread_info_dummy);
 
 		msg->data = m;
 		camel_operation_unref(msg->op);
@@ -564,7 +561,7 @@ static void *ms_thread_msg_new(CamelSession *session, CamelSessionThreadOps *ops
 
 static void ms_thread_msg_free(CamelSession *session, CamelSessionThreadMsg *m)
 {
-	mail_msg_free(m->data);
+	mail_msg_unref(m->data);
 	ms_parent_class->thread_msg_free(session, m);
 }
 
@@ -689,22 +686,23 @@ mail_session_set_interactive (gboolean interactive)
 	MAIL_SESSION (session)->interactive = interactive;
 
 	if (!interactive) {
-		struct _user_message_msg *um;
+		struct _user_message_msg *msg;
 
 		d(printf ("Gone non-interactive, checking for outstanding interactive tasks\n"));
 
 		e_passwords_cancel();
 
 		/* flush/cancel pending user messages */
-		while ((um = (struct _user_message_msg *) e_dlist_remhead (&message_list))) {
-			d(printf ("Flusing message request: %s\n", um->prompt));
-			e_msgport_reply((EMsg *) um);
+		while (!g_queue_is_empty (&user_message_queue)) {
+			msg = g_queue_pop_head (&user_message_queue);
+			e_flag_set (msg->done);
+			mail_msg_unref (msg);
 		}
 
 		/* and the current */
-		if (message_dialog) {
+		if (user_message_dialog) {
 			d(printf("Destroying message dialogue\n"));
-			gtk_widget_destroy ((GtkWidget *) message_dialog);
+			gtk_widget_destroy ((GtkWidget *) user_message_dialog);
 		}
 	}
 }
diff --git a/mail/mail-vfolder.c b/mail/mail-vfolder.c
index 9f4b8e2d94..6397ca772a 100644
--- a/mail/mail-vfolder.c
+++ b/mail/mail-vfolder.c
@@ -21,7 +21,7 @@
  */
 
 #include <config.h>
-
+#include <pthread.h>
 #include <string.h>
 
 #include <glib.h>
@@ -75,7 +75,7 @@ static void rule_changed(FilterRule *rule, CamelFolder *folder);
 /* ********************************************************************** */
 
 struct _setup_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	CamelFolder *folder;
 	char *query;
@@ -83,18 +83,15 @@ struct _setup_msg {
 	GList *sources_folder;
 };
 
-static char *
-vfolder_setup_desc(struct _mail_msg *mm, int done)
+static gchar *
+vfolder_setup_desc (struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
-
 	return g_strdup_printf(_("Setting up Search Folder: %s"), m->folder->full_name);
 }
 
 static void
-vfolder_setup_do(struct _mail_msg *mm)
+vfolder_setup_exec (struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
 	GList *l, *list = NULL;
 	CamelFolder *folder;
 
@@ -105,12 +102,12 @@ vfolder_setup_do(struct _mail_msg *mm)
 	l = m->sources_uri;
 	while (l && !shutdown) {
 		d(printf(" Adding uri: %s\n", (char *)l->data));
-		folder = mail_tool_uri_to_folder (l->data, 0, &mm->ex);
+		folder = mail_tool_uri_to_folder (l->data, 0, &m->base.ex);
 		if (folder) {
 			list = g_list_append(list, folder);
 		} else {
 			g_warning("Could not open vfolder source: %s", (char *)l->data);
-			camel_exception_clear(&mm->ex);
+			camel_exception_clear(&m->base.ex);
 		}
 		l = l->next;
 	}
@@ -135,17 +132,13 @@ vfolder_setup_do(struct _mail_msg *mm)
 }
 
 static void
-vfolder_setup_done(struct _mail_msg *mm)
+vfolder_setup_done (struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
-
-	m = m;
 }
 
 static void
-vfolder_setup_free (struct _mail_msg *mm)
+vfolder_setup_free (struct _setup_msg *m)
 {
-	struct _setup_msg *m = (struct _setup_msg *)mm;
 	GList *l;
 
 	camel_object_unref(m->folder);
@@ -166,11 +159,12 @@ vfolder_setup_free (struct _mail_msg *mm)
 	g_list_free(m->sources_folder);
 }
 
-static struct _mail_msg_op vfolder_setup_op = {
-	vfolder_setup_desc,
-	vfolder_setup_do,
-	vfolder_setup_done,
-	vfolder_setup_free,
+static MailMsgInfo vfolder_setup_info = {
+	sizeof (struct _setup_msg),
+	(MailMsgDescFunc) vfolder_setup_desc,
+	(MailMsgExecFunc) vfolder_setup_exec,
+	(MailMsgDoneFunc) vfolder_setup_done,
+	(MailMsgFreeFunc) vfolder_setup_free
 };
 
 /* sources_uri should be camel uri's */
@@ -180,15 +174,15 @@ vfolder_setup(CamelFolder *folder, const char *query, GList *sources_uri, GList
 	struct _setup_msg *m;
 	int id;
 
-	m = mail_msg_new(&vfolder_setup_op, NULL, sizeof (*m));
+	m = mail_msg_new(&vfolder_setup_info);
 	m->folder = folder;
 	camel_object_ref(folder);
 	m->query = g_strdup(query);
 	m->sources_uri = sources_uri;
 	m->sources_folder = sources_folder;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_slow_ordered_push (m);
 
 	return id;
 }
@@ -196,17 +190,16 @@ vfolder_setup(CamelFolder *folder, const char *query, GList *sources_uri, GList
 /* ********************************************************************** */
 
 struct _adduri_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	char *uri;
 	GList *folders;
 	int remove;
 };
 
-static char *
-vfolder_adduri_desc(struct _mail_msg *mm, int done)
+static gchar *
+vfolder_adduri_desc (struct _adduri_msg *m)
 {
-	struct _adduri_msg *m = (struct _adduri_msg *)mm;
 	char *euri, *desc = NULL;
 
 	/* Yuck yuck.  Lookup the account name and use that to describe the path */
@@ -250,9 +243,8 @@ vfolder_adduri_desc(struct _mail_msg *mm, int done)
 }
 
 static void
-vfolder_adduri_do(struct _mail_msg *mm)
+vfolder_adduri_exec (struct _adduri_msg *m)
 {
-	struct _adduri_msg *m = (struct _adduri_msg *)mm;
 	GList *l;
 	CamelFolder *folder = NULL;
 
@@ -269,7 +261,7 @@ vfolder_adduri_do(struct _mail_msg *mm)
 	}
 
 	if (folder == NULL)
-		folder = mail_tool_uri_to_folder (m->uri, 0, &mm->ex);
+		folder = mail_tool_uri_to_folder (m->uri, 0, &m->base.ex);
 
 	if (folder != NULL) {
 		l = m->folders;
@@ -285,28 +277,24 @@ vfolder_adduri_do(struct _mail_msg *mm)
 }
 
 static void
-vfolder_adduri_done(struct _mail_msg *mm)
+vfolder_adduri_done(struct _adduri_msg *m)
 {
-	struct _adduri_msg *m = (struct _adduri_msg *)mm;
-
-	m = m;
 }
 
 static void
-vfolder_adduri_free (struct _mail_msg *mm)
+vfolder_adduri_free (struct _adduri_msg *m)
 {
-	struct _adduri_msg *m = (struct _adduri_msg *)mm;
-
 	g_list_foreach(m->folders, (GFunc)camel_object_unref, NULL);
 	g_list_free(m->folders);
 	g_free(m->uri);
 }
 
-static struct _mail_msg_op vfolder_adduri_op = {
-	vfolder_adduri_desc,
-	vfolder_adduri_do,
-	vfolder_adduri_done,
-	vfolder_adduri_free,
+static MailMsgInfo vfolder_adduri_info = {
+	sizeof (struct _adduri_msg),
+	(MailMsgDescFunc) vfolder_adduri_desc,
+	(MailMsgExecFunc) vfolder_adduri_exec,
+	(MailMsgDoneFunc) vfolder_adduri_done,
+	(MailMsgFreeFunc) vfolder_adduri_free
 };
 
 
@@ -317,13 +305,13 @@ vfolder_adduri(const char *uri, GList *folders, int remove)
 	struct _adduri_msg *m;
 	int id;
 
-	m = mail_msg_new(&vfolder_adduri_op, NULL, sizeof (*m));
+	m = mail_msg_new(&vfolder_adduri_info);
 	m->folders = folders;
 	m->uri = g_strdup(uri);
 	m->remove = remove;
 
-	id = m->msg.seq;
-	e_thread_put(mail_thread_queued_slow, (EMsg *)m);
+	id = m->base.seq;
+	mail_msg_slow_ordered_push (m);
 
 	return id;
 }
@@ -447,7 +435,7 @@ mail_vfolder_add_uri(CamelStore *store, const char *curi, int remove)
 		return;
 	}
 
-	g_return_if_fail (pthread_equal(pthread_self(), mail_gui_thread));
+	g_return_if_fail (mail_in_main_thread());
 
 	is_ignore = uri_is_ignore(store, curi);
 
@@ -543,7 +531,7 @@ mail_vfolder_delete_uri(CamelStore *store, const char *curi)
 
 	d(printf ("Deleting uri to check: %s\n", uri));
 
-	g_return_if_fail (pthread_equal(pthread_self(), mail_gui_thread));
+	g_return_if_fail (mail_in_main_thread());
 
 	changed = g_string_new ("");
 
@@ -627,7 +615,7 @@ mail_vfolder_rename_uri(CamelStore *store, const char *cfrom, const char *cto)
 	if (context == NULL || uri_is_spethal(store, cfrom) || uri_is_spethal(store, cto))
 		return;
 
-	g_return_if_fail (pthread_equal(pthread_self(), mail_gui_thread));
+	g_return_if_fail (mail_in_main_thread());
 
 	from = em_uri_from_camel(cfrom);
 	to = em_uri_from_camel(cto);
diff --git a/mail/message-list.c b/mail/message-list.c
index 9b76441418..94f60a18ae 100644
--- a/mail/message-list.c
+++ b/mail/message-list.c
@@ -1942,7 +1942,7 @@ ml_tree_drag_data_get (ETree *tree, int row, ETreePath path, int col,
 /* TODO: merge this with the folder tree stuff via empopup targets */
 /* Drop handling */
 struct _drop_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	GdkDragContext *context;
 
@@ -1959,11 +1959,9 @@ struct _drop_msg {
 	unsigned int aborted:1;
 };
 
-static char *
-ml_drop_async_desc (struct _mail_msg *mm, int done)
+static gchar *
+ml_drop_async_desc (struct _drop_msg *m)
 {
-	struct _drop_msg *m = (struct _drop_msg *) mm;
-
 	if (m->move)
 		return g_strdup_printf(_("Moving messages into folder %s"), m->folder->full_name);
 	else
@@ -1971,13 +1969,11 @@ ml_drop_async_desc (struct _mail_msg *mm, int done)
 }
 
 static void
-ml_drop_async_drop(struct _mail_msg *mm)
+ml_drop_async_exec (struct _drop_msg *m)
 {
-	struct _drop_msg *m = (struct _drop_msg *)mm;
-
 	switch (m->info) {
 	case DND_X_UID_LIST:
-		em_utils_selection_get_uidlist(m->selection, m->folder, m->action == GDK_ACTION_MOVE, &mm->ex);
+		em_utils_selection_get_uidlist(m->selection, m->folder, m->action == GDK_ACTION_MOVE, &m->base.ex);
 		break;
 	case DND_MESSAGE_RFC822:
 		em_utils_selection_get_message(m->selection, m->folder);
@@ -1989,9 +1985,8 @@ ml_drop_async_drop(struct _mail_msg *mm)
 }
 
 static void
-ml_drop_async_done(struct _mail_msg *mm)
+ml_drop_async_done (struct _drop_msg *m)
 {
-	struct _drop_msg *m = (struct _drop_msg *)mm;
 	gboolean success, delete;
 
 	/* ?? */
@@ -1999,7 +1994,7 @@ ml_drop_async_done(struct _mail_msg *mm)
 		success = FALSE;
 		delete = FALSE;
 	} else {
-		success = !camel_exception_is_set (&mm->ex);
+		success = !camel_exception_is_set (&m->base.ex);
 		delete = success && m->move && !m->moved;
 	}
 
@@ -2007,10 +2002,8 @@ ml_drop_async_done(struct _mail_msg *mm)
 }
 
 static void
-ml_drop_async_free(struct _mail_msg *mm)
+ml_drop_async_free (struct _drop_msg *m)
 {
-	struct _drop_msg *m = (struct _drop_msg *)mm;
-
 	g_object_unref(m->context);
 	camel_object_unref(m->folder);
 
@@ -2018,18 +2011,19 @@ ml_drop_async_free(struct _mail_msg *mm)
 	g_free(m->selection);
 }
 
-static struct _mail_msg_op ml_drop_async_op = {
-	ml_drop_async_desc,
-	ml_drop_async_drop,
-	ml_drop_async_done,
-	ml_drop_async_free,
+static MailMsgInfo ml_drop_async_info = {
+	sizeof (struct _drop_msg),
+	(MailMsgDescFunc) ml_drop_async_desc,
+	(MailMsgExecFunc) ml_drop_async_exec,
+	(MailMsgDoneFunc) ml_drop_async_done,
+	(MailMsgFreeFunc) ml_drop_async_free
 };
 
 static void
 ml_drop_action(struct _drop_msg *m)
 {
 	m->move = m->action == GDK_ACTION_MOVE;
-	e_thread_put (mail_thread_new, (EMsg *) m);
+	mail_msg_unordered_push (m);
 }
 
 static void
@@ -2056,7 +2050,7 @@ ml_drop_popup_cancel(EPopup *ep, EPopupItem *item, void *data)
 	struct _drop_msg *m = data;
 
 	m->aborted = TRUE;
-	mail_msg_free(&m->msg);
+	mail_msg_unref(m);
 }
 
 static EPopupItem ml_drop_popup_menu[] = {
@@ -2086,7 +2080,7 @@ ml_tree_drag_data_received (ETree *tree, int row, ETreePath path, int col,
 	if (!ml->folder || data->data == NULL || data->length == -1)
 		return;
 
-	m = mail_msg_new(&ml_drop_async_op, NULL, sizeof(*m));
+	m = mail_msg_new(&ml_drop_async_info);
 	m->context = context;
 	g_object_ref(context);
 	m->folder = ml->folder;
@@ -3811,7 +3805,7 @@ save_hide_state (MessageList *ml)
 
 /* ** REGENERATE MESSAGELIST ********************************************** */
 struct _regen_list_msg {
-	struct _mail_msg msg;
+	MailMsg base;
 
 	int complete;
 
@@ -3841,16 +3835,15 @@ struct _regen_list_msg {
 
  */
 
-static char *
-regen_list_describe (struct _mail_msg *mm, gint complete)
+static gchar *
+regen_list_desc (struct _regen_list_msg *m)
 {
 	return g_strdup (_("Generating message list"));
 }
 
 static void
-regen_list_regen (struct _mail_msg *mm)
+regen_list_exec (struct _regen_list_msg *m)
 {
-	struct _regen_list_msg *m = (struct _regen_list_msg *)mm;
 	GPtrArray *uids, *uidnew, *showuids, *searchuids = NULL;
 	CamelMessageInfo *info;
 	ETreePath cursor;
@@ -3885,7 +3878,7 @@ regen_list_regen (struct _mail_msg *mm)
 			} else
 				expr = "(match-all (not (system-flag \"deleted\")))";
 		}
-		searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &mm->ex);
+		searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &m->base.ex);
 	} else {
 		char *expr;
 
@@ -3895,23 +3888,23 @@ regen_list_regen (struct _mail_msg *mm)
 				sprintf(expr, "(and (match-all (not (system-flag \"junk\")))\n %s)", m->search);
 			} else
 				expr = "(match-all (not (system-flag \"junk\")))";
-			searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &mm->ex);
+			searchuids = uids = camel_folder_search_by_expression (m->folder, expr, &m->base.ex);
 		} else {
 			if (m->search)
-				searchuids = uids = camel_folder_search_by_expression (m->folder, m->search, &mm->ex);
+				searchuids = uids = camel_folder_search_by_expression (m->folder, m->search, &m->base.ex);
 			else
 				uids = camel_folder_get_uids (m->folder);
 		}
 	}
 
-	if (camel_exception_is_set (&mm->ex))
+	if (camel_exception_is_set (&m->base.ex))
 		return;
 
 	/* perform hiding */
 	if (m->hideexpr && camel_folder_has_search_capability(m->folder)) {
-		uidnew = camel_folder_search_by_expression (m->ml->folder, m->hideexpr, &mm->ex);
+		uidnew = camel_folder_search_by_expression (m->ml->folder, m->hideexpr, &m->base.ex);
 		/* well, lets not abort just because this faileld ... */
-		camel_exception_clear (&mm->ex);
+		camel_exception_clear (&m->base.ex);
 
 		if (uidnew) {
 			MESSAGE_LIST_LOCK(m->ml, hide_lock);
@@ -3998,7 +3991,7 @@ regen_list_regen (struct _mail_msg *mm)
 
 	e_profile_event_emit("list.threaduids", m->folder->full_name, 0);
 
-	if (!camel_operation_cancel_check(mm->cancel)) {
+	if (!camel_operation_cancel_check(m->base.cancel)) {
 		/* update/build a new tree */
 		if (m->dotree) {
 			if (m->tree)
@@ -4027,17 +4020,15 @@ regen_list_regen (struct _mail_msg *mm)
 }
 
 static void
-regen_list_regened (struct _mail_msg *mm)
+regen_list_done (struct _regen_list_msg *m)
 {
-	struct _regen_list_msg *m = (struct _regen_list_msg *)mm;
-
 	if (m->ml->priv->destroyed)
 		return;
 
 	if (!m->complete)
 		return;
 
-	if (camel_operation_cancel_check(mm->cancel))
+	if (camel_operation_cancel_check(m->base.cancel))
 		return;
 
 	if (m->ml->folder != m->folder)
@@ -4101,9 +4092,8 @@ regen_list_regened (struct _mail_msg *mm)
 }
 
 static void
-regen_list_free (struct _mail_msg *mm)
+regen_list_free (struct _regen_list_msg *m)
 {
-	struct _regen_list_msg *m = (struct _regen_list_msg *)mm;
 	int i;
 
 	e_profile_event_emit("list.regenerated", m->folder->full_name, 0);
@@ -4131,11 +4121,12 @@ regen_list_free (struct _mail_msg *mm)
 	g_object_unref(m->ml);
 }
 
-static struct _mail_msg_op regen_list_op = {
-	regen_list_describe,
-	regen_list_regen,
-	regen_list_regened,
-	regen_list_free,
+static MailMsgInfo regen_list_info = {
+	sizeof (struct _regen_list_msg),
+	(MailMsgDescFunc) regen_list_desc,
+	(MailMsgExecFunc) regen_list_exec,
+	(MailMsgDoneFunc) regen_list_done,
+	(MailMsgFreeFunc) regen_list_free
 };
 
 static gboolean
@@ -4145,7 +4136,7 @@ ml_regen_timeout(struct _regen_list_msg *m)
 
 	m->ml->regen = g_list_prepend(m->ml->regen, m);
 	/* TODO: we should manage our own thread stuff, would make cancelling outstanding stuff easier */
-	e_thread_put (mail_thread_queued, (EMsg *)m);
+	mail_msg_fast_ordered_push (m);
 
 	m->ml->regen_timeout_msg = NULL;
 	m->ml->regen_timeout_id = 0;
@@ -4161,7 +4152,7 @@ mail_regen_cancel(MessageList *ml)
 		GList *l = ml->regen;
 
 		while (l) {
-			struct _mail_msg *mm = l->data;
+			MailMsg *mm = l->data;
 
 			if (mm->cancel)
 				camel_operation_cancel(mm->cancel);
@@ -4173,7 +4164,7 @@ mail_regen_cancel(MessageList *ml)
 	if (ml->regen_timeout_id) {
 		g_source_remove(ml->regen_timeout_id);
 		ml->regen_timeout_id = 0;
-		mail_msg_free((struct _mail_msg *)ml->regen_timeout_msg);
+		mail_msg_unref(ml->regen_timeout_msg);
 		ml->regen_timeout_msg = NULL;
 	}
 }
@@ -4208,7 +4199,7 @@ mail_regen_list (MessageList *ml, const char *search, const char *hideexpr, Came
 	}
 #endif
 
-	m = mail_msg_new (&regen_list_op, NULL, sizeof (*m));
+	m = mail_msg_new (&regen_list_info);
 	m->ml = ml;
 	m->search = g_strdup (search);
 	m->hideexpr = g_strdup (hideexpr);