gchar *
mail_tool_generate_forward_subject (CamelMimeMessage *msg)
{
const gchar *subject;
gchar *fwd_subj;
const gint max_subject_length = 1024;
subject = camel_mime_message_get_subject (msg);
if (subject && *subject) {
/* Truncate insanely long subjects */
if (strlen (subject) < max_subject_length) {
fwd_subj = g_strdup_printf ("[Fwd: %s]", subject);
} else {
/* We can't use %.*s because it depends on the
* locale being C/POSIX or UTF-8 to work correctly
* in glibc. */
fwd_subj = g_malloc (max_subject_length + 11);
memcpy (fwd_subj, "[Fwd: ", 6);
memcpy (fwd_subj + 6, subject, max_subject_length);
memcpy (fwd_subj + 6 + max_subject_length, "...]", 5);
}
} else {
const CamelInternetAddress *from;
gchar *fromstr;
from = camel_mime_message_get_from (msg);
if (from) {
fromstr = camel_address_format (CAMEL_ADDRESS (from));
fwd_subj = g_strdup_printf ("[Fwd: %s]", fromstr);
g_free (fromstr);
} else
fwd_subj = g_strdup ("[Fwd: No Subject]");
}
return fwd_subj;
}
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);
}
gboolean
mail_send_short_message (EGdbusSession *object,
GDBusMethodInvocation *invocation, const char *account_uid,
const char *text, const char **to,
EMailDataSession *msession, GError **ret_error)
{
EAccount *account;
CamelMimeMessage *message;
CamelService *service;
gchar *transport_uid;
CamelInternetAddress *recipients;
CamelMessageInfo *info;
GSimpleAsyncResult *simple;
SendAsyncContext *context;
CamelInternetAddress *from;
GCancellable *ops;
EMailDataOperation *mops;
char *mops_path;
gchar subject[MAX_SUBJECT_LENGTH + 4];
GError *error = NULL;
/* Check params. */
if (account_uid == NULL || *account_uid == 0) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("Invalid account"));
goto on_error;
}
if (text == NULL || *text == 0) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("Text is empty"));
goto on_error;
}
if (to == NULL || *to == 0 || **to == 0) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("No recipient"));
goto on_error;
}
/* Get transport. */
account = e_get_account_by_uid (account_uid);
if (!account) {
error = g_error_new (G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
_("Invalid account %s"),
account_uid);
goto on_error;
}
transport_uid = g_strconcat (account->uid, "-transport", NULL);
service = camel_session_ref_service (CAMEL_SESSION (session),
transport_uid);
if (!CAMEL_IS_TRANSPORT (service)) {
error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
_("Invalid account %s"), account_uid);
g_object_unref (account);
g_free (transport_uid);
goto on_error;
}
/* Prepare message. */
message = camel_mime_message_new ();
strncpy (subject, text, MAX_SUBJECT_LENGTH + 1);
if (strlen(text) > MAX_SUBJECT_LENGTH)
strcpy (subject + MAX_SUBJECT_LENGTH, "...");
camel_mime_message_set_subject (message, subject);
from = camel_internet_address_new ();
camel_internet_address_add (from, NULL, "sms");
recipients = camel_internet_address_new ();
while (*to) {
camel_internet_address_add (recipients, NULL, *to);
to++;
}
camel_mime_message_set_from (message, from);
camel_mime_message_set_recipients (message, CAMEL_RECIPIENT_TYPE_TO,
recipients);
camel_mime_message_set_date (message, CAMEL_MESSAGE_DATE_CURRENT, 0);
camel_mime_part_set_content_type (CAMEL_MIME_PART(message),
"text/plain");
camel_mime_part_set_content (CAMEL_MIME_PART(message), text,
strlen(text), "text/plain");
info = camel_message_info_new (NULL);
camel_message_info_set_flags (info, CAMEL_MESSAGE_SEEN, ~0);
/* Return the new operation */
ops = camel_operation_new ();
mops = e_mail_data_operation_new ((CamelOperation *) ops);
mops_path = e_mail_data_operation_register_gdbus_object (mops,
g_dbus_method_invocation_get_connection(invocation),
NULL);
egdbus_session_complete_send_short_message (object, invocation,
mops_path);
/* The rest of the processing happens in a thread. */
context = g_slice_new0 (SendAsyncContext);
context->message = message;
context->io_priority = G_PRIORITY_DEFAULT;
context->from = CAMEL_ADDRESS (from);
context->recipients = CAMEL_ADDRESS (recipients);
context->info = info;
context->transport = service;
context->sent_folder_uri = g_strdup (account->sent_folder_uri);
context->cancellable = ops;
context->ops_path = mops_path;
context->result = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
/* Failure here emits a runtime warning but is non-fatal. */
context->driver = camel_session_get_filter_driver (
CAMEL_SESSION (session), "outgoing", &error);
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), mail_send_short_message_completed,
context, mail_send_short_message);
g_simple_async_result_set_op_res_gpointer (
simple, context, (GDestroyNotify) async_context_free);
g_simple_async_result_run_in_thread (
simple,
(GSimpleAsyncThreadFunc) mail_send_short_to_thread,
context->io_priority, context->cancellable);
g_object_unref (simple);
return TRUE;
on_error:
*ret_error = error;
return FALSE;
}
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 void
set_attendees (ECalComponent *comp,
CamelMimeMessage *message,
const gchar *organizer)
{
GSList *attendees = NULL, *to_free = NULL;
ECalComponentAttendee *ca;
CamelInternetAddress *from = NULL, *to, *cc, *bcc, *arr[4];
gint len, i, j;
if (message->reply_to)
from = message->reply_to;
else if (message->from)
from = message->from;
to = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_TO);
cc = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_CC);
bcc = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_BCC);
arr[0] = from; arr[1] = to; arr[2] = cc; arr[3] = bcc;
for (j = 0; j < 4; j++) {
if (!arr[j])
continue;
len = CAMEL_ADDRESS (arr[j])->addresses->len;
for (i = 0; i < len; i++) {
const gchar *name, *addr;
if (camel_internet_address_get (arr[j], i, &name, &addr)) {
gchar *temp;
temp = g_strconcat ("mailto:", addr, NULL);
if (organizer && g_ascii_strcasecmp (temp, organizer) == 0) {
/* do not add organizer twice */
g_free (temp);
continue;
}
ca = g_new0 (ECalComponentAttendee, 1);
ca->value = temp;
ca->cn = name;
ca->cutype = ICAL_CUTYPE_INDIVIDUAL;
ca->status = ICAL_PARTSTAT_NEEDSACTION;
if (j == 0) {
/* From */
ca->role = ICAL_ROLE_CHAIR;
} else if (j == 2) {
/* BCC */
ca->role = ICAL_ROLE_OPTPARTICIPANT;
} else {
/* all other */
ca->role = ICAL_ROLE_REQPARTICIPANT;
}
to_free = g_slist_prepend (to_free, temp);
attendees = g_slist_append (attendees, ca);
}
}
}
e_cal_component_set_attendee_list (comp, attendees);
g_slist_foreach (attendees, (GFunc) g_free, NULL);
g_slist_foreach (to_free, (GFunc) g_free, NULL);
g_slist_free (to_free);
g_slist_free (attendees);
}
gint main (gint argc, gchar **argv)
{
gint i;
CamelInternetAddress *addr, *addr2;
gchar *name;
const gchar *charset;
const gchar *real, *where;
gchar *enc, *enc2, *format, *format2;
camel_test_init (argc, argv);
camel_test_start ("CamelInternetAddress, basics");
addr = camel_internet_address_new ();
push ("Test blank address");
check (camel_address_length (CAMEL_ADDRESS (addr)) == 0);
check (camel_internet_address_get (addr, 0, &real, &where) == FALSE);
pull ();
push ("Test blank clone");
addr2 = CAMEL_INTERNET_ADDRESS (camel_address_new_clone (CAMEL_ADDRESS (addr)));
test_address_compare (addr, addr2);
check_unref (addr2, 1);
pull ();
push ("Test add 1");
camel_internet_address_add (addr, "Zed", "*****@*****.**");
check (camel_address_length (CAMEL_ADDRESS (addr)) == 1);
check (camel_internet_address_get (addr, 0, &real, &where) == TRUE);
check_msg (string_equal ("Zed", real), "real = '%s'", real);
check (strcmp (where, "*****@*****.**") == 0);
pull ();
push ("Test clone 1");
addr2 = CAMEL_INTERNET_ADDRESS (camel_address_new_clone (CAMEL_ADDRESS (addr)));
test_address_compare (addr, addr2);
check_unref (addr2, 1);
pull ();
push ("Test add many");
for (i = 1; i < 10; i++) {
gchar name[16], a[32];
sprintf (name, "Zed %d", i);
sprintf (a, "nowhere@here-%d.com.au", i);
camel_internet_address_add (addr, name, a);
check (camel_address_length (CAMEL_ADDRESS (addr)) == i + 1);
check (camel_internet_address_get (addr, i, &real, &where) == TRUE);
check_msg (string_equal (name, real), "name = '%s' real = '%s'", name, real);
check (strcmp (where, a) == 0);
}
pull ();
/* put a few of these in to make it look like its doing something impressive ... :) */
camel_test_end ();
camel_test_start ("CamelInternetAddress, search");
push ("Test search");
camel_test_nonfatal ("Address comparisons should ignore whitespace??");
check (camel_internet_address_find_name (addr, "Zed 1", &where) == 1);
check (camel_internet_address_find_name (addr, "Zed 9", &where) == 9);
check (camel_internet_address_find_name (addr, "Zed", &where) == 0);
check (camel_internet_address_find_name (addr, " Zed", &where) == 0);
check (camel_internet_address_find_name (addr, "Zed ", &where) == 0);
check (camel_internet_address_find_name (addr, " Zed ", &where) == 0);
check (camel_internet_address_find_name (addr, "Zed 20", &where) == -1);
check (camel_internet_address_find_name (addr, "", &where) == -1);
/* interface dont handle nulls :) */
/*check(camel_internet_address_find_name(addr, NULL, &where) == -1);*/
check (camel_internet_address_find_address (addr, "*****@*****.**", &where) == 1);
check (camel_internet_address_find_address (addr, "nowhere@here-1 . com.au", &where) == 1);
check (camel_internet_address_find_address (addr, "nowhere@here-2 .com.au ", &where) == 2);
check (camel_internet_address_find_address (addr, " nowhere @here-3.com.au", &where) == 3);
check (camel_internet_address_find_address (addr, "[email protected] ", &where) == -1);
check (camel_internet_address_find_address (addr, "", &where) == -1);
/*check(camel_internet_address_find_address(addr, NULL, &where) == -1);*/
camel_test_fatal ();
pull ();
camel_test_end ();
camel_test_start ("CamelInternetAddress, copy/cat/clone");
push ("Test clone many");
addr2 = CAMEL_INTERNET_ADDRESS (camel_address_new_clone (CAMEL_ADDRESS (addr)));
test_address_compare (addr, addr2);
pull ();
push ("Test remove items");
camel_address_remove (CAMEL_ADDRESS (addr2), 0);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 9);
camel_address_remove (CAMEL_ADDRESS (addr2), 0);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 8);
camel_address_remove (CAMEL_ADDRESS (addr2), 5);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 7);
camel_address_remove (CAMEL_ADDRESS (addr2), 10);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 7);
camel_address_remove (CAMEL_ADDRESS (addr2), -1);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 0);
check_unref (addr2, 1);
pull ();
push ("Testing copy/cat");
push ("clone + cat");
addr2 = CAMEL_INTERNET_ADDRESS (camel_address_new_clone (CAMEL_ADDRESS (addr)));
camel_address_cat (CAMEL_ADDRESS (addr2), CAMEL_ADDRESS (addr));
check (camel_address_length (CAMEL_ADDRESS (addr)) == 10);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 20);
check_unref (addr2, 1);
pull ();
push ("cat + cat + copy");
addr2 = camel_internet_address_new ();
camel_address_cat (CAMEL_ADDRESS (addr2), CAMEL_ADDRESS (addr));
test_address_compare (addr, addr2);
camel_address_cat (CAMEL_ADDRESS (addr2), CAMEL_ADDRESS (addr));
check (camel_address_length (CAMEL_ADDRESS (addr)) == 10);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 20);
camel_address_copy (CAMEL_ADDRESS (addr2), CAMEL_ADDRESS (addr));
test_address_compare (addr, addr2);
check_unref (addr2, 1);
pull ();
push ("copy");
addr2 = camel_internet_address_new ();
camel_address_copy (CAMEL_ADDRESS (addr2), CAMEL_ADDRESS (addr));
test_address_compare (addr, addr2);
check_unref (addr2, 1);
pull ();
pull ();
check_unref (addr, 1);
camel_test_end ();
camel_test_start ("CamelInternetAddress, I18N");
for (i = 0; i < G_N_ELEMENTS (test_lines); i++) {
push ("Testing text line %d (%s) '%s'", i, test_lines[i].type, test_lines[i].line);
addr = camel_internet_address_new ();
/* first, convert to api format (utf-8) */
charset = test_lines[i].type;
name = to_utf8 (test_lines[i].line, charset);
push ("Address setup");
camel_internet_address_add (addr, name, "*****@*****.**");
check (camel_internet_address_get (addr, 0, &real, &where) == TRUE);
check_msg (string_equal (name, real), "name = '%s' real = '%s'", name, real);
check (strcmp (where, "*****@*****.**") == 0);
test_free (name);
check (camel_internet_address_get (addr, 1, &real, &where) == FALSE);
check (camel_address_length (CAMEL_ADDRESS (addr)) == 1);
pull ();
push ("Address encode/decode");
enc = camel_address_encode (CAMEL_ADDRESS (addr));
addr2 = camel_internet_address_new ();
check (camel_address_decode (CAMEL_ADDRESS (addr2), enc) == 1);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 1);
enc2 = camel_address_encode (CAMEL_ADDRESS (addr2));
check_msg (string_equal (enc, enc2), "enc = '%s' enc2 = '%s'", enc, enc2);
test_free (enc2);
push ("Compare addresses");
test_address_compare (addr, addr2);
pull ();
check_unref (addr2, 1);
test_free (enc);
pull ();
/* FIXME: format/unformat arne't guaranteed to be reversible, at least at the moment */
camel_test_nonfatal ("format/unformat not (yet) reversible for all cases");
push ("Address format/unformat");
format = camel_address_format (CAMEL_ADDRESS (addr));
addr2 = camel_internet_address_new ();
check (camel_address_unformat (CAMEL_ADDRESS (addr2), format) == 1);
check (camel_address_length (CAMEL_ADDRESS (addr2)) == 1);
format2 = camel_address_format (CAMEL_ADDRESS (addr2));
check_msg (string_equal (format, format2), "format = '%s\n\tformat2 = '%s'", format, format2);
test_free (format2);
/* currently format/unformat doesn't handle ,'s and other special chars at all */
if (camel_address_length (CAMEL_ADDRESS (addr2)) == 1) {
push ("Compare addresses");
test_address_compare (addr, addr2);
pull ();
}
test_free (format);
pull ();
camel_test_fatal ();
check_unref (addr2, 1);
check_unref (addr, 1);
pull ();
}
camel_test_end ();
camel_test_start ("CamelInternetAddress, I18N decode");
for (i = 0; i < G_N_ELEMENTS (test_address); i++) {
push ("Testing address line %d '%s'", i, test_address[i].addr);
addr = camel_internet_address_new ();
push ("checking decoded");
check (camel_address_decode (CAMEL_ADDRESS (addr), test_address[i].addr) == test_address[i].count);
format = camel_address_format (CAMEL_ADDRESS (addr));
check (strcmp (format, test_address[i].utf8) == 0);
test_free (format);
pull ();
push ("Comparing re-encoded output");
addr2 = CAMEL_INTERNET_ADDRESS (camel_internet_address_new ());
enc = camel_address_encode (CAMEL_ADDRESS (addr));
check_msg (camel_address_decode (CAMEL_ADDRESS (addr2), enc) == test_address[i].count, "enc = '%s'", enc);
test_free (enc);
test_address_compare (addr, addr2);
check_unref (addr2, 1);
pull ();
check_unref (addr, 1);
pull ();
}
camel_test_end ();
camel_test_start ("CamelInternerAddress name & email decoder");
for (i = 0; i < G_N_ELEMENTS (test_decode); i++) {
gchar *line;
const gchar *name, *email;
gint jj;
name = test_decode[i].name;
email = test_decode[i].email;
for (jj = 0; jj < G_N_ELEMENTS (line_decode_formats); jj++) {
if (line_decode_formats[jj].without_name) {
line = g_strdup_printf (line_decode_formats[jj].without_name, email);
check_address_line_decode (i, line, NULL, email);
g_free (line);
}
if (!name)
continue;
line = g_strdup_printf (line_decode_formats[jj].with_name, name, email);
check_address_line_decode (i, line, name, email);
g_free (line);
}
}
camel_test_end ();
return 0;
}
/* FIXME: check format of fields. */
static gboolean
process_header (CamelMedium *medium,
const gchar *name,
const gchar *value)
{
CamelHeaderType header_type;
CamelMimeMessage *message = CAMEL_MIME_MESSAGE (medium);
CamelInternetAddress *addr;
const gchar *charset;
gchar *unfolded;
header_type = (CamelHeaderType) g_hash_table_lookup (header_name_table, name);
switch (header_type) {
case HEADER_FROM:
addr = camel_internet_address_new ();
unfolded = camel_header_unfold (value);
if (camel_address_decode ((CamelAddress *) addr, unfolded) <= 0) {
g_object_unref (addr);
} else {
if (message->from)
g_object_unref (message->from);
message->from = addr;
}
g_free (unfolded);
break;
case HEADER_REPLY_TO:
addr = camel_internet_address_new ();
unfolded = camel_header_unfold (value);
if (camel_address_decode ((CamelAddress *) addr, unfolded) <= 0) {
g_object_unref (addr);
} else {
if (message->reply_to)
g_object_unref (message->reply_to);
message->reply_to = addr;
}
g_free (unfolded);
break;
case HEADER_SUBJECT:
g_free (message->subject);
if (((CamelDataWrapper *) message)->mime_type) {
charset = camel_content_type_param (((CamelDataWrapper *) message)->mime_type, "charset");
charset = camel_iconv_charset_name (charset);
} else
charset = NULL;
unfolded = camel_header_unfold (value);
message->subject = g_strstrip (camel_header_decode_string (unfolded, charset));
g_free (unfolded);
break;
case HEADER_TO:
case HEADER_CC:
case HEADER_BCC:
case HEADER_RESENT_TO:
case HEADER_RESENT_CC:
case HEADER_RESENT_BCC:
addr = g_hash_table_lookup (message->recipients, name);
if (value) {
unfolded = camel_header_unfold (value);
camel_address_decode (CAMEL_ADDRESS (addr), unfolded);
g_free (unfolded);
} else {
camel_address_remove (CAMEL_ADDRESS (addr), -1);
}
return FALSE;
case HEADER_DATE:
if (value) {
message->date = camel_header_decode_date (value, &message->date_offset);
} else {
message->date = CAMEL_MESSAGE_DATE_CURRENT;
message->date_offset = 0;
}
break;
case HEADER_MESSAGE_ID:
g_free (message->message_id);
if (value)
message->message_id = camel_header_msgid_decode (value);
else
message->message_id = NULL;
break;
default:
return FALSE;
}
return TRUE;
}
static gboolean
ews_send_to_sync (CamelTransport *transport,
CamelMimeMessage *message,
CamelAddress *from,
CamelAddress *recipients,
gboolean *out_sent_message_saved,
GCancellable *cancellable,
GError **error)
{
CamelNetworkSettings *network_settings;
CamelEwsSettings *ews_settings;
CamelInternetAddress *used_from;
CamelSettings *settings;
CamelService *service;
EEwsConnection *cnc;
EwsFolderId *folder_id = NULL;
gchar *ews_email;
gchar *host_url;
gchar *user;
gboolean success = FALSE;
service = CAMEL_SERVICE (transport);
settings = camel_service_ref_settings (service);
ews_settings = CAMEL_EWS_SETTINGS (settings);
ews_email = camel_ews_settings_dup_email (ews_settings);
host_url = camel_ews_settings_dup_hosturl (ews_settings);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
user = camel_network_settings_dup_user (network_settings);
g_object_unref (settings);
if (CAMEL_IS_INTERNET_ADDRESS (from))
used_from = CAMEL_INTERNET_ADDRESS (from);
else
used_from = camel_mime_message_get_from (message);
if (!used_from || camel_address_length (CAMEL_ADDRESS (used_from)) == 0) {
g_set_error_literal (
error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
_("Cannot send message with no From address"));
goto exit;
} else if (camel_address_length (CAMEL_ADDRESS (used_from)) > 1) {
g_set_error_literal (
error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
_("Exchange server cannot send message with "
"multiple From addresses"));
goto exit;
} else {
const gchar *used_email = NULL;
if (!camel_internet_address_get (used_from, 0, NULL, &used_email)) {
g_set_error_literal (
error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
_("Failed to read From address"));
goto exit;
}
}
cnc = ews_transport_ref_connection (CAMEL_EWS_TRANSPORT (service));
if (!cnc) {
g_set_error (
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_NOT_CONNECTED,
_("Service not connected"));
goto exit;
}
if (ews_transport_can_server_side_sent_folder (service, &folder_id, cancellable)) {
if (out_sent_message_saved)
*out_sent_message_saved = TRUE;
}
success = camel_ews_utils_create_mime_message (
cnc, folder_id ? "SendAndSaveCopy" : "SendOnly", folder_id, message, NULL,
from, recipients, NULL, NULL, cancellable, error);
g_object_unref (cnc);
e_ews_folder_id_free (folder_id);
exit:
g_free (ews_email);
g_free (host_url);
g_free (user);
return success;
}
