void test_address_compare(CamelInternetAddress *addr, CamelInternetAddress *addr2) { const char *r1, *r2, *a1, *a2; char *e1, *e2, *f1, *f2; int j; check(camel_address_length(CAMEL_ADDRESS(addr)) == camel_address_length(CAMEL_ADDRESS(addr2))); for (j=0;j<camel_address_length(CAMEL_ADDRESS(addr));j++) { check(camel_internet_address_get(addr, j, &r1, &a1) == TRUE); check(camel_internet_address_get(addr2, j, &r2, &a2) == TRUE); check(string_equal(r1, r2)); check(strcmp(a1, a2) == 0); } check(camel_internet_address_get(addr, j, &r1, &a1) == FALSE); check(camel_internet_address_get(addr2, j, &r2, &a2) == FALSE); e1 = camel_address_encode(CAMEL_ADDRESS(addr)); e2 = camel_address_encode(CAMEL_ADDRESS(addr2)); if (camel_address_length(CAMEL_ADDRESS(addr)) == 0) check(e1 == NULL && e2 == NULL); else check(e1 != NULL && e2 != NULL); if (e1 != NULL) { check_msg(string_equal(e1, e2), "e1 = '%s' e2 = '%s'", e1, e2); test_free(e1); test_free(e2); } f1 = camel_address_format(CAMEL_ADDRESS(addr)); f2 = camel_address_format(CAMEL_ADDRESS(addr2)); if (camel_address_length(CAMEL_ADDRESS(addr)) == 0) check(f1 == NULL && f2 == NULL); else check(f1 != NULL && f2 != NULL); if (f1 != NULL) { check_msg(string_equal(f1, f2), "f1 = '%s' f2 = '%s'", f1, f2); test_free(f1); test_free(f2); } }
static GPtrArray * parse_sendmail_args (const gchar *binary, const gchar *args, const gchar *from_addr, CamelAddress *recipients) { GPtrArray *args_arr; gint ii, len, argc = 0; gchar **argv = NULL; g_return_val_if_fail (binary != NULL, NULL); g_return_val_if_fail (args != NULL, NULL); g_return_val_if_fail (from_addr != NULL, NULL); len = camel_address_length (recipients); args_arr = g_ptr_array_new_full (5, g_free); g_ptr_array_add (args_arr, g_strdup (binary)); if (args && g_shell_parse_argv (args, &argc, &argv, NULL) && argc > 0 && argv) { for (ii = 0; ii < argc; ii++) { const gchar *arg = argv[ii]; if (g_strcmp0 (arg, "%F") == 0) { g_ptr_array_add (args_arr, g_strdup (from_addr)); } else if (g_strcmp0 (arg, "%R") == 0) { gint jj; for (jj = 0; jj < len; jj++) { const gchar *addr = NULL; if (!camel_internet_address_get ( CAMEL_INTERNET_ADDRESS (recipients), jj, NULL, &addr)) { /* should not happen, as the array is checked beforehand */ g_ptr_array_free (args_arr, TRUE); g_strfreev (argv); return NULL; } g_ptr_array_add (args_arr, g_strdup (addr)); } } else { g_ptr_array_add (args_arr, g_strdup (arg)); } } g_strfreev (argv); } g_ptr_array_add (args_arr, NULL); return args_arr; }
static void mail_send_short_connection_fail(SendAsyncContext *context) { const gchar *addr; gint i, len; len = camel_address_length(context->recipients); for (i = 0; i < len; i++) { if (camel_internet_address_get( CAMEL_INTERNET_ADDRESS(context->recipients), i, NULL, &addr)) g_variant_builder_add (context->result, "(sssi)", addr, _("Connection failed"), g_quark_to_string(CAMEL_SERVICE_ERROR), CAMEL_SERVICE_ERROR_NOT_CONNECTED); } }
/* Expands groups to individual addresses, or removes empty groups completely. * Usual email addresses are left untouched. */ void em_utils_expand_groups (CamelInternetAddress *addresses) { gint ii, len; const gchar *addr; CamelAddress *addrs; g_return_if_fail (CAMEL_IS_INTERNET_ADDRESS (addresses)); addrs = CAMEL_ADDRESS (addresses); len = camel_address_length (addrs); for (ii = len - 1; ii >= 0; ii--) { addr = NULL; if (!camel_internet_address_get (addresses, ii, NULL, &addr)) { camel_address_remove (addrs, ii); } else if (addr) { gchar *encoded = camel_internet_address_encode_address (NULL, NULL, addr); if (encoded) { CamelInternetAddress *iaddr = camel_internet_address_new (); gint decoded; /* decode expands respective groups */ decoded = camel_address_decode (CAMEL_ADDRESS (iaddr), encoded); if (decoded <= 0 || decoded > 1) { camel_address_remove (addrs, ii); if (decoded > 1) camel_address_cat (addrs, CAMEL_ADDRESS (iaddr)); } g_object_unref (iaddr); g_free (encoded); } } } }
static void filter_recipients (CamelMimeMessage *message, CamelAddress *recipients, GHashTable *recip_to, GHashTable *recip_cc, GHashTable *recip_bcc) { CamelInternetAddress *addresses, *mime_cc, *mime_bcc; gint ii, len; g_return_if_fail (message != NULL); g_return_if_fail (recipients != NULL); g_return_if_fail (CAMEL_IS_INTERNET_ADDRESS (recipients)); g_return_if_fail (recip_to != NULL); g_return_if_fail (recip_cc != NULL); g_return_if_fail (recip_bcc != NULL); mime_cc = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_CC); mime_bcc = camel_mime_message_get_recipients (message, CAMEL_RECIPIENT_TYPE_BCC); addresses = CAMEL_INTERNET_ADDRESS (recipients); len = camel_address_length (recipients); for (ii = 0; ii < len; ii++) { const gchar *name = NULL, *email = NULL; if (!camel_internet_address_get (addresses, ii, &name, &email) || !email) continue; if (mime_bcc && camel_internet_address_find_address (mime_bcc, email, NULL) != -1) { g_hash_table_insert (recip_bcc, (gpointer) email, GINT_TO_POINTER (1)); } else if (mime_cc && camel_internet_address_find_address (mime_cc, email, NULL) != -1) { g_hash_table_insert (recip_cc, (gpointer) email, GINT_TO_POINTER (1)); } else { g_hash_table_insert (recip_to, (gpointer) email, GINT_TO_POINTER (1)); } } }
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); }
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); }
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; }
static gboolean sendmail_send_to_sync (CamelTransport *transport, CamelMimeMessage *message, CamelAddress *from, CamelAddress *recipients, gboolean *out_sent_message_saved, GCancellable *cancellable, GError **error) { CamelHeaderRaw *header, *savedbcc, *n, *tail; const gchar *from_addr, *addr; GPtrArray *argv_arr; gint i, len, fd[2], nullfd, wstat; CamelStream *filter; CamelMimeFilter *crlf; sigset_t mask, omask; CamelStream *out; CamelSendmailSettings *settings; const gchar *binary = SENDMAIL_PATH; gchar *custom_binary = NULL, *custom_args = NULL; gboolean success; pid_t pid; success = camel_internet_address_get ( CAMEL_INTERNET_ADDRESS (from), 0, NULL, &from_addr); if (!success) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Failed to read From address")); return FALSE; } settings = CAMEL_SENDMAIL_SETTINGS (camel_service_ref_settings (CAMEL_SERVICE (transport))); if (!camel_sendmail_settings_get_send_in_offline (settings)) { CamelSession *session; gboolean is_online; session = camel_service_ref_session (CAMEL_SERVICE (transport)); is_online = session && camel_session_get_online (session); g_clear_object (&session); if (!is_online) { g_set_error ( error, CAMEL_SERVICE_ERROR, CAMEL_SERVICE_ERROR_UNAVAILABLE, _("Message send in offline mode is disabled")); return FALSE; } } if (camel_sendmail_settings_get_use_custom_binary (settings)) { custom_binary = camel_sendmail_settings_dup_custom_binary (settings); if (custom_binary && *custom_binary) binary = custom_binary; } if (camel_sendmail_settings_get_use_custom_args (settings)) { custom_args = camel_sendmail_settings_dup_custom_args (settings); /* means no arguments used */ if (!custom_args) custom_args = g_strdup (""); } g_object_unref (settings); len = camel_address_length (recipients); for (i = 0; i < len; i++) { success = camel_internet_address_get ( CAMEL_INTERNET_ADDRESS (recipients), i, NULL, &addr); if (!success) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Could not parse recipient list")); g_free (custom_binary); g_free (custom_args); return FALSE; } } argv_arr = parse_sendmail_args ( binary, custom_args ? custom_args : "-i -f %F -- %R", from_addr, recipients); if (!argv_arr) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Could not parse arguments")); g_free (custom_binary); g_free (custom_args); return FALSE; } /* unlink the bcc headers */ savedbcc = NULL; tail = (CamelHeaderRaw *) &savedbcc; header = (CamelHeaderRaw *) &CAMEL_MIME_PART (message)->headers; n = header->next; while (n != NULL) { if (!g_ascii_strcasecmp (n->name, "Bcc")) { header->next = n->next; tail->next = n; n->next = NULL; tail = n; } else { header = n; } n = header->next; } if (pipe (fd) == -1) { g_set_error ( error, G_IO_ERROR, g_io_error_from_errno (errno), _("Could not create pipe to '%s': %s: " "mail not sent"), binary, g_strerror (errno)); /* restore the bcc headers */ header->next = savedbcc; g_free (custom_binary); g_free (custom_args); g_ptr_array_free (argv_arr, TRUE); return FALSE; } /* Block SIGCHLD so the calling application doesn't notice * sendmail exiting before we do. */ sigemptyset (&mask); sigaddset (&mask, SIGCHLD); sigprocmask (SIG_BLOCK, &mask, &omask); pid = fork (); switch (pid) { case -1: g_set_error ( error, G_IO_ERROR, g_io_error_from_errno (errno), _("Could not fork '%s': %s: " "mail not sent"), binary, g_strerror (errno)); close (fd[0]); close (fd[1]); sigprocmask (SIG_SETMASK, &omask, NULL); /* restore the bcc headers */ header->next = savedbcc; g_free (custom_binary); g_free (custom_args); g_ptr_array_free (argv_arr, TRUE); return FALSE; case 0: /* Child process */ nullfd = open ("/dev/null", O_RDWR); dup2 (fd[0], STDIN_FILENO); if (nullfd != -1) { /*dup2 (nullfd, STDOUT_FILENO); dup2 (nullfd, STDERR_FILENO);*/ close (nullfd); } close (fd[1]); execv (binary, (gchar **) argv_arr->pdata); _exit (255); } g_ptr_array_free (argv_arr, TRUE); /* Parent process. Write the message out. */ close (fd[0]); out = camel_stream_fs_new_with_fd (fd[1]); /* XXX Workaround for lame sendmail implementations * that can't handle CRLF eoln sequences. */ filter = camel_stream_filter_new (out); crlf = camel_mime_filter_crlf_new ( CAMEL_MIME_FILTER_CRLF_DECODE, CAMEL_MIME_FILTER_CRLF_MODE_CRLF_ONLY); camel_stream_filter_add (CAMEL_STREAM_FILTER (filter), crlf); g_object_unref (crlf); g_object_unref (out); out = (CamelStream *) filter; if (camel_data_wrapper_write_to_stream_sync ( CAMEL_DATA_WRAPPER (message), out, cancellable, error) == -1 || camel_stream_close (out, cancellable, error) == -1) { g_object_unref (out); g_prefix_error (error, _("Could not send message: ")); /* Wait for sendmail to exit. */ while (waitpid (pid, &wstat, 0) == -1 && errno == EINTR) ; sigprocmask (SIG_SETMASK, &omask, NULL); /* restore the bcc headers */ header->next = savedbcc; g_free (custom_binary); g_free (custom_args); return FALSE; } g_object_unref (out); /* Wait for sendmail to exit. */ while (waitpid (pid, &wstat, 0) == -1 && errno == EINTR) ; sigprocmask (SIG_SETMASK, &omask, NULL); /* restore the bcc headers */ header->next = savedbcc; if (!WIFEXITED (wstat)) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("'%s' exited with signal %s: mail not sent."), binary, g_strsignal (WTERMSIG (wstat))); g_free (custom_binary); g_free (custom_args); return FALSE; } else if (WEXITSTATUS (wstat) != 0) { if (WEXITSTATUS (wstat) == 255) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Could not execute '%s': mail not sent."), binary); } else { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("'%s' exited with status %d: " "mail not sent."), binary, WEXITSTATUS (wstat)); } g_free (custom_binary); g_free (custom_args); return FALSE; } g_free (custom_binary); g_free (custom_args); 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; }
static void set_attendees (ECalComponent *comp, CamelMimeMessage *message, const gchar *organizer) { GSList *attendees = NULL, *to_free = NULL; ECalComponentAttendee *ca; CamelInternetAddress *from, *to, *cc, *bcc, *arr[4]; gint len, i, j; from = camel_mime_message_get_reply_to (message); if (!from) from = camel_mime_message_get_from (message); 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_length (CAMEL_ADDRESS (arr[j])); 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); }
static gboolean smtp_transport_send_to_sync (CamelTransport *transport, CamelMimeMessage *message, CamelAddress *from, CamelAddress *recipients, gboolean *out_sent_message_saved, GCancellable *cancellable, GError **error) { CamelSmtpTransport *smtp_transport = CAMEL_SMTP_TRANSPORT (transport); CamelInternetAddress *cia; gboolean has_8bit_parts; const gchar *addr; gint i, len; smtp_debug_print_server_name (CAMEL_SERVICE (transport), "Sending with"); if (!smtp_transport->connected) { g_set_error ( error, CAMEL_SERVICE_ERROR, CAMEL_SERVICE_ERROR_NOT_CONNECTED, _("Cannot send message: service not connected.")); return FALSE; } if (!camel_internet_address_get (CAMEL_INTERNET_ADDRESS (from), 0, NULL, &addr)) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Cannot send message: sender address not valid.")); return FALSE; } camel_operation_push_message (cancellable, _("Sending message")); /* find out if the message has 8bit mime parts */ has_8bit_parts = camel_mime_message_has_8bit_parts (message); /* If the connection needs a ReSET, then do so */ if (smtp_transport->need_rset && !smtp_rset (smtp_transport, cancellable, error)) { camel_operation_pop_message (cancellable); return FALSE; } smtp_transport->need_rset = FALSE; /* rfc1652 (8BITMIME) requires that you notify the ESMTP daemon that * you'll be sending an 8bit mime message at "MAIL FROM:" time. */ if (!smtp_mail ( smtp_transport, addr, has_8bit_parts, cancellable, error)) { camel_operation_pop_message (cancellable); return FALSE; } len = camel_address_length (recipients); if (len == 0) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Cannot send message: no recipients defined.")); camel_operation_pop_message (cancellable); smtp_transport->need_rset = TRUE; return FALSE; } cia = CAMEL_INTERNET_ADDRESS (recipients); for (i = 0; i < len; i++) { gchar *enc; if (!camel_internet_address_get (cia, i, NULL, &addr)) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Cannot send message: " "one or more invalid recipients")); camel_operation_pop_message (cancellable); smtp_transport->need_rset = TRUE; return FALSE; } enc = camel_internet_address_encode_address (NULL, NULL, addr); if (!smtp_rcpt (smtp_transport, enc, cancellable, error)) { g_free (enc); camel_operation_pop_message (cancellable); smtp_transport->need_rset = TRUE; return FALSE; } g_free (enc); } if (!smtp_data (smtp_transport, message, cancellable, error)) { camel_operation_pop_message (cancellable); smtp_transport->need_rset = TRUE; return FALSE; } camel_operation_pop_message (cancellable); return TRUE; }