path: root/libemail-engine/e-mail-session-utils.c

/*
 * e-mail-session-utils.c
 *
 * 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/>
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "e-mail-session-utils.h"

#include <glib/gi18n-lib.h>
#include <libedataserver/libedataserver.h>

#include <libemail-engine/e-mail-folder-utils.h>
#include <libemail-engine/e-mail-utils.h>
#include <libemail-engine/mail-tools.h>

/* X-Mailer header value */
#define X_MAILER ("Evolution " VERSION SUB_VERSION " " VERSION_COMMENT)

/* FIXME: Temporary - remove this after we move filter/ to eds */
#define E_FILTER_SOURCE_OUTGOING "outgoing"

typedef struct _AsyncContext AsyncContext;

struct _AsyncContext {
    CamelFolder *folder;

    CamelMimeMessage *message;
    CamelMessageInfo *info;

    CamelAddress *from;
    CamelAddress *recipients;

    CamelFilterDriver *driver;

    CamelService *transport;

    GCancellable *cancellable;
    gint io_priority;

    /* X-Evolution headers */
    struct _camel_header_raw *xev;

    GPtrArray *post_to_uris;

    EMailLocalFolder local_id;

    gchar *folder_uri;
    gchar *message_uid;
};

static void
async_context_free (AsyncContext *context)
{
    if (context->folder != NULL)
        g_object_unref (context->folder);

    if (context->message != NULL)
        g_object_unref (context->message);

    if (context->info != NULL)
        camel_message_info_free (context->info);

    if (context->from != NULL)
        g_object_unref (context->from);

    if (context->recipients != NULL)
        g_object_unref (context->recipients);

    if (context->driver != NULL)
        g_object_unref (context->driver);

    if (context->transport != NULL)
        g_object_unref (context->transport);

    if (context->cancellable != NULL) {
        camel_operation_pop_message (context->cancellable);
        g_object_unref (context->cancellable);
    }

    if (context->xev != NULL)
        camel_header_raw_clear (&context->xev);

    if (context->post_to_uris != NULL) {
        g_ptr_array_foreach (
            context->post_to_uris, (GFunc) g_free, NULL);
        g_ptr_array_free (context->post_to_uris, TRUE);
    }

    g_free (context->folder_uri);
    g_free (context->message_uid);

    g_slice_free (AsyncContext, context);
}

GQuark
e_mail_error_quark (void)
{
    static GQuark quark = 0;

    if (G_UNLIKELY (quark == 0)) {
        const gchar *string = "e-mail-error-quark";
        quark = g_quark_from_static_string (string);
    }

    return quark;
}

static void
mail_session_append_to_local_folder_thread (GSimpleAsyncResult *simple,
                                            GObject *object,
                                            GCancellable *cancellable)
{
    AsyncContext *context;
    GError *error = NULL;

    context = g_simple_async_result_get_op_res_gpointer (simple);

    e_mail_session_append_to_local_folder_sync (
        E_MAIL_SESSION (object),
        context->local_id, context->message,
        context->info, &context->message_uid,
        cancellable, &error);

    if (error != NULL)
        g_simple_async_result_take_error (simple, error);
}

gboolean
e_mail_session_append_to_local_folder_sync (EMailSession *session,
                                            EMailLocalFolder local_id,
                                            CamelMimeMessage *message,
                                            CamelMessageInfo *info,
                                            gchar **appended_uid,
                                            GCancellable *cancellable,
                                            GError **error)
{
    CamelFolder *folder;
    const gchar *folder_uri;
    gboolean success = FALSE;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), FALSE);
    g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), FALSE);

    folder_uri = e_mail_session_get_local_folder_uri (session, local_id);
    g_return_val_if_fail (folder_uri != NULL, FALSE);

    folder = e_mail_session_uri_to_folder_sync (
        session, folder_uri, CAMEL_STORE_FOLDER_CREATE,
        cancellable, error);

    if (folder != NULL) {
        success = e_mail_folder_append_message_sync (
            folder, message, info, appended_uid,
            cancellable, error);
        g_object_unref (folder);
    }

    return success;
}

void
e_mail_session_append_to_local_folder (EMailSession *session,
                                       EMailLocalFolder local_id,
                                       CamelMimeMessage *message,
                                       CamelMessageInfo *info,
                                       gint io_priority,
                                       GCancellable *cancellable,
                                       GAsyncReadyCallback callback,
                                       gpointer user_data)
{
    GSimpleAsyncResult *simple;
    AsyncContext *context;

    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));

    context = g_slice_new0 (AsyncContext);
    context->local_id = local_id;
    context->message = g_object_ref (message);

    if (info != NULL)
        context->info = camel_message_info_ref (info);

    simple = g_simple_async_result_new (
        G_OBJECT (session), callback, user_data,
        e_mail_session_append_to_local_folder);

    g_simple_async_result_set_check_cancellable (simple, cancellable);

    g_simple_async_result_set_op_res_gpointer (
        simple, context, (GDestroyNotify) async_context_free);

    g_simple_async_result_run_in_thread (
        simple, mail_session_append_to_local_folder_thread,
        io_priority, cancellable);

    g_object_unref (simple);
}

