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;
}
/* although we dont do anythign smart here yet, there is no need for this interface to
* be available to anyone else.
* This can also be used to hook into which folders are being updated, and occasionally
* let them refresh */
static CamelFolder *
receive_get_folder (CamelFilterDriver *d,
const gchar *uri,
gpointer data,
GError **error)
{
struct _send_info *info = data;
CamelFolder *folder;
EMailSession *session;
struct _folder_info *oldinfo;
gpointer oldkey, oldinfoptr;
g_mutex_lock (info->data->lock);
oldinfo = g_hash_table_lookup (info->data->folders, uri);
g_mutex_unlock (info->data->lock);
if (oldinfo) {
g_object_ref (oldinfo->folder);
return oldinfo->folder;
}
session = info->session;
/* FIXME Not passing a GCancellable here. */
folder = e_mail_session_uri_to_folder_sync (
session, uri, 0, NULL, error);
if (!folder)
return NULL;
/* we recheck that the folder hasn't snuck in while we were loading it... */
/* and we assume the newer one is the same, but unref the old one anyway */
g_mutex_lock (info->data->lock);
if (g_hash_table_lookup_extended (
info->data->folders, uri, &oldkey, &oldinfoptr)) {
oldinfo = (struct _folder_info *) oldinfoptr;
g_object_unref (oldinfo->folder);
oldinfo->folder = folder;
} else {
oldinfo = g_malloc0 (sizeof (*oldinfo));
oldinfo->folder = folder;
oldinfo->uri = g_strdup (uri);
g_hash_table_insert (info->data->folders, oldinfo->uri, oldinfo);
}
g_object_ref (folder);
g_mutex_unlock (info->data->lock);
return folder;
}
static void
refresh_folders_exec (struct _refresh_folders_msg *m,
GCancellable *cancellable,
GError **error)
{
CamelFolder *folder;
EMailSession *session;
gint i;
GError *local_error = NULL;
gulong handler_id = 0;
if (cancellable)
handler_id = g_signal_connect (
m->info->cancellable, "cancelled",
G_CALLBACK (main_op_cancelled_cb), cancellable);
get_folders (m->store, m->folders, m->finfo);
camel_operation_push_message (m->info->cancellable, _("Updating..."));
session = m->info->session;
for (i = 0; i < m->folders->len; i++) {
folder = e_mail_session_uri_to_folder_sync (
session,
m->folders->pdata[i], 0,
cancellable, &local_error);
if (folder) {
/* FIXME Not passing a GError here. */
camel_folder_synchronize_sync (
folder, FALSE, cancellable, NULL);
camel_folder_refresh_info_sync (folder, cancellable, NULL);
g_object_unref (folder);
} else if (local_error != NULL) {
g_warning ("Failed to refresh folders: %s", local_error->message);
g_clear_error (&local_error);
}
if (g_cancellable_is_cancelled (m->info->cancellable))
break;
if (m->info->state != SEND_CANCELLED)
camel_operation_progress (
m->info->cancellable, 100 * i / m->folders->len);
}
camel_operation_pop_message (m->info->cancellable);
if (cancellable)
g_signal_handler_disconnect (m->info->cancellable, handler_id);
}
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;
}
static void
vfolder_adduri_exec (struct _adduri_msg *m,
GCancellable *cancellable,
GError **error)
{
GList *l;
EMailSession *session;
CamelFolder *folder = NULL;
MailFolderCache *folder_cache;
if (vfolder_shutdown)
return;
session = e_mail_backend_get_session (m->backend);
folder_cache = e_mail_session_get_folder_cache (session);
/* we dont try lookup the cache if we are removing it, its no longer there */
if (!m->remove &&
!mail_folder_cache_get_folder_from_uri (folder_cache, m->uri, &folder)) {
g_warning (
"Folder '%s' disappeared while I was "
"adding/removing it to/from my vfolder", m->uri);
return;
}
if (folder == NULL)
folder = e_mail_session_uri_to_folder_sync (
session, m->uri, 0, cancellable, error);
if (folder != NULL) {
l = m->folders;
while (l && !vfolder_shutdown) {
if (m->remove)
camel_vee_folder_remove_folder (
CAMEL_VEE_FOLDER (l->data), folder);
else
camel_vee_folder_add_folder ((CamelVeeFolder *) l->data, folder);
l = l->next;
}
g_object_unref (folder);
}
}
static void
vfolder_setup_exec (struct _setup_msg *m,
GCancellable *cancellable,
GError **error)
{
GList *l, *list = NULL;
CamelFolder *folder;
camel_vee_folder_set_expression ((CamelVeeFolder *) m->folder, m->query);
l = m->sources_uri;
while (l && !vfolder_shutdown) {
d(printf(" Adding uri: %s\n", (gchar *)l->data));
/* FIXME Not passing a GCancellable or GError here. */
folder = e_mail_session_uri_to_folder_sync (
m->session, l->data, 0, NULL, NULL);
if (folder != NULL)
list = g_list_append (list, folder);
l = l->next;
}
l = m->sources_folder;
while (l && !vfolder_shutdown) {
g_object_ref (l->data);
list = g_list_append (list, l->data);
l = l->next;
}
if (!vfolder_shutdown)
camel_vee_folder_set_folders ((CamelVeeFolder *) m->folder, list);
l = list;
while (l) {
g_object_unref (l->data);
l = l->next;
}
g_list_free (list);
}
/* 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;
}
static void
mail_send_short_to_thread (GSimpleAsyncResult *simple, EMailSession *session,
GCancellable *cancellable)
{
SendAsyncContext *context;
CamelFolder *local_sent_folder;
CamelProvider *provider;
CamelService *service;
CamelInternetAddress *cia;
const gchar *addr;
gint i, len;
gboolean copy_to_sent = TRUE;
GError *error = NULL;
gboolean success = FALSE;
gboolean did_connect = FALSE;
gboolean cancelled = FALSE;
context = g_simple_async_result_get_op_res_gpointer (simple);
/* Connect transport service */
service = context->transport;
if (camel_service_get_connection_status (service) !=
CAMEL_SERVICE_CONNECTED) {
did_connect = TRUE;
if (!camel_service_connect_sync (service, &error)) {
mail_send_short_connection_fail (context);
g_simple_async_result_take_error (simple, error);
return;
}
}
provider = camel_service_get_provider (service);
if (provider->flags & CAMEL_PROVIDER_DISABLE_SENT_FOLDER)
copy_to_sent = FALSE;
/* Send the message to each individual recipient. */
len = camel_address_length (context->recipients);
for (i = 0; i < len; i++) {
if (!cancelled) {
if (!camel_internet_address_get(
CAMEL_INTERNET_ADDRESS(context->recipients),
i, NULL, &addr))
continue;
cia = camel_internet_address_new ();
camel_internet_address_add (cia, NULL, addr);
camel_transport_send_to_sync (
CAMEL_TRANSPORT (service), context->message,
context->from, CAMEL_ADDRESS(cia),
cancellable, &error);
g_object_unref(cia);
}
if (error) {
g_variant_builder_add (context->result, "(sssi)", addr,
error->message,
g_quark_to_string(error->domain),
error->code);
if (g_error_matches (error, G_IO_ERROR,
G_IO_ERROR_CANCELLED))
cancelled = TRUE;
else
g_clear_error (&error);
} else {
g_variant_builder_add (context->result, "(sssi)", addr,
"", "", 0);
success = TRUE;
}
camel_operation_progress (cancellable, (i+1)*100/len);
}
g_clear_error (&error);
if (did_connect)
camel_service_disconnect_sync (service, FALSE, NULL);
/*** Post Processing ***/
if (!success) {
g_simple_async_result_set_error (
simple, E_MAIL_ERROR,
E_MAIL_ERROR_POST_PROCESSING,
_("All recipients failed"));
return;
}
/* 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;
g_clear_error (&error);
}
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);
/* Try to extract a CamelFolder from the Sent folder URI. */
if (context->sent_folder_uri != NULL) {
context->sent_folder = e_mail_session_uri_to_folder_sync (
session, context->sent_folder_uri, 0,
cancellable, &error);
if (error != NULL) {
g_warn_if_fail (context->sent_folder == NULL);
g_clear_error (&error);
}
}
/* Fall back to the local Sent folder. */
if (context->sent_folder == NULL)
context->sent_folder = g_object_ref (local_sent_folder);
/* Append the message. */
camel_folder_append_message_sync (
context->sent_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 appending to a remote Sent folder failed,
* try appending to the local Sent folder. */
if (context->sent_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) {
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 != NULL) {
g_simple_async_result_set_error (simple, E_MAIL_ERROR,
E_MAIL_ERROR_POST_PROCESSING, "%s", error->message);
}
/* Synchronize the Sent folder. */
if (context->sent_folder != NULL)
camel_folder_synchronize_sync (context->sent_folder, FALSE,
cancellable, NULL);
}
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. */
/* XXX Leave this untranslated in gnome-3-8.
* It was added during the string freeze,
* but should rarely ever be seen by users. */
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);
}
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;
}
static void
mail_session_send_to_thread (GSimpleAsyncResult *simple,
EMailSession *session,
GCancellable *cancellable)
{
AsyncContext *context;
CamelFolder *local_sent_folder;
GString *error_messages;
gboolean copy_to_sent = TRUE;
guint ii;
GError *error = NULL;
context = g_simple_async_result_get_op_res_gpointer (simple);
/* Send the message to all recipients. */
if (camel_address_length (context->recipients) > 0) {
CamelProvider *provider;
CamelService *service;
gboolean did_connect = FALSE;
service = camel_session_get_service (
CAMEL_SESSION (session), context->transport_uid);
if (!CAMEL_IS_TRANSPORT (service)) {
g_simple_async_result_set_error (simple,
CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_URL_INVALID,
_("Cannot get transport for account '%s'"),
context->transport_uid);
return;
}
if (camel_service_get_connection_status (service) != CAMEL_SERVICE_CONNECTED) {
did_connect = TRUE;
/* XXX This API does not allow for cancellation. */
if (!em_utils_connect_service_sync (service, cancellable, &error)) {
g_simple_async_result_take_error (simple, error);
return;
}
}
provider = camel_service_get_provider (service);
if (provider->flags & CAMEL_PROVIDER_DISABLE_SENT_FOLDER)
copy_to_sent = FALSE;
camel_transport_send_to_sync (
CAMEL_TRANSPORT (service),
context->message, context->from,
context->recipients, cancellable, &error);
if (did_connect)
em_utils_disconnect_service_sync (
service, error == NULL,
cancellable, error ? NULL : &error);
if (error != NULL) {
g_simple_async_result_take_error (simple, error);
return;
}
}
/* 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 (!copy_to_sent)
goto cleanup;
/* Append the sent message to a Sent folder. */
local_sent_folder = e_mail_local_get_folder (E_MAIL_LOCAL_FOLDER_SENT);
/* Try to extract a CamelFolder from the Sent folder URI. */
if (context->sent_folder_uri != NULL) {
context->sent_folder = e_mail_session_uri_to_folder_sync (
session, context->sent_folder_uri, 0,
cancellable, &error);
if (error != NULL) {
g_warn_if_fail (context->sent_folder == NULL);
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."),
context->sent_folder_uri, error->message);
g_clear_error (&error);
}
}
/* Fall back to the local Sent folder. */
if (context->sent_folder == NULL)
context->sent_folder = g_object_ref (local_sent_folder);
/* Append the message. */
camel_folder_append_message_sync (
context->sent_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 appending to a remote Sent folder failed,
* try appending to the local Sent folder. */
if (context->sent_folder != local_sent_folder) {
const gchar *description;
description = camel_folder_get_description (
context->sent_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);
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 (context->sent_folder != NULL)
camel_folder_synchronize_sync (
context->sent_folder, FALSE, cancellable, NULL);
g_string_free (error_messages, TRUE);
}
static void
mail_attachment_handler_x_uid_list (EAttachmentView *view,
GdkDragContext *drag_context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
EAttachmentHandler *handler)
{
static GdkAtom atom = GDK_NONE;
EMailAttachmentHandlerPrivate *priv;
CamelDataWrapper *wrapper;
CamelMimeMessage *message;
CamelMultipart *multipart;
CamelMimePart *mime_part;
CamelFolder *folder = NULL;
EAttachment *attachment;
EAttachmentStore *store;
EMailSession *session;
GPtrArray *uids;
const gchar *data;
const gchar *cp, *end;
gchar *description;
gpointer parent;
gint length;
guint ii;
GError *local_error = NULL;
if (G_UNLIKELY (atom == GDK_NONE))
atom = gdk_atom_intern_static_string ("x-uid-list");
if (gtk_selection_data_get_target (selection_data) != atom)
return;
store = e_attachment_view_get_store (view);
priv = E_MAIL_ATTACHMENT_HANDLER_GET_PRIVATE (handler);
parent = gtk_widget_get_toplevel (GTK_WIDGET (view));
parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
uids = g_ptr_array_new ();
data = (const gchar *) gtk_selection_data_get_data (selection_data);
length = gtk_selection_data_get_length (selection_data);
/* The UID list is delimited by NUL characters.
* Brilliant. So we can't use g_strsplit(). */
cp = data;
end = data + length;
while (cp < end) {
const gchar *start = cp;
while (cp < end && *cp != '\0')
cp++;
/* Skip the first string. */
if (start > data)
g_ptr_array_add (uids, g_strndup (start, cp - start));
cp++;
}
if (uids->len == 0)
goto exit;
session = e_mail_backend_get_session (priv->backend);
/* The first string is the folder URI. */
/* FIXME Not passing a GCancellable here. */
folder = e_mail_session_uri_to_folder_sync (
session, data, 0, NULL, &local_error);
if (folder == NULL)
goto exit;
/* Handle one message. */
if (uids->len == 1) {
const gchar *message_uid;
message_uid = g_ptr_array_index (uids, 0);
/* FIXME Not passing a GCancellable here. */
message = camel_folder_get_message_sync (
folder, message_uid, NULL, &local_error);
if (message == NULL)
goto exit;
attachment = e_attachment_new_for_message (message);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
g_object_unref (message);
goto exit;
}
/* Build a multipart/digest message out of the UIDs. */
multipart = camel_multipart_new ();
wrapper = CAMEL_DATA_WRAPPER (multipart);
camel_data_wrapper_set_mime_type (wrapper, "multipart/digest");
camel_multipart_set_boundary (multipart, NULL);
for (ii = 0; ii < uids->len; ii++) {
/* FIXME Not passing a GCancellable here. */
message = camel_folder_get_message_sync (
folder, uids->pdata[ii], NULL, &local_error);
if (message == NULL) {
g_object_unref (multipart);
goto exit;
}
mime_part = camel_mime_part_new ();
wrapper = CAMEL_DATA_WRAPPER (message);
camel_mime_part_set_disposition (mime_part, "inline");
camel_medium_set_content (
CAMEL_MEDIUM (mime_part), wrapper);
camel_mime_part_set_content_type (mime_part, "message/rfc822");
camel_multipart_add_part (multipart, mime_part);
g_object_unref (mime_part);
g_object_unref (message);
}
mime_part = camel_mime_part_new ();
wrapper = CAMEL_DATA_WRAPPER (multipart);
camel_medium_set_content (CAMEL_MEDIUM (mime_part), wrapper);
description = g_strdup_printf (
ngettext (
"%d attached message",
"%d attached messages",
uids->len),
uids->len);
camel_mime_part_set_description (mime_part, description);
g_free (description);
attachment = e_attachment_new ();
e_attachment_set_mime_part (attachment, mime_part);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
g_object_unref (mime_part);
g_object_unref (multipart);
exit:
if (local_error != NULL) {
const gchar *folder_name = data;
if (folder != NULL)
folder_name = camel_folder_get_display_name (folder);
e_alert_run_dialog_for_args (
parent, "mail-composer:attach-nomessages",
folder_name, local_error->message, NULL);
g_clear_error (&local_error);
}
if (folder != NULL)
g_object_unref (folder);
g_ptr_array_free (uids, TRUE);
g_signal_stop_emission_by_name (view, "drag-data-received");
}
static void
dbx_import_file (DbxImporter *m)
{
EShell *shell;
EShellBackend *shell_backend;
EMailSession *session;
GCancellable *cancellable;
gchar *filename;
CamelFolder *folder;
gint tmpfile;
gint i;
gint missing = 0;
m->status_what = NULL;
filename = g_filename_from_uri (
((EImportTargetURI *) m->target)->uri_src, NULL, NULL);
/* Destination folder, was set in our widget */
m->parent_uri = g_strdup (((EImportTargetURI *) m->target)->uri_dest);
cancellable = m->base.cancellable;
/* XXX Dig up the EMailSession from the default EShell.
* Since the EImport framework doesn't allow for user
* data, I don't see how else to get to it. */
shell = e_shell_get_default ();
shell_backend = e_shell_get_backend_by_name (shell, "mail");
session = e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend));
camel_operation_push_message (NULL, _("Importing “%s”"), filename);
folder = e_mail_session_uri_to_folder_sync (
session, m->parent_uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, &m->base.error);
if (!folder)
return;
d (printf ("importing to %s\n", camel_folder_get_full_name (folder)));
camel_folder_freeze (folder);
filename = g_filename_from_uri (
((EImportTargetURI *) m->target)->uri_src, NULL, NULL);
m->dbx_fd = g_open (filename, O_RDONLY, 0);
g_free (filename);
if (m->dbx_fd == -1) {
g_set_error (
&m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
"Failed to open import file");
goto out;
}
if (!dbx_load_indices (m))
goto out;
tmpfile = e_mkstemp ("dbx-import-XXXXXX");
if (tmpfile == -1) {
g_set_error (
&m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
"Failed to create temporary file for import");
goto out;
}
for (i = 0; i < m->index_count; i++) {
CamelMessageInfo *info;
CamelMimeMessage *msg;
CamelMimeParser *mp;
gint dbx_flags = 0;
gint flags = 0;
gboolean success;
camel_operation_progress (NULL, 100 * i / m->index_count);
camel_operation_progress (cancellable, 100 * i / m->index_count);
if (!dbx_read_email (m, m->indices[i], tmpfile, &dbx_flags)) {
d (
printf ("Cannot read email index %d at %x\n",
i, m->indices[i]));
if (m->base.error != NULL)
goto out;
missing++;
continue;
}
if (dbx_flags & 0x40)
flags |= CAMEL_MESSAGE_DELETED;
if (dbx_flags & 0x80)
flags |= CAMEL_MESSAGE_SEEN;
if (dbx_flags & 0x80000)
flags |= CAMEL_MESSAGE_ANSWERED;
mp = camel_mime_parser_new ();
lseek (tmpfile, 0, SEEK_SET);
camel_mime_parser_init_with_fd (mp, tmpfile);
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (msg);
g_object_unref (mp);
break;
}
info = camel_message_info_new (NULL);
camel_message_info_set_flags (info, flags, ~0);
success = camel_folder_append_message_sync (
folder, msg, info, NULL,
cancellable, &m->base.error);
g_clear_object (&info);
g_object_unref (msg);
if (!success) {
g_object_unref (mp);
break;
}
}
out:
if (m->dbx_fd != -1)
close (m->dbx_fd);
if (m->indices)
g_free (m->indices);
/* FIXME Not passing GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
g_object_unref (folder);
if (missing && m->base.error == NULL) {
g_set_error (
&m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
"%d messages imported correctly; %d message "
"bodies were not present in the DBX file",
m->index_count - missing, missing);
}
camel_operation_pop_message (NULL);
}
static void
import_kmail_folder (struct _import_mbox_msg *m,
gchar *k_path_in,
GCancellable *cancellable,
GError **error)
{
const gchar *special_folders []= {"cur", "tmp", "new", NULL};
gchar *special_path;
const CamelStore *store;
CamelFolder *folder;
CamelMimeParser *mp = NULL;
CamelMessageInfo *info;
CamelMimeMessage *msg;
guint32 flags = 0;
gchar *e_uri, *e_path;
gchar *k_path;
const gchar *d;
gchar *mail_url;
GDir *dir;
struct stat st;
gint fd, i;
e_uri = kuri_to_euri (k_path_in);
/* we need to drop some folders, like: Trash */
if (!e_uri)
return;
/* In case we using async way in the future */
k_path = g_strdup (k_path_in);
store = evolution_get_local_store ();
e_path = e_uri + strlen (EVOLUTION_LOCAL_BASE) + 1;
e_mail_store_create_folder_sync ((CamelStore *)store, e_path, NULL, NULL);
folder = e_mail_session_uri_to_folder_sync (
m->session, e_uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, NULL);
if (folder == NULL) {
g_free (k_path);
g_warning ("evolution error: cannot get the folder\n");
return;
}
camel_operation_push_message (
cancellable, _("Importing '%s'"),
camel_folder_get_display_name (folder));
camel_folder_freeze (folder);
for (i = 0; special_folders [i]; i++) {
camel_operation_progress (cancellable, 100*i/3);
special_path = g_build_filename (k_path, special_folders[i], NULL);
dir = g_dir_open (special_path, 0, NULL);
while ((d = g_dir_read_name (dir))) {
if ((strcmp (d, ".") == 0) || (strcmp (d, "..") == 0)) {
continue;
}
mail_url = g_build_filename (special_path, d, NULL);
if (g_stat (mail_url, &st) == -1) {
g_free (mail_url);
continue;
}
if (S_ISREG (st.st_mode)) {
fd = g_open (mail_url, O_RDONLY | O_BINARY, 0);
g_free (mail_url);
if (fd == -1) {
continue;
}
mp = camel_mime_parser_new ();
camel_mime_parser_scan_from (mp, FALSE);
if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
/* will never happen - 0 is unconditionally returned */
g_object_unref (mp);
continue;
}
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (mp);
g_object_unref (msg);
continue;
}
info = camel_message_info_new (NULL);
if (strcmp (special_folders[i], "cur") == 0) {
flags |= CAMEL_MESSAGE_SEEN;
} else if (strcmp (special_folders[i], "tmp") == 0) {
flags |= CAMEL_MESSAGE_DELETED; /* Mark the 'tmp' mails as 'deleted' */
}
camel_message_info_set_flags (info, flags, ~0);
camel_folder_append_message_sync (
folder, msg, info, NULL,
cancellable, error);
camel_message_info_unref (info);
g_object_unref (msg);
g_object_unref (mp);
} else {
g_free (mail_url);
}
}
}
camel_operation_progress (cancellable, 100);
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
camel_operation_pop_message (cancellable);
g_free (k_path);
}
static void
import_mbox_exec (struct _import_mbox_msg *m,
GCancellable *cancellable,
GError **error)
{
CamelFolder *folder;
CamelMimeParser *mp = NULL;
struct stat st;
gint fd;
if (g_stat (m->path, &st) == -1) {
g_warning (
"cannot find source file to import '%s': %s",
m->path, g_strerror (errno));
return;
}
if (m->uri == NULL || m->uri[0] == 0)
folder = e_mail_session_get_local_folder (
m->session, E_MAIL_LOCAL_FOLDER_INBOX);
else
folder = e_mail_session_uri_to_folder_sync (
m->session, m->uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, error);
if (folder == NULL)
return;
if (S_ISREG (st.st_mode)) {
gboolean any_read = FALSE;
fd = g_open (m->path, O_RDONLY | O_BINARY, 0);
if (fd == -1) {
g_warning (
"cannot find source file to import '%s': %s",
m->path, g_strerror (errno));
goto fail1;
}
mp = camel_mime_parser_new ();
camel_mime_parser_scan_from (mp, TRUE);
if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
/* will never happen - 0 is unconditionally returned */
goto fail2;
}
camel_operation_push_message (
cancellable, _("Importing '%s'"),
camel_folder_get_display_name (folder));
camel_folder_freeze (folder);
while (camel_mime_parser_step (mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM &&
!g_cancellable_is_cancelled (cancellable)) {
CamelMimeMessage *msg;
gint pc = 0;
any_read = TRUE;
if (st.st_size > 0)
pc = (gint) (100.0 * ((gdouble)
camel_mime_parser_tell (mp) /
(gdouble) st.st_size));
camel_operation_progress (cancellable, pc);
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (msg);
break;
}
import_mbox_add_message (folder, msg, cancellable, error);
g_object_unref (msg);
if (error && *error != NULL)
break;
camel_mime_parser_step (mp, NULL, NULL);
}
if (!any_read && !g_cancellable_is_cancelled (cancellable)) {
CamelStream *stream;
stream = camel_stream_fs_new_with_name (m->path, O_RDONLY, 0, NULL);
if (stream) {
CamelMimeMessage *msg;
msg = camel_mime_message_new ();
if (camel_data_wrapper_construct_from_stream_sync ((CamelDataWrapper *) msg, stream, NULL, NULL))
import_mbox_add_message (folder, msg, cancellable, error);
g_object_unref (msg);
g_object_unref (stream);
}
}
/* Not passing a GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
camel_operation_pop_message (cancellable);
fail2:
g_object_unref (mp);
}
fail1:
/* Not passing a GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
g_object_unref (folder);
/* 'fd' is freed together with 'mp' */
/* coverity[leaked_handle] */
}
