static gssize
mime_message_write_to_stream_sync (CamelDataWrapper *data_wrapper,
CamelStream *stream,
GCancellable *cancellable,
GError **error)
{
CamelDataWrapperClass *data_wrapper_class;
CamelMimeMessage *mm = CAMEL_MIME_MESSAGE (data_wrapper);
/* force mandatory headers ... */
if (mm->from == NULL) {
/* FIXME: should we just abort? Should we make one up? */
g_warning ("No from set for message");
camel_medium_set_header ((CamelMedium *) mm, "From", "");
}
if (!camel_medium_get_header ((CamelMedium *) mm, "Date"))
camel_mime_message_set_date (mm, CAMEL_MESSAGE_DATE_CURRENT, 0);
if (mm->subject == NULL)
camel_mime_message_set_subject (mm, "No Subject");
if (mm->message_id == NULL)
camel_mime_message_set_message_id (mm, NULL);
/* FIXME: "To" header needs to be set explicitly as well ... */
if (!camel_medium_get_header ((CamelMedium *) mm, "Mime-Version"))
camel_medium_set_header ((CamelMedium *) mm, "Mime-Version", "1.0");
/* Chain up to parent's write_to_stream_sync() method. */
data_wrapper_class = CAMEL_DATA_WRAPPER_CLASS (
camel_mime_message_parent_class);
return data_wrapper_class->write_to_stream_sync (
data_wrapper, stream, cancellable, error);
}
static void
mime_message_ensure_required_headers (CamelMimeMessage *message)
{
CamelMedium *medium = CAMEL_MEDIUM (message);
if (message->from == NULL) {
camel_medium_set_header (medium, "From", "");
}
if (!camel_medium_get_header (medium, "Date"))
camel_mime_message_set_date (
message, CAMEL_MESSAGE_DATE_CURRENT, 0);
if (message->subject == NULL)
camel_mime_message_set_subject (message, "No Subject");
if (message->message_id == NULL)
camel_mime_message_set_message_id (message, NULL);
/* FIXME: "To" header needs to be set explicitly as well ... */
if (!camel_medium_get_header (medium, "Mime-Version"))
camel_medium_set_header (medium, "Mime-Version", "1.0");
}
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);
}
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;
EAccount *account = NULL;
GPtrArray *post_to_uris;
struct _camel_header_raw *xev;
struct _camel_header_raw *header;
const gchar *string;
const gchar *resent_from;
gchar *transport_uid = NULL;
gchar *sent_folder_uri = NULL;
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);
xev = mail_tool_remove_xevolution_headers (message);
/* Extract directives from X-Evolution headers. */
string = camel_header_raw_find (&xev, "X-Evolution-Account", NULL);
if (string != NULL) {
gchar *account_uid;
account_uid = g_strstrip (g_strdup (string));
account = e_get_account_by_uid (account_uid);
g_free (account_uid);
}
if (account != NULL) {
if (account->transport != NULL) {
/* XXX Transport UIDs are kludgy right now. We
* use the EAccount's regular UID and tack on
* "-transport". Will be better soon. */
transport_uid = g_strconcat (
account->uid, "-transport", NULL);
/* to reprompt password on sending if needed */
account->transport->get_password_canceled = FALSE;
}
sent_folder_uri = g_strdup (account->sent_folder_uri);
}
string = camel_header_raw_find (&xev, "X-Evolution-Fcc", NULL);
if (sent_folder_uri == NULL && string != NULL)
sent_folder_uri = g_strstrip (g_strdup (string));
string = camel_header_raw_find (&xev, "X-Evolution-Transport", NULL);
if (transport_uid == NULL && string != NULL)
transport_uid = g_strstrip (g_strdup (string));
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 (NULL);
camel_message_info_set_flags (info, CAMEL_MESSAGE_SEEN, ~0);
/* 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->message = g_object_ref (message);
context->info = info;
context->xev = xev;
context->post_to_uris = post_to_uris;
context->transport_uid = transport_uid;
context->sent_folder_uri = sent_folder_uri;
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_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);
}
static gboolean
mbox_folder_append_message_sync (CamelFolder *folder,
CamelMimeMessage *message,
CamelMessageInfo *info,
gchar **appended_uid,
GCancellable *cancellable,
GError **error)
{
CamelLocalFolder *lf = (CamelLocalFolder *) folder;
CamelStream *output_stream = NULL, *filter_stream = NULL;
CamelMimeFilter *filter_from;
CamelMboxSummary *mbs = (CamelMboxSummary *) folder->summary;
CamelMessageInfo *mi;
gchar *fromline = NULL;
struct stat st;
gint retval;
gboolean has_attachment;
#if 0
gchar *xev;
#endif
/* If we can't lock, dont do anything */
if (camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1)
return FALSE;
d (printf ("Appending message\n"));
/* first, check the summary is correct (updates folder_size too) */
retval = camel_local_summary_check ((CamelLocalSummary *) folder->summary, lf->changes, cancellable, error);
if (retval == -1)
goto fail;
/* add it to the summary/assign the uid, etc */
mi = camel_local_summary_add ((CamelLocalSummary *) folder->summary, message, info, lf->changes, error);
if (mi == NULL)
goto fail;
d (printf ("Appending message: uid is %s\n", camel_message_info_get_uid (mi)));
has_attachment = camel_mime_message_has_attachment (message);
if (((camel_message_info_get_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) && !has_attachment) ||
((camel_message_info_get_flags (mi) & CAMEL_MESSAGE_ATTACHMENTS) == 0 && has_attachment)) {
camel_message_info_set_flags (mi, CAMEL_MESSAGE_ATTACHMENTS, has_attachment ? CAMEL_MESSAGE_ATTACHMENTS : 0);
}
output_stream = camel_stream_fs_new_with_name (
lf->folder_path, O_WRONLY | O_APPEND |
O_LARGEFILE, 0666, error);
if (output_stream == NULL) {
g_prefix_error (
error, _("Cannot open mailbox: %s: "),
lf->folder_path);
goto fail;
}
/* and we need to set the frompos/XEV explicitly */
((CamelMboxMessageInfo *) mi)->frompos = mbs->folder_size;
#if 0
xev = camel_local_summary_encode_x_evolution ((CamelLocalSummary *) folder->summary, mi);
if (xev) {
/* the x-ev header should match the 'current' flags, no problem, so store as much */
camel_medium_set_header ((CamelMedium *) message, "X-Evolution", xev);
mi->flags &= ~ CAMEL_MESSAGE_FOLDER_NOXEV | CAMEL_MESSAGE_FOLDER_FLAGGED;
g_free (xev);
}
#endif
/* we must write this to the non-filtered stream ... */
fromline = camel_mime_message_build_mbox_from (message);
if (camel_stream_write (output_stream, fromline, strlen (fromline), cancellable, error) == -1)
goto fail_write;
/* and write the content to the filtering stream, that translates '\nFrom' into '\n>From' */
filter_stream = camel_stream_filter_new (output_stream);
filter_from = camel_mime_filter_from_new ();
camel_stream_filter_add ((CamelStreamFilter *) filter_stream, filter_from);
g_object_unref (filter_from);
if (camel_data_wrapper_write_to_stream_sync (
(CamelDataWrapper *) message, filter_stream, cancellable, error) == -1 ||
camel_stream_write (filter_stream, "\n", 1, cancellable, error) == -1 ||
camel_stream_flush (filter_stream, cancellable, error) == -1)
goto fail_write;
/* filter stream ref's the output stream itself, so we need to unref it too */
g_object_unref (filter_stream);
g_object_unref (output_stream);
g_free (fromline);
if (!((CamelMessageInfoBase *) mi)->preview && camel_folder_summary_get_need_preview (folder->summary)) {
if (camel_mime_message_build_preview ((CamelMimePart *) message, mi) && ((CamelMessageInfoBase *) mi)->preview)
camel_folder_summary_add_preview (folder->summary, mi);
}
/* now we 'fudge' the summary to tell it its uptodate, because its idea of uptodate has just changed */
/* the stat really shouldn't fail, we just wrote to it */
if (g_stat (lf->folder_path, &st) == 0) {
((CamelFolderSummary *) mbs)->time = st.st_mtime;
mbs->folder_size = st.st_size;
}
/* unlock as soon as we can */
camel_local_folder_unlock (lf);
if (camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
if (appended_uid)
*appended_uid = g_strdup(camel_message_info_get_uid(mi));
return TRUE;
fail_write:
g_prefix_error (
error, _("Cannot append message to mbox file: %s: "),
lf->folder_path);
if (output_stream) {
gint fd;
fd = camel_stream_fs_get_fd (CAMEL_STREAM_FS (output_stream));
if (fd != -1) {
/* reset the file to original size */
do {
retval = ftruncate (fd, mbs->folder_size);
} while (retval == -1 && errno == EINTR);
}
g_object_unref (output_stream);
}
if (filter_stream)
g_object_unref (filter_stream);
g_free (fromline);
/* remove the summary info so we are not out-of-sync with the mbox */
camel_folder_summary_remove (CAMEL_FOLDER_SUMMARY (mbs), mi);
/* and tell the summary it's up-to-date */
if (g_stat (lf->folder_path, &st) == 0) {
((CamelFolderSummary *) mbs)->time = st.st_mtime;
mbs->folder_size = st.st_size;
}
fail:
/* make sure we unlock the folder - before we start triggering events into appland */
camel_local_folder_unlock (lf);
/* cascade the changes through, anyway, if there are any outstanding */
if (camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (folder, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
return FALSE;
}