gboolean
e_mail_session_append_to_local_folder_finish (EMailSession *session,
                                              GAsyncResult *result,
                                              gchar **appended_uid,
                                              GError **error)
{
    GSimpleAsyncResult *simple;
    AsyncContext *context;

    g_return_val_if_fail (
        g_simple_async_result_is_valid (
        result, G_OBJECT (session),
        e_mail_session_append_to_local_folder), FALSE);

    simple = G_SIMPLE_ASYNC_RESULT (result);
    context = g_simple_async_result_get_op_res_gpointer (simple);

    if (appended_uid != NULL) {
        *appended_uid = context->message_uid;
        context->message_uid = NULL;
    }

    /* Assume success unless a GError is set. */
    return !g_simple_async_result_propagate_error (simple, error);
}

static void
mail_session_handle_draft_headers_thread (GSimpleAsyncResult *simple,
                                          EMailSession *session,
                                          GCancellable *cancellable)
{
    AsyncContext *context;
    GError *error = NULL;

    context = g_simple_async_result_get_op_res_gpointer (simple);

    e_mail_session_handle_draft_headers_sync (
        session, context->message, cancellable, &error);

    if (error != NULL)
        g_simple_async_result_take_error (simple, error);
}

gboolean
e_mail_session_handle_draft_headers_sync (EMailSession *session,
                                          CamelMimeMessage *message,
                                          GCancellable *cancellable,
                                          GError **error)
{
    CamelFolder *folder;
    CamelMedium *medium;
    const gchar *folder_uri;
    const gchar *message_uid;
    const gchar *header_name;
    gboolean success;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), FALSE);
    g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), FALSE);

    medium = CAMEL_MEDIUM (message);

    header_name = "X-Evolution-Draft-Folder";
    folder_uri = camel_medium_get_header (medium, header_name);

    header_name = "X-Evolution-Draft-Message";
    message_uid = camel_medium_get_header (medium, header_name);

    /* Don't report errors about missing X-Evolution-Draft
     * headers.  These headers are optional, so their absence
     * is handled by doing nothing. */
    if (folder_uri == NULL || message_uid == NULL)
        return TRUE;

    folder = e_mail_session_uri_to_folder_sync (
        session, folder_uri, 0, cancellable, error);

    if (folder == NULL)
        return FALSE;

    camel_folder_set_message_flags (
        folder, message_uid,
        CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_SEEN,
        CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_SEEN);

    success = camel_folder_synchronize_message_sync (
        folder, message_uid, cancellable, error);

    g_object_unref (folder);

    return success;
}

void
e_mail_session_handle_draft_headers (EMailSession *session,
                                     CamelMimeMessage *message,
                                     gint io_priority,
                                     GCancellable *cancellable,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data)
{
    GSimpleAsyncResult *simple;
    AsyncContext *context;

    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));

    context = g_slice_new0 (AsyncContext);
    context->message = g_object_ref (message);

    simple = g_simple_async_result_new (
        G_OBJECT (session), callback, user_data,
        e_mail_session_handle_draft_headers);

    g_simple_async_result_set_check_cancellable (simple, cancellable);

    g_simple_async_result_set_op_res_gpointer (
        simple, context, (GDestroyNotify) async_context_free);

    g_simple_async_result_run_in_thread (
        simple, (GSimpleAsyncThreadFunc)
        mail_session_handle_draft_headers_thread,
        io_priority, cancellable);

    g_object_unref (simple);
}

gboolean
e_mail_session_handle_draft_headers_finish (EMailSession *session,
                                            GAsyncResult *result,
                                            GError **error)
{
    GSimpleAsyncResult *simple;

    g_return_val_if_fail (
        g_simple_async_result_is_valid (
        result, G_OBJECT (session),
        e_mail_session_handle_draft_headers), FALSE);

    simple = G_SIMPLE_ASYNC_RESULT (result);

    /* Assume success unless a GError is set. */
    return !g_simple_async_result_propagate_error (simple, error);
}

static void
mail_session_handle_source_headers_thread (GSimpleAsyncResult *simple,
                                           EMailSession *session,
                                           GCancellable *cancellable)
{
    AsyncContext *context;
    GError *error = NULL;

    context = g_simple_async_result_get_op_res_gpointer (simple);

    e_mail_session_handle_source_headers_sync (
        session, context->message, cancellable, &error);

    if (error != NULL)
        g_simple_async_result_take_error (simple, error);
}

gboolean
e_mail_session_handle_source_headers_sync (EMailSession *session,
                                           CamelMimeMessage *message,
                                           GCancellable *cancellable,
                                           GError **error)
{
    CamelFolder *folder;
    CamelMedium *medium;
    CamelMessageFlags flags = 0;
    const gchar *folder_uri;
    const gchar *message_uid;
    const gchar *flag_string;
    const gchar *header_name;
    gboolean success;
    guint length, ii;
    gchar **tokens;
    gchar *string;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), FALSE);
    g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), FALSE);

    medium = CAMEL_MEDIUM (message);

    header_name = "X-Evolution-Source-Folder";
    folder_uri = camel_medium_get_header (medium, header_name);

    header_name = "X-Evolution-Source-Message";
    message_uid = camel_medium_get_header (medium, header_name);

    header_name = "X-Evolution-Source-Flags";
    flag_string = camel_medium_get_header (medium, header_name);

    /* Don't report errors about missing X-Evolution-Source
     * headers.  These headers are optional, so their absence
     * is handled by doing nothing. */
    if (folder_uri == NULL || message_uid == NULL || flag_string == NULL)
        return TRUE;

    /* Convert the flag string to CamelMessageFlags. */

    string = g_strstrip (g_strdup (flag_string));
    tokens = g_strsplit (string, " ", 0);
    g_free (string);

    /* If tokens is NULL, a length of 0 will skip the loop. */
    length = (tokens != NULL) ? g_strv_length (tokens) : 0;

    for (ii = 0; ii < length; ii++) {
        /* Note: We're only checking for flags known to
         * be used in X-Evolution-Source-Flags headers.
         * Add more as needed. */
        if (g_strcmp0 (tokens[ii], "ANSWERED") == 0)
            flags |= CAMEL_MESSAGE_ANSWERED;
        else if (g_strcmp0 (tokens[ii], "ANSWERED_ALL") == 0)
            flags |= CAMEL_MESSAGE_ANSWERED_ALL;
        else if (g_strcmp0 (tokens[ii], "FORWARDED") == 0)
            flags |= CAMEL_MESSAGE_FORWARDED;
        else if (g_strcmp0 (tokens[ii], "SEEN") == 0)
            flags |= CAMEL_MESSAGE_SEEN;
        else
            g_warning (
                "Unknown flag '%s' in %s",
                tokens[ii], header_name);
    }

    g_strfreev (tokens);

    folder = e_mail_session_uri_to_folder_sync (
        session, folder_uri, 0, cancellable, error);

    if (folder == NULL)
        return FALSE;

    camel_folder_set_message_flags (
        folder, message_uid, flags, flags);

    success = camel_folder_synchronize_message_sync (
        folder, message_uid, cancellable, error);

    g_object_unref (folder);

    return success;
}

