diff options
Diffstat (limited to 'libemail-engine/mail-ops.c')
| -rw-r--r-- | libemail-engine/mail-ops.c | 1506 |
1 files changed, 1506 insertions, 0 deletions
diff --git a/libemail-engine/mail-ops.c b/libemail-engine/mail-ops.c new file mode 100644 index 0000000000..4f3dbd3ee1 --- /dev/null +++ b/libemail-engine/mail-ops.c @@ -0,0 +1,1506 @@ +/* + * mail-ops.c: callbacks for the mail toolbar/menus + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with the program; if not, see <http://www.gnu.org/licenses/> + * + * + * Authors: + * Dan Winship <danw@ximian.com> + * Jeffrey Stedfast <fejj@ximian.com> + * Peter Williams <peterw@ximian.com> + * Michael Zucchi <notzed@ximian.com> + * + * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <errno.h> + +#include <glib/gstdio.h> +#include <glib/gi18n.h> + +#include <libedataserver/libedataserver.h> + +#include <libemail-engine/mail-mt.h> + +#include "e-mail-utils.h" +#include "mail-ops.h" +#include "mail-tools.h" + +#include "e-mail-folder-utils.h" +#include "e-mail-session.h" +#include "e-mail-session-utils.h" + +#define w(x) +#define d(x) + +/* XXX Make this a preprocessor definition. */ +const gchar *x_mailer = "Evolution " VERSION SUB_VERSION " " VERSION_COMMENT; + +/* 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 { + MailMsg base; + + EMailSession *session; + CamelFolder *source_folder; /* where they come from */ + GPtrArray *source_uids; /* uids to copy, or NULL == copy all */ + CamelUIDCache *cache; /* UID cache if we are to cache + * the uids, NULL otherwise */ + CamelFilterDriver *driver; + gint delete; /* delete messages after filtering? */ + CamelFolder *destination; /* default destination for any + * messages, NULL for none */ +}; + +/* since fetching also filters, we subclass the data here */ +struct _fetch_mail_msg { + struct _filter_mail_msg fmsg; + + CamelStore *store; + GCancellable *cancellable; /* we have our own cancellation + * struct, the other should be empty */ + gint keep; /* keep on server? */ + gint fetch_count; + CamelFetchType fetch_type; + gint still_more; + + MailProviderFetchLockFunc provider_lock; + MailProviderFetchUnlockFunc provider_unlock; + MailProviderFetchInboxFunc provider_fetch_inbox; + + void (*done)(gint still_more, gpointer data); + gpointer data; +}; + +static gchar * +em_filter_folder_element_desc (struct _filter_mail_msg *m) +{ + return g_strdup (_("Filtering Selected Messages")); +} + +/* filter a folder, or a subset thereof, uses source_folder/source_uids */ +/* this is shared with fetch_mail */ +static gboolean +em_filter_folder_element_exec (struct _filter_mail_msg *m, + GCancellable *cancellable, + GError **error) +{ + CamelFolder *folder; + GPtrArray *uids, *folder_uids = NULL; + gboolean success = TRUE; + GError *local_error = NULL; + + folder = m->source_folder; + + if (folder == NULL || camel_folder_get_message_count (folder) == 0) + return success; + + if (m->destination) { + camel_folder_freeze (m->destination); + camel_filter_driver_set_default_folder (m->driver, m->destination); + } + + camel_folder_freeze (folder); + + if (m->source_uids) + uids = m->source_uids; + else + folder_uids = uids = camel_folder_get_uids (folder); + + success = camel_filter_driver_filter_folder ( + m->driver, folder, m->cache, uids, m->delete, + cancellable, &local_error) == 0; + camel_filter_driver_flush (m->driver, &local_error); + + if (folder_uids) + camel_folder_free_uids (folder, folder_uids); + + /* sync our source folder */ + if (!m->cache && !local_error) + camel_folder_synchronize_sync ( + folder, FALSE, cancellable, &local_error); + camel_folder_thaw (folder); + + if (m->destination) + camel_folder_thaw (m->destination); + + /* this may thaw/unref source folders, do it here so we dont do + * it in the main thread see also fetch_mail_fetch () below */ + g_object_unref (m->driver); + m->driver = NULL; + + if (g_error_matches (local_error, CAMEL_SERVICE_ERROR, CAMEL_SERVICE_ERROR_URL_INVALID) || + g_error_matches (local_error, CAMEL_FOLDER_ERROR, CAMEL_FOLDER_ERROR_INVALID)) { + g_set_error ( + error, local_error->domain, local_error->code, + _("Failed to filter selected messages. One reason can be that folder " + "location set in one or more filters is invalid. Please check your " + "filters in Edit->Message Filters.\n" + "Original error was: %s"), local_error->message); + g_clear_error (&local_error); + } else if (local_error) + g_propagate_error (error, local_error); + + return success; +} + +static void +em_filter_folder_element_done (struct _filter_mail_msg *m) +{ +} + +static void +em_filter_folder_element_free (struct _filter_mail_msg *m) +{ + mail_session_flush_filter_log (m->session); + + if (m->session) + g_object_unref (m->session); + + if (m->source_folder) + g_object_unref (m->source_folder); + + if (m->source_uids) + g_ptr_array_unref (m->source_uids); + + if (m->destination) + g_object_unref (m->destination); + + if (m->driver) + g_object_unref (m->driver); +} + +static MailMsgInfo em_filter_folder_element_info = { + sizeof (struct _filter_mail_msg), + (MailMsgDescFunc) em_filter_folder_element_desc, + (MailMsgExecFunc) em_filter_folder_element_exec, + (MailMsgDoneFunc) em_filter_folder_element_done, + (MailMsgFreeFunc) em_filter_folder_element_free +}; + +void +mail_filter_folder (EMailSession *session, + CamelFolder *source_folder, + GPtrArray *uids, + const gchar *type, + gboolean notify) +{ + struct _filter_mail_msg *m; + + m = mail_msg_new (&em_filter_folder_element_info); + m->session = g_object_ref (session); + m->source_folder = g_object_ref (source_folder); + m->source_uids = g_ptr_array_ref (uids); + m->cache = NULL; + m->delete = FALSE; + + m->driver = camel_session_get_filter_driver ( + CAMEL_SESSION (session), type, NULL); + + if (!notify) { + /* FIXME: have a #define NOTIFY_FILTER_NAME macro? */ + /* the filter name has to stay in sync + * with mail-session::get_filter_driver */ + camel_filter_driver_remove_rule_by_name ( + m->driver, "new-mail-notification"); + } + + mail_msg_unordered_push (m); +} + +/* ********************************************************************** */ + +static gchar * +fetch_mail_desc (struct _fetch_mail_msg *m) +{ + return g_strdup_printf ( + _("Fetching mail from '%s'"), + camel_service_get_display_name (CAMEL_SERVICE (m->store))); +} + +static void +fetch_mail_exec (struct _fetch_mail_msg *m, + GCancellable *cancellable, + GError **error) +{ + struct _filter_mail_msg *fm = (struct _filter_mail_msg *) m; + GObjectClass *class; + CamelFolder *folder = NULL; + CamelProvider *provider; + CamelService *service; + CamelSession *session; + CamelSettings *settings; + CamelStore *parent_store; + CamelUIDCache *cache = NULL; + CamelURL *url; + gboolean keep = TRUE; + gboolean delete_fetched; + gboolean is_local_delivery = FALSE; + const gchar *uid = NULL; + const gchar *data_dir; + gchar *cachename; + gint i; + + service = CAMEL_SERVICE (m->store); + session = camel_service_ref_session (service); + provider = camel_service_get_provider (service); + + if (provider && (provider->flags & CAMEL_PROVIDER_IS_REMOTE) != 0 && + !camel_session_get_online (session)) + goto exit; + + fm->destination = e_mail_session_get_local_folder ( + E_MAIL_SESSION (session), E_MAIL_LOCAL_FOLDER_LOCAL_INBOX); + if (fm->destination == NULL) + goto exit; + g_object_ref (fm->destination); + + uid = camel_service_get_uid (service); + settings = camel_service_ref_settings (service); + + /* XXX This is a POP3-specific setting. */ + class = G_OBJECT_GET_CLASS (settings); + if (g_object_class_find_property (class, "keep-on-server") != NULL) + g_object_get (settings, "keep-on-server", &keep, NULL); + + g_object_unref (settings); + + /* Just for readability. */ + delete_fetched = !keep; + + url = camel_service_new_camel_url (service); + is_local_delivery = em_utils_is_local_delivery_mbox_file (url); + + if (is_local_delivery) { + gchar *path; + gchar *url_string; + + path = mail_tool_do_movemail (m->store, error); + url_string = camel_url_to_string (url, CAMEL_URL_HIDE_ALL); + + if (path && (!error || !*error)) { + camel_folder_freeze (fm->destination); + camel_filter_driver_set_default_folder ( + fm->driver, fm->destination); + camel_filter_driver_filter_mbox ( + fm->driver, path, url_string, + cancellable, error); + camel_folder_thaw (fm->destination); + + if (!error || !*error) + g_unlink (path); + } + + g_free (path); + g_free (url_string); + } else { + uid = camel_service_get_uid (service); + if (m->provider_lock) + m->provider_lock (uid); + + folder = fm->source_folder = + e_mail_session_get_inbox_sync ( + fm->session, uid, cancellable, error); + } + + camel_url_free (url); + + if (folder == NULL) + goto exit; + + parent_store = camel_folder_get_parent_store (folder); + + if (m->fetch_count > 0) { + /* We probably should fetch some old messages first. */ + m->still_more = camel_folder_fetch_messages_sync ( + folder, m->fetch_type, + m->fetch_count, cancellable, error) ? 1 : 0; + } + + service = CAMEL_SERVICE (parent_store); + data_dir = camel_service_get_user_data_dir (service); + + cachename = g_build_filename (data_dir, "uid-cache", NULL); + cache = camel_uid_cache_new (cachename); + g_free (cachename); + + if (cache) { + GPtrArray *folder_uids, *cache_uids, *uids; + GError *local_error = NULL; + + if (m->provider_fetch_inbox) { + g_object_unref (fm->destination); + fm->destination = m->provider_fetch_inbox (uid, cancellable, &local_error); + if (fm->destination == NULL) + goto exit; + g_object_ref (fm->destination); + } + + if (!local_error && !g_cancellable_is_cancelled (cancellable)) { + folder_uids = camel_folder_get_uids (folder); + cache_uids = camel_uid_cache_get_new_uids (cache, folder_uids); + + if (cache_uids) { + gboolean success; + + /* need to copy this, sigh */ + fm->source_uids = uids = g_ptr_array_new (); + g_ptr_array_set_size (uids, cache_uids->len); + + /* Reverse it so that we fetch the latest as first, while fetching POP */ + for (i = 0; i < cache_uids->len; i++) { + uids->pdata[cache_uids->len - i - 1] = g_strdup (cache_uids->pdata[i]); + } + + fm->cache = cache; + + success = em_filter_folder_element_exec (fm, cancellable, &local_error); + + /* need to uncancel so writes/etc. don't fail */ + if (g_cancellable_is_cancelled (m->cancellable)) + g_cancellable_reset (m->cancellable); + + if (!success) { + GPtrArray *uncached_uids; + GHashTable *uncached_hash; + + uncached_uids = camel_folder_get_uncached_uids (folder, cache_uids, NULL); + uncached_hash = g_hash_table_new (g_str_hash, g_str_equal); + + for (i = 0; uncached_uids && i < uncached_uids->len; i++) { + g_hash_table_insert (uncached_hash, uncached_uids->pdata[i], uncached_uids->pdata[i]); + } + + /* re-enter known UIDs, thus they are not + * re-fetched next time */ + for (i = 0; i < cache_uids->len; i++) { + /* skip uncached UIDs */ + if (!g_hash_table_lookup (uncached_hash, cache_uids->pdata[i])) + camel_uid_cache_save_uid (cache, cache_uids->pdata[i]); + } + + g_hash_table_destroy (uncached_hash); + camel_folder_free_uids (folder, uncached_uids); + } + + /* save the cache of uids that we've just downloaded */ + camel_uid_cache_save (cache); + + camel_uid_cache_free_uids (cache_uids); + } + + if (delete_fetched && !local_error) { + /* not keep on server - just delete all + * the actual messages on the server */ + for (i = 0; i < folder_uids->len; i++) { + camel_folder_delete_message ( + folder, folder_uids->pdata[i]); + } + } + + if ((delete_fetched || cache_uids) && !local_error) { + /* expunge messages (downloaded so far) */ + /* FIXME Not passing a GCancellable or GError here. */ + camel_folder_synchronize_sync ( + folder, delete_fetched, NULL, NULL); + } + + camel_folder_free_uids (folder, folder_uids); + } + + camel_uid_cache_destroy (cache); + + if (local_error) + g_propagate_error (error, local_error); + } else { + em_filter_folder_element_exec (fm, cancellable, error); + } + + /* we unref the source folder here since we + * may now block in finalize (we try to + * disconnect cleanly) */ + g_object_unref (fm->source_folder); + fm->source_folder = NULL; + +exit: + if (!is_local_delivery && m->provider_unlock) + m->provider_unlock (uid); + + /* we unref this here as it may have more work to do (syncing + * folders and whatnot) before we are really done */ + /* should this be cancellable too? (i.e. above unregister above) */ + if (fm->driver) { + g_object_unref (fm->driver); + fm->driver = NULL; + } + + /* also disconnect if not a local delivery mbox; + * there is no need to keep the connection alive forever */ + if (!is_local_delivery) { + gboolean was_cancelled; + + was_cancelled = g_cancellable_is_cancelled (cancellable); + + /* pity, but otherwise it doesn't disconnect */ + if (was_cancelled) + g_cancellable_reset (cancellable); + + camel_service_disconnect_sync ( + service, !was_cancelled, cancellable, NULL); + } + + g_object_unref (session); +} + +static void +fetch_mail_done (struct _fetch_mail_msg *m) +{ + if (m->done) + m->done (m->still_more, m->data); +} + +static void +fetch_mail_free (struct _fetch_mail_msg *m) +{ + if (m->store != NULL) + g_object_unref (m->store); + + if (m->cancellable != NULL) + g_object_unref (m->cancellable); + + em_filter_folder_element_free ((struct _filter_mail_msg *) m); +} + +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 ... */ +void +mail_fetch_mail (CamelStore *store, + CamelFetchType fetch_type, + gint fetch_count, + const gchar *type, + MailProviderFetchLockFunc lock_func, + MailProviderFetchUnlockFunc unlock_func, + MailProviderFetchInboxFunc fetch_inbox_func, + GCancellable *cancellable, + CamelFilterGetFolderFunc get_folder, + gpointer get_data, + CamelFilterStatusFunc *status, + gpointer status_data, + void (*done)(gint still_more, + gpointer data), + gpointer data) +{ + struct _fetch_mail_msg *m; + struct _filter_mail_msg *fm; + CamelSession *session; + + g_return_if_fail (CAMEL_IS_STORE (store)); + + session = camel_service_ref_session (CAMEL_SERVICE (store)); + + m = mail_msg_new (&fetch_mail_info); + fm = (struct _filter_mail_msg *) m; + fm->session = g_object_ref (session); + m->store = g_object_ref (store); + fm->cache = NULL; + if (cancellable) + m->cancellable = g_object_ref (cancellable); + m->done = done; + m->data = data; + + m->fetch_count = fetch_count; + m->fetch_type = fetch_type; + m->still_more = -1; + + m->provider_lock = lock_func; + m->provider_unlock = unlock_func; + m->provider_fetch_inbox = fetch_inbox_func; + + fm->driver = camel_session_get_filter_driver (session, type, NULL); + camel_filter_driver_set_folder_func (fm->driver, get_folder, get_data); + if (status) + camel_filter_driver_set_status_func (fm->driver, status, status_data); + + mail_msg_unordered_push (m); + + g_object_unref (session); +} + +/* ********************************************************************** */ +/* sending stuff */ +/* ** SEND MAIL *********************************************************** */ + +static const gchar *normal_recipients[] = { + CAMEL_RECIPIENT_TYPE_TO, + CAMEL_RECIPIENT_TYPE_CC, + CAMEL_RECIPIENT_TYPE_BCC +}; + +static const gchar *resent_recipients[] = { + CAMEL_RECIPIENT_TYPE_RESENT_TO, + CAMEL_RECIPIENT_TYPE_RESENT_CC, + CAMEL_RECIPIENT_TYPE_RESENT_BCC +}; + +struct _send_queue_msg { + MailMsg base; + + EMailSession *session; + CamelFolder *queue; + CamelTransport *transport; + + CamelFilterDriver *driver; + + /* we use camelfilterstatusfunc, even though its not the filter doing it */ + CamelFilterStatusFunc *status; + gpointer status_data; + + void (*done)(gpointer data); + gpointer data; +}; + +static void report_status (struct _send_queue_msg *m, + enum camel_filter_status_t status, + gint pc, + const gchar *desc, + ...); + +/* send 1 message to a specific transport */ +static void +mail_send_message (struct _send_queue_msg *m, + CamelFolder *queue, + const gchar *uid, + CamelTransport *transport, + CamelFilterDriver *driver, + GCancellable *cancellable, + GError **error) +{ + CamelService *service; + const CamelInternetAddress *iaddr; + CamelAddress *from, *recipients; + CamelMessageInfo *info = NULL; + CamelProvider *provider = NULL; + const gchar *resent_from; + CamelFolder *folder = NULL; + GString *err = NULL; + struct _camel_header_raw *xev, *header; + CamelMimeMessage *message; + gint i; + GError *local_error = NULL; + + message = camel_folder_get_message_sync ( + queue, uid, cancellable, error); + if (!message) + return; + + camel_medium_set_header (CAMEL_MEDIUM (message), "X-Mailer", x_mailer); + + /* Do this before removing "X-Evolution" headers. */ + service = e_mail_session_ref_transport_for_message ( + m->session, message); + if (service != NULL) + provider = camel_service_get_provider (service); + + err = g_string_new (""); + xev = mail_tool_remove_xevolution_headers (message); + + if (CAMEL_IS_TRANSPORT (service)) { + const gchar *tuid; + + /* Let the dialog know the right account it is using. */ + tuid = camel_service_get_uid (CAMEL_SERVICE (transport)); + report_status (m, CAMEL_FILTER_STATUS_ACTION, 0, tuid); + } + + /* Check for email sending */ + from = (CamelAddress *) camel_internet_address_new (); + resent_from = camel_medium_get_header ( + CAMEL_MEDIUM (message), "Resent-From"); + if (resent_from != NULL) { + camel_address_decode (from, resent_from); + } else { + iaddr = camel_mime_message_get_from (message); + camel_address_copy (from, CAMEL_ADDRESS (iaddr)); + } + + recipients = (CamelAddress *) camel_internet_address_new (); + for (i = 0; i < 3; i++) { + const gchar *type; + + if (resent_from != NULL) + type = resent_recipients[i]; + else + type = normal_recipients[i]; + iaddr = camel_mime_message_get_recipients (message, type); + camel_address_cat (recipients, CAMEL_ADDRESS (iaddr)); + } + + if (camel_address_length (recipients) > 0) { + if (provider && (provider->flags & CAMEL_PROVIDER_IS_REMOTE) != 0 && + !camel_session_get_online (CAMEL_SESSION (m->session))) { + /* silently ignore */ + goto exit; + } + + if (!camel_service_connect_sync ( + service, cancellable, error)) + goto exit; + + /* expand, or remove empty, group addresses */ + em_utils_expand_groups (CAMEL_INTERNET_ADDRESS (recipients)); + + if (!camel_transport_send_to_sync ( + CAMEL_TRANSPORT (service), message, + from, recipients, cancellable, error)) + goto exit; + } + + /* Now check for posting, failures are ignored */ + info = camel_message_info_new (NULL); + camel_message_info_set_flags (info, CAMEL_MESSAGE_SEEN, ~0); + + for (header = xev; header; header = header->next) { + gchar *uri; + + if (strcmp (header->name, "X-Evolution-PostTo") != 0) + continue; + + /* TODO: don't lose errors */ + + uri = g_strstrip (g_strdup (header->value)); + /* FIXME Not passing a GCancellable or GError here. */ + folder = e_mail_session_uri_to_folder_sync ( + m->session, uri, 0, NULL, NULL); + if (folder != NULL) { + /* FIXME Not passing a GCancellable or GError here. */ + camel_folder_append_message_sync ( + folder, message, info, NULL, NULL, NULL); + g_object_unref (folder); + folder = NULL; + } + g_free (uri); + } + + /* post process */ + mail_tool_restore_xevolution_headers (message, xev); + + if (driver) { + camel_filter_driver_filter_message ( + driver, message, info, NULL, NULL, + NULL, "", cancellable, &local_error); + + if (local_error != NULL) { + if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + goto exit; + + /* sending mail, filtering failed */ + if (g_error_matches (local_error, CAMEL_SERVICE_ERROR, CAMEL_SERVICE_ERROR_URL_INVALID) || + g_error_matches (local_error, CAMEL_FOLDER_ERROR, CAMEL_FOLDER_ERROR_INVALID)) { + g_string_append_printf ( + err, + _("Failed to apply outgoing filters. One reason can be that folder " + "location set in one or more filters is invalid. Please check your " + "filters in Edit->Message Filters.\n" + "Original error was: %s"), local_error->message); + } else { + g_string_append_printf ( + err, _("Failed to apply outgoing filters: %s"), + local_error->message); + } + + g_clear_error (&local_error); + } + } + + if (provider == NULL + || !(provider->flags & CAMEL_PROVIDER_DISABLE_SENT_FOLDER)) { + CamelFolder *local_sent_folder; + GError *local_error = NULL; + + local_sent_folder = e_mail_session_get_local_folder ( + m->session, E_MAIL_LOCAL_FOLDER_SENT); + + folder = e_mail_session_get_fcc_for_message_sync ( + m->session, message, cancellable, &local_error); + + /* Sanity check. */ + g_return_if_fail ( + ((folder == NULL) && (local_error != NULL)) || + ((folder != NULL) && (local_error == NULL))); + + if (local_error == NULL) + camel_folder_append_message_sync ( + folder, message, info, NULL, + cancellable, &local_error); + + if (g_error_matches ( + local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + goto exit; + + if (local_error != NULL && folder != local_sent_folder) { + + if (folder != NULL) { + const gchar *description; + + description = + camel_folder_get_description (folder); + if (err->len > 0) + g_string_append (err, "\n\n"); + g_string_append_printf ( + err, + _("Failed to append to %s: %s\n" + "Appending to local 'Sent' folder instead."), + description, + local_error->message); + + g_object_unref (folder); + } + + g_clear_error (&local_error); + folder = g_object_ref (local_sent_folder); + + camel_folder_append_message_sync ( + folder, message, info, NULL, + cancellable, &local_error); + + if (g_error_matches ( + local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + goto exit; + + if (local_error != NULL) { + if (err->len > 0) + g_string_append (err, "\n\n"); + g_string_append_printf ( + err, + _("Failed to append to " + "local 'Sent' folder: %s"), + local_error->message); + } + } + } + + if (local_error == NULL) { + /* Mark the draft message for deletion, if present. */ + e_mail_session_handle_draft_headers_sync ( + m->session, message, cancellable, &local_error); + if (local_error != NULL) { + g_warning ( + "%s: Failed to handle draft headers: %s", + G_STRFUNC, local_error->message); + g_clear_error (&local_error); + } + + /* Set flags on the original source message, if present. + * Source message refers to the message being forwarded + * or replied to. */ + e_mail_session_handle_source_headers_sync ( + m->session, message, cancellable, &local_error); + if (local_error != NULL) { + g_warning ( + "%s: Failed to handle source headers: %s", + G_STRFUNC, local_error->message); + g_clear_error (&local_error); + } + } + + if (local_error == NULL) { + camel_folder_set_message_flags ( + queue, uid, CAMEL_MESSAGE_DELETED | + CAMEL_MESSAGE_SEEN, ~0); + /* Sync it to disk, since if it crashes in between, + * we keep sending it again on next start. */ + /* FIXME Not passing a GCancellable or GError here. */ + camel_folder_synchronize_sync (queue, FALSE, NULL, NULL); + } + + if (err->len > 0) { + /* set the culmulative exception report */ + g_set_error ( + &local_error, CAMEL_ERROR, + CAMEL_ERROR_GENERIC, "%s", err->str); + } + +exit: + if (local_error != NULL) + g_propagate_error (error, local_error); + + /* FIXME Not passing a GCancellable or GError here. */ + if (folder != NULL) { + camel_folder_synchronize_sync (folder, FALSE, NULL, NULL); + g_object_unref (folder); + } + + if (info != NULL) + camel_message_info_free (info); + + if (service != NULL) + g_object_unref (service); + + g_object_unref (recipients); + g_object_unref (from); + camel_header_raw_clear (&xev); + g_string_free (err, TRUE); + g_object_unref (message); +} + +/* ** SEND MAIL QUEUE ***************************************************** */ + +static void +report_status (struct _send_queue_msg *m, + enum camel_filter_status_t status, + gint pc, + const gchar *desc, + ...) +{ + va_list ap; + gchar *str; + + if (m->status) { + va_start (ap, desc); + str = g_strdup_vprintf (desc, ap); + va_end (ap); + m->status (m->driver, status, pc, str, m->status_data); + g_free (str); + } +} + +static void +send_queue_exec (struct _send_queue_msg *m, + GCancellable *cancellable, + GError **error) +{ + CamelFolder *sent_folder; + GPtrArray *uids, *send_uids = NULL; + gint i, j; + GError *local_error = NULL; + + d (printf ("sending queue\n")); + + sent_folder = + e_mail_session_get_local_folder ( + m->session, E_MAIL_LOCAL_FOLDER_SENT); + + if (!(uids = camel_folder_get_uids (m->queue))) + return; + + send_uids = g_ptr_array_sized_new (uids->len); + for (i = 0, j = 0; i < uids->len; i++) { + CamelMessageInfo *info; + + info = camel_folder_get_message_info (m->queue, uids->pdata[i]); + if (info) { + if ((camel_message_info_flags (info) & CAMEL_MESSAGE_DELETED) == 0) + send_uids->pdata[j++] = uids->pdata[i]; + camel_folder_free_message_info (m->queue, info); + } + } + + send_uids->len = j; + if (send_uids->len == 0) { + /* nothing to send */ + camel_folder_free_uids (m->queue, uids); + g_ptr_array_free (send_uids, TRUE); + return; + } + + camel_operation_push_message (cancellable, _("Sending message")); + + /* NB: This code somewhat abuses the 'exception' stuff. Apart from + * fatal problems, it is also used as a mechanism to accumualte + * warning messages and present them back to the user. */ + + for (i = 0, j = 0; i < send_uids->len; i++) { + gint pc = (100 * i) / send_uids->len; + + report_status ( + m, CAMEL_FILTER_STATUS_START, pc, + _("Sending message %d of %d"), i + 1, + send_uids->len); + + camel_operation_progress ( + cancellable, (i + 1) * 100 / send_uids->len); + + mail_send_message ( + m, m->queue, send_uids->pdata[i], m->transport, + m->driver, cancellable, &local_error); + if (local_error != NULL) { + if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { + /* merge exceptions into one */ + if (m->base.error != NULL) { + gchar *old_message; + + old_message = g_strdup ( + m->base.error->message); + g_clear_error (&m->base.error); + g_set_error ( + &m->base.error, CAMEL_ERROR, + CAMEL_ERROR_GENERIC, + "%s\n\n%s", old_message, + local_error->message); + g_free (old_message); + + g_clear_error (&local_error); + } else { + g_propagate_error (&m->base.error, local_error); + local_error = NULL; + } + + /* keep track of the number of failures */ + j++; + } else { + /* transfer the USER_CANCEL error to the + * async op exception and then break */ + g_propagate_error (&m->base.error, local_error); + local_error = NULL; + break; + } + } + } + + j += (send_uids->len - i); + + if (j > 0) + report_status ( + m, CAMEL_FILTER_STATUS_END, 100, + /* Translators: The string is distinguished by total + * count of messages to be sent. Failed messages is + * always more than zero. */ + ngettext ( + "Failed to send a message", + "Failed to send %d of %d messages", + send_uids->len), + j, send_uids->len); + else if (g_error_matches ( + m->base.error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Canceled.")); + else + report_status (m, CAMEL_FILTER_STATUS_END, 100, _("Complete.")); + + if (m->driver) { + g_object_unref (m->driver); + m->driver = NULL; + } + + camel_folder_free_uids (m->queue, uids); + g_ptr_array_free (send_uids, TRUE); + + /* FIXME Not passing a GCancellable or GError here. */ + if (j <= 0 && m->base.error == NULL) + camel_folder_synchronize_sync (m->queue, TRUE, NULL, NULL); + + /* FIXME Not passing a GCancellable or GError here. */ + if (sent_folder) + camel_folder_synchronize_sync (sent_folder, FALSE, NULL, NULL); + + camel_operation_pop_message (cancellable); +} + +static void +send_queue_done (struct _send_queue_msg *m) +{ + if (m->done) + m->done (m->data); +} + +static gchar * +send_queue_desc (struct _send_queue_msg *m) +{ + return g_strdup (_("Sending message")); +} + +static void +send_queue_free (struct _send_queue_msg *m) +{ + if (m->session != NULL) + g_object_unref (m->session); + if (m->driver != NULL) + g_object_unref (m->driver); + if (m->transport != NULL) + g_object_unref (m->transport); + g_object_unref (m->queue); +} + +static MailMsgInfo send_queue_info = { + sizeof (struct _send_queue_msg), + (MailMsgDescFunc) send_queue_desc, + (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?) */ +void +mail_send_queue (EMailSession *session, + CamelFolder *queue, + CamelTransport *transport, + const gchar *type, + GCancellable *cancellable, + CamelFilterGetFolderFunc get_folder, + gpointer get_data, + CamelFilterStatusFunc *status, + gpointer status_data, + void (*done)(gpointer data), + gpointer data) +{ + struct _send_queue_msg *m; + + g_return_if_fail (E_IS_MAIL_SESSION (session)); + + m = mail_msg_new (&send_queue_info); + m->session = g_object_ref (session); + m->queue = g_object_ref (queue); + m->transport = g_object_ref (transport); + if (G_IS_CANCELLABLE (cancellable)) + m->base.cancellable = g_object_ref (cancellable); + m->status = status; + m->status_data = status_data; + m->done = done; + m->data = data; + + m->driver = camel_session_get_filter_driver ( + CAMEL_SESSION (session), type, NULL); + camel_filter_driver_set_folder_func (m->driver, get_folder, get_data); + + mail_msg_unordered_push (m); +} + +/* ** TRANSFER MESSAGES **************************************************** */ + +struct _transfer_msg { + MailMsg base; + + EMailSession *session; + CamelFolder *source; + GPtrArray *uids; + gboolean delete; + gchar *dest_uri; + guint32 dest_flags; + + void (*done)(gboolean ok, gpointer data); + gpointer data; +}; + +static gchar * +transfer_messages_desc (struct _transfer_msg *m) +{ + return g_strdup_printf ( + m->delete ? + _("Moving messages to '%s'") : + _("Copying messages to '%s'"), + m->dest_uri); + +} + +static void +transfer_messages_exec (struct _transfer_msg *m, + GCancellable *cancellable, + GError **error) +{ + CamelFolder *dest; + + dest = e_mail_session_uri_to_folder_sync ( + m->session, m->dest_uri, m->dest_flags, + cancellable, error); + if (dest == NULL) + return; + + if (dest == m->source) { + g_object_unref (dest); + /* no-op */ + return; + } + + camel_folder_freeze (m->source); + camel_folder_freeze (dest); + + camel_folder_transfer_messages_to_sync ( + m->source, m->uids, dest, m->delete, NULL, + cancellable, error); + + /* make sure all deleted messages are marked as seen */ + + if (m->delete) { + gint i; + + for (i = 0; i < m->uids->len; i++) + camel_folder_set_message_flags ( + m->source, m->uids->pdata[i], + CAMEL_MESSAGE_SEEN, CAMEL_MESSAGE_SEEN); + } + + camel_folder_thaw (m->source); + camel_folder_thaw (dest); + + /* FIXME Not passing a GCancellable or GError here. */ + camel_folder_synchronize_sync (dest, FALSE, NULL, NULL); + g_object_unref (dest); +} + +static void +transfer_messages_done (struct _transfer_msg *m) +{ + if (m->done) + m->done (m->base.error == NULL, m->data); +} + +static void +transfer_messages_free (struct _transfer_msg *m) +{ + g_object_unref (m->session); + g_object_unref (m->source); + g_free (m->dest_uri); + g_ptr_array_unref (m->uids); +} + +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 +mail_transfer_messages (EMailSession *session, + CamelFolder *source, + GPtrArray *uids, + gboolean delete_from_source, + const gchar *dest_uri, + guint32 dest_flags, + void (*done) (gboolean ok, + gpointer data), + gpointer data) +{ + struct _transfer_msg *m; + + g_return_if_fail (CAMEL_IS_FOLDER (source)); + g_return_if_fail (uids != NULL); + g_return_if_fail (dest_uri != NULL); + + m = mail_msg_new (&transfer_messages_info); + m->session = g_object_ref (session); + m->source = g_object_ref (source); + m->uids = g_ptr_array_ref (uids); + m->delete = delete_from_source; + m->dest_uri = g_strdup (dest_uri); + m->dest_flags = dest_flags; + m->done = done; + m->data = data; + + mail_msg_slow_ordered_push (m); +} + +/* ** SYNC FOLDER ********************************************************* */ + +struct _sync_folder_msg { + MailMsg base; + + CamelFolder *folder; + gboolean test_for_expunge; + void (*done) (CamelFolder *folder, gpointer data); + gpointer data; +}; + +static gchar * +sync_folder_desc (struct _sync_folder_msg *m) +{ + return g_strdup_printf ( + _("Storing folder '%s'"), + camel_folder_get_full_name (m->folder)); +} + +static void +sync_folder_exec (struct _sync_folder_msg *m, + GCancellable *cancellable, + GError **error) +{ + gboolean expunge = FALSE; + + if (m->test_for_expunge) { + GSettings *settings; + gboolean delete_junk; + + settings = g_settings_new ("org.gnome.evolution.mail"); + + expunge = g_settings_get_boolean (settings, "trash-empty-on-exit") && + g_settings_get_int (settings, "trash-empty-on-exit-days") == -1; + delete_junk = g_settings_get_boolean (settings, "junk-empty-on-exit") && + g_settings_get_int (settings, "junk-empty-on-exit-days") == -1; + + g_object_unref (settings); + + /* delete junk first, if requested */ + if (delete_junk) { + CamelStore *store; + CamelFolder *folder; + + store = camel_folder_get_parent_store (m->folder); + folder = camel_store_get_junk_folder_sync (store, cancellable, error); + if (folder != NULL) { + GPtrArray *uids; + guint32 flags; + guint32 mask; + guint ii; + + uids = camel_folder_get_uids (folder); + flags = mask = CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_SEEN; + + camel_folder_freeze (folder); + + for (ii = 0; ii < uids->len && !g_cancellable_is_cancelled (cancellable); ii++) { + const gchar *uid = uids->pdata[ii]; + camel_folder_set_message_flags (folder, uid, flags, mask); + } + + camel_folder_thaw (folder); + camel_folder_free_uids (folder, uids); + + g_object_unref (folder); + + if (g_cancellable_set_error_if_cancelled (cancellable, error)) + return; + } + + /* error should be set already, from the get_junk_folder_sync() call */ + if (g_cancellable_is_cancelled (cancellable)) + return; + } + } + + camel_folder_synchronize_sync (m->folder, expunge, cancellable, error); +} + +static void +sync_folder_done (struct _sync_folder_msg *m) +{ + if (m->done) + m->done (m->folder, m->data); +} + +static void +sync_folder_free (struct _sync_folder_msg *m) +{ + if (m->folder) + g_object_unref (m->folder); +} + +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 +mail_sync_folder (CamelFolder *folder, + gboolean test_for_expunge, + void (*done) (CamelFolder *folder, + gpointer data), + gpointer data) +{ + struct _sync_folder_msg *m; + + m = mail_msg_new (&sync_folder_info); + m->folder = g_object_ref (folder); + m->test_for_expunge = test_for_expunge; + m->data = data; + m->done = done; + + mail_msg_slow_ordered_push (m); +} + +/* ** SYNC STORE ********************************************************* */ + +struct _sync_store_msg { + MailMsg base; + + CamelStore *store; + gint expunge; + void (*done) (CamelStore *store, gpointer data); + gpointer data; +}; + +static gchar * +sync_store_desc (struct _sync_store_msg *m) +{ + CamelURL *url; + gchar *uri, *res; + + url = camel_service_new_camel_url (CAMEL_SERVICE (m->store)); + uri = camel_url_to_string (url, CAMEL_URL_HIDE_ALL); + camel_url_free (url); + + res = g_strdup_printf ( + m->expunge ? + _("Expunging and storing account '%s'") : + _("Storing account '%s'"), + uri); + g_free (uri); + + return res; +} + +static void +sync_store_exec (struct _sync_store_msg *m, + GCancellable *cancellable, + GError **error) +{ + camel_store_synchronize_sync ( + m->store, m->expunge, + cancellable, error); +} + +static void +sync_store_done (struct _sync_store_msg *m) +{ + if (m->done) + m->done (m->store, m->data); +} + +static void +sync_store_free (struct _sync_store_msg *m) +{ + g_object_unref (m->store); +} + +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 +mail_sync_store (CamelStore *store, + gint expunge, + void (*done) (CamelStore *store, + gpointer data), + gpointer data) +{ + struct _sync_store_msg *m; + + m = mail_msg_new (&sync_store_info); + m->store = g_object_ref (store); + m->expunge = expunge; + m->data = data; + m->done = done; + + mail_msg_slow_ordered_push (m); +} + +/* ******************************************************************************** */ + +struct _empty_trash_msg { + MailMsg base; + + CamelStore *store; +}; + +static gchar * +empty_trash_desc (struct _empty_trash_msg *m) +{ + CamelService *service; + const gchar *display_name; + + service = CAMEL_SERVICE (m->store); + display_name = camel_service_get_display_name (service); + + return g_strdup_printf ( + _("Emptying trash in '%s'"), display_name); +} + +static void +empty_trash_exec (struct _empty_trash_msg *m, + GCancellable *cancellable, + GError **error) +{ + CamelService *service; + CamelFolder *trash; + + service = CAMEL_SERVICE (m->store); + + if (!camel_service_connect_sync (service, cancellable, error)) + return; + + trash = camel_store_get_trash_folder_sync ( + m->store, cancellable, error); + + if (trash != NULL) { + e_mail_folder_expunge_sync (trash, cancellable, error); + g_object_unref (trash); + } +} + +static void +empty_trash_done (struct _empty_trash_msg *m) +{ +} + +static void +empty_trash_free (struct _empty_trash_msg *m) +{ + if (m->store) + g_object_unref (m->store); +} + +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 +mail_empty_trash (CamelStore *store) +{ + struct _empty_trash_msg *m; + + g_return_if_fail (CAMEL_IS_STORE (store)); + + m = mail_msg_new (&empty_trash_info); + m->store = g_object_ref (store); + + mail_msg_slow_ordered_push (m); +} + +/* ** Execute Shell Command ************************************************ */ + +void +mail_execute_shell_command (CamelFilterDriver *driver, + gint argc, + gchar **argv, + gpointer data) +{ + if (argc <= 0) + return; + + g_spawn_async (NULL, argv, NULL, 0, NULL, data, NULL, NULL); +} + |