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; }