void
e_mail_session_handle_source_headers (EMailSession *session,
                                      CamelMimeMessage *message,
                                      gint io_priority,
                                      GCancellable *cancellable,
                                      GAsyncReadyCallback callback,
                                      gpointer user_data)
{
    GSimpleAsyncResult *simple;
    AsyncContext *context;

    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));

    context = g_slice_new0 (AsyncContext);
    context->message = g_object_ref (message);

    simple = g_simple_async_result_new (
        G_OBJECT (session), callback, user_data,
        e_mail_session_handle_source_headers);

    g_simple_async_result_set_check_cancellable (simple, cancellable);

    g_simple_async_result_set_op_res_gpointer (
        simple, context, (GDestroyNotify) async_context_free);

    g_simple_async_result_run_in_thread (
        simple, (GSimpleAsyncThreadFunc)
        mail_session_handle_source_headers_thread,
        io_priority, cancellable);

    g_object_unref (simple);
}

gboolean
e_mail_session_handle_source_headers_finish (EMailSession *session,
                                             GAsyncResult *result,
                                             GError **error)
{
    GSimpleAsyncResult *simple;

    g_return_val_if_fail (
        g_simple_async_result_is_valid (
        result, G_OBJECT (session),
        e_mail_session_handle_draft_headers), FALSE);

    simple = G_SIMPLE_ASYNC_RESULT (result);

    /* Assume success unless a GError is set. */
    return !g_simple_async_result_propagate_error (simple, error);
}

static void
mail_session_send_to_thread (GSimpleAsyncResult *simple,
                             EMailSession *session,
                             GCancellable *cancellable)
{
    AsyncContext *context;
    CamelProvider *provider;
    CamelFolder *folder = NULL;
    CamelFolder *local_sent_folder;
    CamelServiceConnectionStatus status;
    GString *error_messages;
    gboolean copy_to_sent = TRUE;
    gboolean did_connect = FALSE;
    guint ii;
    GError *error = NULL;

    context = g_simple_async_result_get_op_res_gpointer (simple);

    if (camel_address_length (context->recipients) == 0)
        goto skip_send;

    /* Send the message to all recipients. */

    if (context->transport == NULL) {
        g_simple_async_result_set_error (
            simple, CAMEL_SERVICE_ERROR,
            CAMEL_SERVICE_ERROR_UNAVAILABLE,
            _("No mail transport service available"));
        return;
    }

    status = camel_service_get_connection_status (context->transport);
    if (status != CAMEL_SERVICE_CONNECTED) {
        did_connect = TRUE;

        camel_service_connect_sync (
            context->transport, cancellable, &error);

        if (error != NULL) {
            g_simple_async_result_take_error (simple, error);
            return;
        }
    }

    provider = camel_service_get_provider (context->transport);

    if (provider->flags & CAMEL_PROVIDER_DISABLE_SENT_FOLDER)
        copy_to_sent = FALSE;

    camel_transport_send_to_sync (
        CAMEL_TRANSPORT (context->transport),
        context->message, context->from,
        context->recipients, cancellable, &error);

    if (did_connect) {
        /* Disconnect regardless of error or cancellation,
         * but be mindful of these conditions when calling
         * camel_service_disconnect_sync(). */
        if (g_cancellable_is_cancelled (cancellable)) {
            camel_service_disconnect_sync (
                context->transport, FALSE, NULL, NULL);
        } else if (error != NULL) {
            camel_service_disconnect_sync (
                context->transport, FALSE, cancellable, NULL);
        } else {
            camel_service_disconnect_sync (
                context->transport, TRUE, cancellable, &error);
        }

        if (error != NULL) {
            g_simple_async_result_take_error (simple, error);
            return;
        }
    }

skip_send:
    /* Post the message to requested folders. */
    for (ii = 0; ii < context->post_to_uris->len; ii++) {
        CamelFolder *folder;
        const gchar *folder_uri;

        folder_uri = g_ptr_array_index (context->post_to_uris, ii);

        folder = e_mail_session_uri_to_folder_sync (
            session, folder_uri, 0, cancellable, &error);

        if (error != NULL) {
            g_warn_if_fail (folder == NULL);
            g_simple_async_result_take_error (simple, error);
            return;
        }

        g_return_if_fail (CAMEL_IS_FOLDER (folder));

        camel_folder_append_message_sync (
            folder, context->message, context->info,
            NULL, cancellable, &error);

        g_object_unref (folder);

        if (error != NULL) {
            g_simple_async_result_take_error (simple, error);
            return;
        }
    }

    /*** Post Processing ***/

    /* This accumulates error messages during post-processing. */
    error_messages = g_string_sized_new (256);

    mail_tool_restore_xevolution_headers (context->message, context->xev);

    /* Run filters on the outgoing message. */
    if (context->driver != NULL) {
        camel_filter_driver_filter_message (
            context->driver, context->message, context->info,
            NULL, NULL, NULL, "", cancellable, &error);

        if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
            goto exit;

        if (error != NULL) {
            g_string_append_printf (
                error_messages,
                _("Failed to apply outgoing filters: %s"),
                error->message);
            g_clear_error (&error);
        }

        if ((camel_message_info_flags (context->info) & CAMEL_MESSAGE_DELETED) != 0)
            copy_to_sent = FALSE;
    }

    if (!copy_to_sent)
        goto cleanup;

    /* Append the sent message to a Sent folder. */

    local_sent_folder =
        e_mail_session_get_local_folder (
        session, E_MAIL_LOCAL_FOLDER_SENT);

    folder = e_mail_session_get_fcc_for_message_sync (
        session, context->message, cancellable, &error);

    /* Sanity check. */
    g_return_if_fail (
        ((folder != NULL) && (error == NULL)) ||
        ((folder == NULL) && (error != NULL)));

    /* Append the message. */
    if (folder != NULL)
        camel_folder_append_message_sync (
            folder, context->message,
            context->info, NULL, cancellable, &error);

    if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        goto exit;

    if (error == NULL)
        goto cleanup;

    if (folder != NULL && folder != local_sent_folder) {
        const gchar *description;

        description = camel_folder_get_description (folder);

        if (error_messages->len > 0)
            g_string_append (error_messages, "\n\n");
        g_string_append_printf (
            error_messages,
            _("Failed to append to %s: %s\n"
            "Appending to local 'Sent' folder instead."),
            description, error->message);
    }

    /* If appending to a remote Sent folder failed,
     * try appending to the local Sent folder. */
    if (folder != local_sent_folder) {

        g_clear_error (&error);

        camel_folder_append_message_sync (
            local_sent_folder, context->message,
            context->info, NULL, cancellable, &error);
    }

    if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        goto exit;

    /* We can't even append to the local Sent folder?
     * In that case just leave the message in Outbox. */
    if (error != NULL) {
        if (error_messages->len > 0)
            g_string_append (error_messages, "\n\n");
        g_string_append_printf (
            error_messages,
            _("Failed to append to local 'Sent' folder: %s"),
            error->message);
        g_clear_error (&error);
        goto exit;
    }

cleanup:

    /* The send operation was successful; ignore cleanup errors. */

    /* Mark the draft message for deletion, if present. */
    e_mail_session_handle_draft_headers_sync (
        session, context->message, cancellable, &error);
    if (error != NULL) {
        g_warning ("%s", error->message);
        g_clear_error (&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 (
        session, context->message, cancellable, &error);
    if (error != NULL) {
        g_warning ("%s", error->message);
        g_clear_error (&error);
    }

exit:

    /* If we were cancelled, disregard any other errors. */
    if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
        g_simple_async_result_take_error (simple, error);

    /* Stuff the accumulated error messages in a GError. */
    } else if (error_messages->len > 0) {
        g_simple_async_result_set_error (
            simple, E_MAIL_ERROR,
            E_MAIL_ERROR_POST_PROCESSING,
            "%s", error_messages->str);
    }

    /* Synchronize the Sent folder. */
    if (folder != NULL) {
        camel_folder_synchronize_sync (
            folder, FALSE, cancellable, NULL);
        g_object_unref (folder);
    }

    g_string_free (error_messages, TRUE);
}

static guint32
get_message_size (CamelMimeMessage *message,
                  GCancellable *cancellable)
{
    CamelStream *null;
    guint32 size;

    null = camel_stream_null_new ();
    camel_data_wrapper_write_to_stream_sync (
        CAMEL_DATA_WRAPPER (message), null, cancellable, NULL);
    size = CAMEL_STREAM_NULL (null)->written;
    g_object_unref (null);

    return size;
}

void
e_mail_session_send_to (EMailSession *session,
                        CamelMimeMessage *message,
                        gint io_priority,
                        GCancellable *cancellable,
                        CamelFilterGetFolderFunc get_folder_func,
                        gpointer get_folder_data,
                        GAsyncReadyCallback callback,
                        gpointer user_data)
{
    GSimpleAsyncResult *simple;
    AsyncContext *context;
    CamelAddress *from;
    CamelAddress *recipients;
    CamelMedium *medium;
    CamelMessageInfo *info;
    CamelService *transport;
    GPtrArray *post_to_uris;
    struct _camel_header_raw *xev;
    struct _camel_header_raw *header;
    const gchar *resent_from;
    GError *error = NULL;

    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));

    medium = CAMEL_MEDIUM (message);

    camel_medium_set_header (medium, "X-Mailer", X_MAILER);

    /* Do this before removing "X-Evolution" headers. */
    transport = e_mail_session_ref_transport_for_message (
        session, message);

    xev = mail_tool_remove_xevolution_headers (message);

    /* Extract directives from X-Evolution headers. */

    post_to_uris = g_ptr_array_new ();
    for (header = xev; header != NULL; header = header->next) {
        gchar *folder_uri;

        if (g_strcmp0 (header->name, "X-Evolution-PostTo") != 0)
            continue;

        folder_uri = g_strstrip (g_strdup (header->value));
        g_ptr_array_add (post_to_uris, folder_uri);
    }

    /* Collect sender and recipients from headers. */

    from = (CamelAddress *) camel_internet_address_new ();
    recipients = (CamelAddress *) camel_internet_address_new ();
    resent_from = camel_medium_get_header (medium, "Resent-From");

    if (resent_from != NULL) {
        const CamelInternetAddress *addr;
        const gchar *type;

        camel_address_decode (from, resent_from);

        type = CAMEL_RECIPIENT_TYPE_RESENT_TO;
        addr = camel_mime_message_get_recipients (message, type);
        camel_address_cat (recipients, CAMEL_ADDRESS (addr));

        type = CAMEL_RECIPIENT_TYPE_RESENT_CC;
        addr = camel_mime_message_get_recipients (message, type);
        camel_address_cat (recipients, CAMEL_ADDRESS (addr));

        type = CAMEL_RECIPIENT_TYPE_RESENT_BCC;
        addr = camel_mime_message_get_recipients (message, type);
        camel_address_cat (recipients, CAMEL_ADDRESS (addr));

    } else {
        const CamelInternetAddress *addr;
        const gchar *type;

        addr = camel_mime_message_get_from (message);
        camel_address_copy (from, CAMEL_ADDRESS (addr));

        type = CAMEL_RECIPIENT_TYPE_TO;
        addr = camel_mime_message_get_recipients (message, type);
        camel_address_cat (recipients, CAMEL_ADDRESS (addr));

        type = CAMEL_RECIPIENT_TYPE_CC;
        addr = camel_mime_message_get_recipients (message, type);
        camel_address_cat (recipients, CAMEL_ADDRESS (addr));

        type = CAMEL_RECIPIENT_TYPE_BCC;
        addr = camel_mime_message_get_recipients (message, type);
        camel_address_cat (recipients, CAMEL_ADDRESS (addr));
    }

    /* Miscellaneous preparations. */

    info = camel_message_info_new_from_header (
        NULL, CAMEL_MIME_PART (message)->headers);
    ((CamelMessageInfoBase *) info)->size =
        get_message_size (message, cancellable);
    camel_message_info_set_flags (info, CAMEL_MESSAGE_SEEN, ~0);

    /* expand, or remove empty, group addresses */
    em_utils_expand_groups (CAMEL_INTERNET_ADDRESS (recipients));

    /* The rest of the processing happens in a thread. */

    context = g_slice_new0 (AsyncContext);
    context->message = g_object_ref (message);
    context->io_priority = io_priority;
    context->from = from;
    context->recipients = recipients;
    context->info = info;
    context->xev = xev;
    context->post_to_uris = post_to_uris;
    context->transport = transport;

    if (G_IS_CANCELLABLE (cancellable))
        context->cancellable = g_object_ref (cancellable);

    /* Failure here emits a runtime warning but is non-fatal. */
    context->driver = camel_session_get_filter_driver (
        CAMEL_SESSION (session), E_FILTER_SOURCE_OUTGOING, &error);
    if (context->driver != NULL && get_folder_func)
        camel_filter_driver_set_folder_func (
            context->driver, get_folder_func, get_folder_data);
    if (error != NULL) {
        g_warn_if_fail (context->driver == NULL);
        g_warning ("%s", error->message);
        g_error_free (error);
    }

    /* This gets popped in async_context_free(). */
    camel_operation_push_message (
        context->cancellable, _("Sending message"));

    simple = g_simple_async_result_new (
        G_OBJECT (session), callback,
        user_data, e_mail_session_send_to);

    g_simple_async_result_set_check_cancellable (simple, cancellable);

    g_simple_async_result_set_op_res_gpointer (
        simple, context, (GDestroyNotify) async_context_free);

    g_simple_async_result_run_in_thread (
        simple, (GSimpleAsyncThreadFunc)
        mail_session_send_to_thread,
        context->io_priority,
        context->cancellable);

    g_object_unref (simple);
}

gboolean
e_mail_session_send_to_finish (EMailSession *session,
                               GAsyncResult *result,
                               GError **error)
{
    GSimpleAsyncResult *simple;

    g_return_val_if_fail (
        g_simple_async_result_is_valid (
        result, G_OBJECT (session),
        e_mail_session_send_to), FALSE);

    simple = G_SIMPLE_ASYNC_RESULT (result);

    /* Assume success unless a GError is set. */
    return !g_simple_async_result_propagate_error (simple, error);
}

/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_try_uri_to_folder (EMailSession *session,
                                const gchar *folder_uri,
                                GCancellable *cancellable,
                                GError **error)
{
    CamelFolder *folder;
    GError *local_error = NULL;

    folder = e_mail_session_uri_to_folder_sync (
        session, folder_uri, 0, cancellable, &local_error);

    /* Sanity check. */
    g_return_val_if_fail (
        ((folder != NULL) && (local_error == NULL)) ||
        ((folder == NULL) && (local_error != NULL)), NULL);

    /* Disregard specific errors. */

    /* Invalid URI. */
    if (g_error_matches (
        local_error, CAMEL_FOLDER_ERROR,
        CAMEL_FOLDER_ERROR_INVALID))
        g_clear_error (&local_error);

    /* Folder not found. */
    if (g_error_matches (
        local_error, CAMEL_STORE_ERROR,
        CAMEL_STORE_ERROR_NO_FOLDER))
        g_clear_error (&local_error);

    if (local_error != NULL)
        g_propagate_error (error, local_error);

    return folder;
}

/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_ref_origin_folder (EMailSession *session,
                                CamelMimeMessage *message,
                                GCancellable *cancellable,
                                GError **error)
{
    CamelMedium *medium;
    const gchar *header_name;
    const gchar *header_value;

    medium = CAMEL_MEDIUM (message);

    /* Check that a "X-Evolution-Source-Flags" header is present
     * and its value does not contain the substring "FORWARDED". */

    header_name = "X-Evolution-Source-Flags";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    if (strstr (header_value, "FORWARDED") != NULL)
        return NULL;

    /* Check that a "X-Evolution-Source-Message" header is present. */

    header_name = "X-Evolution-Source-Message";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    /* Check that a "X-Evolution-Source-Folder" header is present.
     * Its value specifies the origin folder as a folder URI. */

    header_name = "X-Evolution-Source-Folder";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    /* This may return NULL without setting a GError. */
    return mail_session_try_uri_to_folder (
        session, header_value, cancellable, error);
}

/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_ref_fcc_from_identity (EMailSession *session,
                                    ESource *source,
                                    CamelMimeMessage *message,
                                    GCancellable *cancellable,
                                    GError **error)
{
    ESourceRegistry *registry;
    ESourceMailSubmission *extension;
    CamelFolder *folder = NULL;
    const gchar *extension_name;
    gchar *folder_uri;

    registry = e_mail_session_get_registry (session);
    extension_name = E_SOURCE_EXTENSION_MAIL_SUBMISSION;

    if (source == NULL)
        return NULL;

    if (!e_source_registry_check_enabled (registry, source))
        return NULL;

    if (!e_source_has_extension (source, extension_name))
        return NULL;

    extension = e_source_get_extension (source, extension_name);

    if (e_source_mail_submission_get_replies_to_origin_folder (extension)) {
        GError *local_error = NULL;

        /* This may return NULL without setting a GError. */
        folder = mail_session_ref_origin_folder (
            session, message, cancellable, &local_error);

        if (local_error != NULL) {
            g_warn_if_fail (folder == NULL);
            g_propagate_error (error, local_error);
            return NULL;
        }
    }

    folder_uri = e_source_mail_submission_dup_sent_folder (extension);

    if (folder_uri != NULL && folder == NULL) {
        /* This may return NULL without setting a GError. */
        folder = mail_session_try_uri_to_folder (
            session, folder_uri, cancellable, error);
    }

    g_free (folder_uri);

    return folder;
}

/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_ref_fcc_from_x_identity (EMailSession *session,
                                      CamelMimeMessage *message,
                                      GCancellable *cancellable,
                                      GError **error)
{
    ESource *source;
    ESourceRegistry *registry;
    CamelFolder *folder;
    CamelMedium *medium;
    const gchar *header_name;
    const gchar *header_value;
    gchar *uid;

    medium = CAMEL_MEDIUM (message);
    header_name = "X-Evolution-Identity";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    uid = g_strstrip (g_strdup (header_value));

    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_source (registry, uid);

    /* This may return NULL without setting a GError. */
    folder = mail_session_ref_fcc_from_identity (
        session, source, message, cancellable, error);

    g_clear_object (&source);

    g_free (uid);

    return folder;
}

/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_ref_fcc_from_x_fcc (EMailSession *session,
                                 CamelMimeMessage *message,
                                 GCancellable *cancellable,
                                 GError **error)
{
    CamelMedium *medium;
    const gchar *header_name;
    const gchar *header_value;

    medium = CAMEL_MEDIUM (message);
    header_name = "X-Evolution-Fcc";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    /* This may return NULL without setting a GError. */
    return mail_session_try_uri_to_folder (
        session, header_value, cancellable, error);
}

/* Helper for e_mail_session_get_fcc_for_message_sync() */
static CamelFolder *
mail_session_ref_fcc_from_default_identity (EMailSession *session,
                                            CamelMimeMessage *message,
                                            GCancellable *cancellable,
                                            GError **error)
{
    ESource *source;
    ESourceRegistry *registry;
    CamelFolder *folder;

    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_default_mail_identity (registry);

    /* This may return NULL without setting a GError. */
    folder = mail_session_ref_fcc_from_identity (
        session, source, message, cancellable, error);

    g_clear_object (&source);

    return folder;
}

/**
 * e_mail_session_get_fcc_for_message_sync:
 * @session: an #EMailSession
 * @message: a #CamelMimeMessage
 * @cancellable: optional #GCancellable object, or %NULL
 * @error: return location for a #GError, or %NULL
 *
 * Obtains the preferred "carbon-copy" folder (a.k.a Fcc) for @message
 * by first checking @message for an "X-Evolution-Identity" header, and
 * then an "X-Evolution-Fcc" header.  Failing that, the function checks
 * the default mail identity (if available), and failing even that, the
 * function falls back to the Sent folder from the built-in mail store.
 *
 * Where applicable, the function attempts to honor the
 * #ESourceMailSubmission:replies-to-origin-folder preference.
 *
 * The returned #CamelFolder is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * If a non-recoverable error occurs, the function sets @error and returns
 * %NULL.
 *
 * Returns: a #CamelFolder, or %NULL
 **/
CamelFolder *
e_mail_session_get_fcc_for_message_sync (EMailSession *session,
                                         CamelMimeMessage *message,
                                         GCancellable *cancellable,
                                         GError **error)
{
    CamelFolder *folder = NULL;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
    g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);

    /* Check for "X-Evolution-Identity" header. */
    if (folder == NULL) {
        GError *local_error = NULL;

        /* This may return NULL without setting a GError. */
        folder = mail_session_ref_fcc_from_x_identity (
            session, message, cancellable, &local_error);

        if (local_error != NULL) {
            g_warn_if_fail (folder == NULL);
            g_propagate_error (error, local_error);
            return NULL;
        }
    }

    /* Check for "X-Evolution-Fcc" header. */
    if (folder == NULL) {
        GError *local_error = NULL;

        /* This may return NULL without setting a GError. */
        folder = mail_session_ref_fcc_from_x_fcc (
            session, message, cancellable, &local_error);

        if (local_error != NULL) {
            g_warn_if_fail (folder == NULL);
            g_propagate_error (error, local_error);
            return NULL;
        }
    }

    /* Check the default mail identity. */
    if (folder == NULL) {
        GError *local_error = NULL;

        /* This may return NULL without setting a GError. */
        folder = mail_session_ref_fcc_from_default_identity (
            session, message, cancellable, &local_error);

        if (local_error != NULL) {
            g_warn_if_fail (folder == NULL);
            g_propagate_error (error, local_error);
            return NULL;
        }
    }

    /* Last resort - local Sent folder. */
    if (folder == NULL) {
        folder = e_mail_session_get_local_folder (
            session, E_MAIL_LOCAL_FOLDER_SENT);
        g_object_ref (folder);
    }

    return folder;
}

/* Helper for e_mail_session_get_fcc_for_message() */
static void
mail_session_get_fcc_for_message_thread (GSimpleAsyncResult *simple,
                                         GObject *source_object,
                                         GCancellable *cancellable)
{
    AsyncContext *async_context;
    GError *local_error = NULL;

    async_context = g_simple_async_result_get_op_res_gpointer (simple);

    async_context->folder =
        e_mail_session_get_fcc_for_message_sync (
            E_MAIL_SESSION (source_object),
            async_context->message,
            cancellable, &local_error);

    if (local_error != NULL)
        g_simple_async_result_take_error (simple, local_error);
}

/**
 * e_mail_session_get_fcc_for_message:
 * @session: an #EMailSession
 * @message: a #CamelMimeMessage
 * @io_priority: the I/O priority of the request
 * @cancellable: optional #GCancellable object, or %NULL
 * @callback: a #GAsyncReadyCallback to call when the request is satisfied
 * @user_data: data to pass to the callback function
 *
 * Asynchronously obtains the preferred "carbon-copy" folder (a.k.a Fcc) for
 * @message by first checking @message for an "X-Evolution-Identity" header,
 * and then an "X-Evolution-Fcc" header.  Failing that, the function checks
 * the default mail identity (if available), and failing even that, the
 * function falls back to the Sent folder from the built-in mail store.
 *
 * Where applicable, the function attempts to honor the
 * #ESourceMailSubmission:replies-to-origin-folder preference.
 *
 * When the operation is finished, @callback will be called.  You can then
 * call e_mail_session_get_fcc_for_message_finish() to get the result of the
 * operation.
 **/
void
e_mail_session_get_fcc_for_message (EMailSession *session,
                                    CamelMimeMessage *message,
                                    gint io_priority,
                                    GCancellable *cancellable,
                                    GAsyncReadyCallback callback,
                                    gpointer user_data)
{
    GSimpleAsyncResult *simple;
    AsyncContext *async_context;

    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));

    async_context = g_slice_new0 (AsyncContext);
    async_context->message = g_object_ref (message);

    simple = g_simple_async_result_new (
        G_OBJECT (session), callback, user_data,
        e_mail_session_get_fcc_for_message);

    g_simple_async_result_set_check_cancellable (simple, cancellable);

    g_simple_async_result_set_op_res_gpointer (
        simple, async_context, (GDestroyNotify) async_context_free);

    g_simple_async_result_run_in_thread (
        simple, mail_session_get_fcc_for_message_thread,
        io_priority, cancellable);

    g_object_unref (simple);
}

/**
 * e_mail_session_get_fcc_for_message_finish:
 * @session: an #EMailSession
 * @result: a #GAsyncResult
 * @error: return location for a #GError, or %NULL
 *
 * Finishes the operation started with e_mail_session_get_fcc_for_message().
 *
 * The returned #CamelFolder is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * If a non-recoverable error occurred, the function sets @error and
 * returns %NULL.
 *
 * Returns: a #CamelFolder, or %NULL
 **/
CamelFolder *
e_mail_session_get_fcc_for_message_finish (EMailSession *session,
                                           GAsyncResult *result,
                                           GError **error)
{
    GSimpleAsyncResult *simple;
    AsyncContext *async_context;

    g_return_val_if_fail (
        g_simple_async_result_is_valid (
        result, G_OBJECT (session),
        e_mail_session_get_fcc_for_message), NULL);

    simple = G_SIMPLE_ASYNC_RESULT (result);
    async_context = g_simple_async_result_get_op_res_gpointer (simple);

    if (g_simple_async_result_propagate_error (simple, error))
        return NULL;

    g_return_val_if_fail (async_context->folder != NULL, NULL);

    return g_object_ref (async_context->folder);
}

/**
 * e_mail_session_ref_transport:
 * @session: an #EMailSession
 * @transport_uid: the UID of a mail transport
 *
 * Returns the transport #CamelService instance for @transport_uid,
 * verifying first that the @transport_uid is indeed a mail transport and
 * that the corresponding #ESource is enabled.  If these checks fail, the
 * function returns %NULL.
 *
 * The returned #CamelService is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * Returns: a #CamelService, or %NULL
 **/
CamelService *
e_mail_session_ref_transport (EMailSession *session,
                              const gchar *transport_uid)
{
    ESourceRegistry *registry;
    ESource *source = NULL;
    CamelService *transport = NULL;
    const gchar *extension_name;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
    g_return_val_if_fail (transport_uid != NULL, NULL);

    registry = e_mail_session_get_registry (session);
    extension_name = E_SOURCE_EXTENSION_MAIL_TRANSPORT;

    source = e_source_registry_ref_source (registry, transport_uid);

    if (source == NULL)
        goto exit;

    if (!e_source_registry_check_enabled (registry, source))
        goto exit;

    if (!e_source_has_extension (source, extension_name))
        goto exit;

    transport = camel_session_ref_service (
        CAMEL_SESSION (session), transport_uid);

    /* Sanity check. */
    if (transport != NULL)
        g_warn_if_fail (CAMEL_IS_TRANSPORT (transport));

exit:
    g_clear_object (&source);

    return transport;
}

/* Helper for e_mail_session_ref_default_transport()
 * and mail_session_ref_transport_from_x_identity(). */
static CamelService *
mail_session_ref_transport_for_identity (EMailSession *session,
                                         ESource *source)
{
    ESourceRegistry *registry;
    ESourceMailSubmission *extension;
    CamelService *transport = NULL;
    const gchar *extension_name;
    gchar *uid;

    registry = e_mail_session_get_registry (session);
    extension_name = E_SOURCE_EXTENSION_MAIL_SUBMISSION;

    if (source == NULL)
        return NULL;

    if (!e_source_registry_check_enabled (registry, source))
        return NULL;

    if (!e_source_has_extension (source, extension_name))
        return NULL;

    extension = e_source_get_extension (source, extension_name);
    uid = e_source_mail_submission_dup_transport_uid (extension);

    if (uid != NULL) {
        transport = e_mail_session_ref_transport (session, uid);
        g_free (uid);
    }

    return transport;
}

/**
 * e_mail_session_ref_default_transport:
 * @session: an #EMailSession
 *
 * Returns the default transport #CamelService instance according to
 * #ESourceRegistry's #ESourceRegistry:default-mail-identity setting,
 * verifying first that the #ESourceMailSubmission:transport-uid named by
 * the #ESourceRegistry:default-mail-identity is indeed a mail transport,
 * and that the corresponding #ESource is enabled.  If these checks fail,
 * the function returns %NULL.
 *
 * The returned #CamelService is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * Returns: a #CamelService, or %NULL
 **/
CamelService *
e_mail_session_ref_default_transport (EMailSession *session)
{
    ESource *source;
    ESourceRegistry *registry;
    CamelService *transport;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);

    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_default_mail_identity (registry);
    transport = mail_session_ref_transport_for_identity (session, source);
    g_clear_object (&source);

    return transport;
}

/* Helper for e_mail_session_ref_transport_for_message() */
static CamelService *
mail_session_ref_transport_from_x_identity (EMailSession *session,
                                            CamelMimeMessage *message)
{
    ESource *source;
    ESourceRegistry *registry;
    CamelMedium *medium;
    CamelService *transport;
    const gchar *header_name;
    const gchar *header_value;
    gchar *uid;

    medium = CAMEL_MEDIUM (message);
    header_name = "X-Evolution-Identity";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    uid = g_strstrip (g_strdup (header_value));

    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_source (registry, uid);
    transport = mail_session_ref_transport_for_identity (session, source);
    g_clear_object (&source);

    g_free (uid);

    return transport;
}

/* Helper for e_mail_session_ref_transport_for_message() */
static CamelService *
mail_session_ref_transport_from_x_transport (EMailSession *session,
                                             CamelMimeMessage *message)
{
    CamelMedium *medium;
    CamelService *transport;
    const gchar *header_name;
    const gchar *header_value;
    gchar *uid;

    medium = CAMEL_MEDIUM (message);
    header_name = "X-Evolution-Transport";
    header_value = camel_medium_get_header (medium, header_name);

    if (header_value == NULL)
        return NULL;

    uid = g_strstrip (g_strdup (header_value));

    transport = e_mail_session_ref_transport (session, uid);

    g_free (uid);

    return transport;
}

/**
 * e_mail_session_ref_transport_for_message:
 * @session: an #EMailSession
 * @message: a #CamelMimeMessage
 *
 * Returns the preferred transport #CamelService instance for @message by
 * first checking @message for an "X-Evolution-Identity" header, and then
 * an "X-Evolution-Transport" header.  Failing that, the function returns
 * the default transport #CamelService instance (if available).
 *
 * The returned #CamelService is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * Returns: a #CamelService, or %NULL
 **/
CamelService *
e_mail_session_ref_transport_for_message (EMailSession *session,
                                          CamelMimeMessage *message)
{
    CamelService *transport = NULL;

    g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
    g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);

    /* Check for "X-Evolution-Identity" header. */
    if (transport == NULL)
        transport = mail_session_ref_transport_from_x_identity (
            session, message);

    /* Check for "X-Evolution-Transport" header. */
    if (transport == NULL)
        transport = mail_session_ref_transport_from_x_transport (
            session, message);

    /* Fall back to the default mail transport. */
    if (transport == NULL)
        transport = e_mail_session_ref_default_transport (session);

    return transport;
}