static void
async_context_free (SendAsyncContext *context)
{
if (context->sent_folder != NULL)
g_object_unref (context->sent_folder);
if (context->message != NULL)
g_object_unref (context->message);
if (context->info != NULL)
camel_message_info_free (context->info);
if (context->recipients != NULL)
g_object_unref (context->recipients);
if (context->from != NULL)
g_object_unref (context->from);
if (context->driver != NULL)
g_object_unref (context->driver);
if (context->result != NULL)
g_variant_builder_unref(context->result);
if (context->sent_folder_uri)
g_free (context->sent_folder_uri);
if (context->ops_path)
g_free (context->ops_path);
if (context->cancellable != NULL) {
camel_operation_pop_message (context->cancellable);
g_object_unref (context->cancellable);
}
g_slice_free (SendAsyncContext, context);
}
gboolean
e_mail_store_go_online_sync (CamelStore *store,
GCancellable *cancellable,
GError **error)
{
CamelService *service;
const gchar *display_name;
gboolean success = TRUE;
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
service = CAMEL_SERVICE (store);
display_name = camel_service_get_display_name (service);
if (display_name == NULL || *display_name == '\0')
display_name = G_OBJECT_TYPE_NAME (service);
camel_operation_push_message (
cancellable, _("Reconnecting to “%s”"), display_name);
if (CAMEL_IS_OFFLINE_STORE (store))
success = camel_offline_store_set_online_sync (
CAMEL_OFFLINE_STORE (store),
TRUE, cancellable, error);
camel_operation_pop_message (cancellable);
return success;
}
static void
mail_store_prepare_for_offline_thread (GSimpleAsyncResult *simple,
CamelStore *store,
GCancellable *cancellable)
{
CamelService *service;
gchar *service_name;
GError *error = NULL;
service = CAMEL_SERVICE (store);
service_name = camel_service_get_name (service, TRUE);
camel_operation_push_message (
cancellable, _("Preparing account '%s' for offline"),
service_name);
g_free (service_name);
if (CAMEL_IS_DISCO_STORE (store))
camel_disco_store_prepare_for_offline (
CAMEL_DISCO_STORE (store), cancellable, &error);
else if (CAMEL_IS_OFFLINE_STORE (store))
camel_offline_store_prepare_for_offline_sync (
CAMEL_OFFLINE_STORE (store), cancellable, &error);
if (error != NULL)
g_simple_async_result_take_error (simple, error);
camel_operation_pop_message (cancellable);
}
/* Helper for e_mail_store_prepare_for_offline() */
static void
mail_store_prepare_for_offline_thread (GSimpleAsyncResult *simple,
GObject *source_object,
GCancellable *cancellable)
{
CamelService *service;
const gchar *display_name;
GError *local_error = NULL;
service = CAMEL_SERVICE (source_object);
display_name = camel_service_get_display_name (service);
if (display_name == NULL || *display_name == '\0')
display_name = G_OBJECT_TYPE_NAME (service);
camel_operation_push_message (
cancellable, _("Preparing account “%s” for offline"),
display_name);
if (CAMEL_IS_OFFLINE_STORE (service))
camel_offline_store_prepare_for_offline_sync (
CAMEL_OFFLINE_STORE (service),
cancellable, &local_error);
if (local_error != NULL)
g_simple_async_result_take_error (simple, local_error);
camel_operation_pop_message (cancellable);
}
static void
refresh_folders_exec (struct _refresh_folders_msg *m,
GCancellable *cancellable,
GError **error)
{
CamelFolder *folder;
EMailSession *session;
gint i;
GError *local_error = NULL;
gulong handler_id = 0;
if (cancellable)
handler_id = g_signal_connect (
m->info->cancellable, "cancelled",
G_CALLBACK (main_op_cancelled_cb), cancellable);
get_folders (m->store, m->folders, m->finfo);
camel_operation_push_message (m->info->cancellable, _("Updating..."));
session = m->info->session;
for (i = 0; i < m->folders->len; i++) {
folder = e_mail_session_uri_to_folder_sync (
session,
m->folders->pdata[i], 0,
cancellable, &local_error);
if (folder) {
/* FIXME Not passing a GError here. */
camel_folder_synchronize_sync (
folder, FALSE, cancellable, NULL);
camel_folder_refresh_info_sync (folder, cancellable, NULL);
g_object_unref (folder);
} else if (local_error != NULL) {
g_warning ("Failed to refresh folders: %s", local_error->message);
g_clear_error (&local_error);
}
if (g_cancellable_is_cancelled (m->info->cancellable))
break;
if (m->info->state != SEND_CANCELLED)
camel_operation_progress (
m->info->cancellable, 100 * i / m->folders->len);
}
camel_operation_pop_message (m->info->cancellable);
if (cancellable)
g_signal_handler_disconnect (m->info->cancellable, handler_id);
}
static gboolean
e_alert_sink_thread_job_done_cb (gpointer user_data)
{
EAlertSinkThreadJobData *job_data = user_data;
EAlertSink *alert_sink;
GCancellable *cancellable;
g_return_val_if_fail (job_data != NULL, FALSE);
g_return_val_if_fail (job_data->func != NULL, FALSE);
alert_sink = e_activity_get_alert_sink (job_data->activity);
cancellable = e_activity_get_cancellable (job_data->activity);
camel_operation_pop_message (cancellable);
if (e_activity_handle_cancellation (job_data->activity, job_data->error)) {
/* do nothing */
} else if (job_data->error != NULL) {
if (job_data->alert_arg_0) {
e_alert_submit (
alert_sink,
job_data->alert_ident,
job_data->alert_arg_0, job_data->error->message, NULL);
} else {
e_alert_submit (
alert_sink,
job_data->alert_ident,
job_data->error->message, NULL);
}
} else {
e_activity_set_state (job_data->activity, E_ACTIVITY_COMPLETED);
}
/* clean-up */
g_clear_object (&job_data->activity);
g_clear_error (&job_data->error);
g_free (job_data->alert_ident);
g_free (job_data->alert_arg_0);
if (job_data->free_user_data)
job_data->free_user_data (job_data->user_data);
g_free (job_data);
return FALSE;
}
static void
mail_store_go_offline_thread (GSimpleAsyncResult *simple,
CamelStore *store,
GCancellable *cancellable)
{
CamelService *service;
gchar *service_name;
GError *error = NULL;
service = CAMEL_SERVICE (store);
service_name = camel_service_get_name (service, TRUE);
camel_operation_push_message (
cancellable, _("Disconnecting from '%s'"), service_name);
g_free (service_name);
if (CAMEL_IS_DISCO_STORE (store)) {
CamelDiscoStore *disco_store;
disco_store = CAMEL_DISCO_STORE (store);
if (camel_disco_store_can_work_offline (disco_store))
camel_disco_store_set_status (
disco_store, CAMEL_DISCO_STORE_OFFLINE,
cancellable, &error);
else
em_utils_disconnect_service_sync (service, TRUE, cancellable, &error);
} else if (CAMEL_IS_OFFLINE_STORE (store)) {
CamelOfflineStore *offline_store;
offline_store = CAMEL_OFFLINE_STORE (store);
camel_offline_store_set_online_sync (
offline_store, FALSE, cancellable, &error);
} else
em_utils_disconnect_service_sync (service, TRUE, cancellable, &error);
if (error != NULL)
g_simple_async_result_take_error (simple, error);
camel_operation_pop_message (cancellable);
}
static void
async_context_free (AsyncContext *context)
{
if (context->folder != NULL)
g_object_unref (context->folder);
if (context->message != NULL)
g_object_unref (context->message);
if (context->info != NULL)
camel_message_info_free (context->info);
if (context->from != NULL)
g_object_unref (context->from);
if (context->recipients != NULL)
g_object_unref (context->recipients);
if (context->driver != NULL)
g_object_unref (context->driver);
if (context->transport != NULL)
g_object_unref (context->transport);
if (context->cancellable != NULL) {
camel_operation_pop_message (context->cancellable);
g_object_unref (context->cancellable);
}
if (context->xev != NULL)
camel_header_raw_clear (&context->xev);
if (context->post_to_uris != NULL) {
g_ptr_array_foreach (
context->post_to_uris, (GFunc) g_free, NULL);
g_ptr_array_free (context->post_to_uris, TRUE);
}
g_free (context->folder_uri);
g_free (context->message_uid);
g_slice_free (AsyncContext, context);
}
gboolean
e_mail_session_unsubscribe_folder_sync (EMailSession *session,
const gchar *folder_uri,
GCancellable *cancellable,
GError **error)
{
CamelStore *store = NULL;
gchar *folder_name = NULL;
const gchar *message;
gboolean success = FALSE;
g_return_val_if_fail (E_IS_MAIL_SESSION (session), FALSE);
g_return_val_if_fail (folder_uri != NULL, FALSE);
success = e_mail_folder_uri_parse (
CAMEL_SESSION (session), folder_uri,
&store, &folder_name, error);
if (!success)
return FALSE;
message = _("Unsubscribing from folder '%s'");
camel_operation_push_message (cancellable, message, folder_name);
/* FIXME This should take our GCancellable. */
success =
em_utils_connect_service_sync (
CAMEL_SERVICE (store), cancellable, error) &&
camel_subscribable_unsubscribe_folder_sync (
CAMEL_SUBSCRIBABLE (store),
folder_name, cancellable, error);
camel_operation_pop_message (cancellable);
g_object_unref (store);
g_free (folder_name);
return success;
}
gboolean
subscribe_method(gchar *url)
{
add_feed *feed = g_new0(add_feed, 1);
feed->feed_url = url;
feed->add=1;
feed->enabled=feed->validate=1;
feed->fetch_html = 0;
if (feed->feed_url && strlen(feed->feed_url)) {
g_print("New Feed received: %s\n", url);
feed->feed_url = sanitize_url(feed->feed_url);
d("sanitized feed URL: %s\n", feed->feed_url);
if (g_hash_table_find(rf->hr, check_if_match, feed->feed_url)) {
rss_error(NULL, NULL, _("Error adding feed."),
_("Feed already exists!"));
//return FALSE;
/* we return true here since org.gnome.feed.Reader
* doesn't support status */
return TRUE;
}
if (setup_feed(feed)) {
gchar *msg = g_strdup_printf(_("Importing URL: %s"),
feed->feed_url);
taskbar_push_message(msg);
g_free(msg);
}
if (rf->treeview)
store_redraw(GTK_TREE_VIEW(rf->treeview));
save_gconf_feed();
#if (DATASERVER_VERSION >= 2033001)
camel_operation_pop_message (NULL);
#else
camel_operation_end(NULL);
#endif
}
g_free(url);
return TRUE;
}
static gboolean
maildir_folder_transfer_messages_to_sync (CamelFolder *source,
GPtrArray *uids,
CamelFolder *dest,
gboolean delete_originals,
GPtrArray **transferred_uids,
GCancellable *cancellable,
GError **error)
{
gboolean fallback = FALSE;
if (delete_originals && CAMEL_IS_MAILDIR_FOLDER (source) && CAMEL_IS_MAILDIR_FOLDER (dest)) {
gint i;
CamelLocalFolder *lf = (CamelLocalFolder *) source;
CamelLocalFolder *df = (CamelLocalFolder *) dest;
camel_operation_push_message (
cancellable, _("Moving messages"));
camel_folder_freeze (dest);
camel_folder_freeze (source);
for (i = 0; i < uids->len; i++) {
gchar *uid = (gchar *) uids->pdata[i];
gchar *s_filename, *d_filename, *tmp;
CamelMaildirMessageInfo *mdi;
CamelMessageInfo *info;
if ((info = camel_folder_summary_uid (source->summary, uid)) == NULL) {
set_cannot_get_message_ex (
error, CAMEL_FOLDER_ERROR_INVALID_UID,
uid, lf->folder_path, _("No such message"));
return FALSE;
}
mdi = (CamelMaildirMessageInfo *) info;
tmp = camel_maildir_summary_info_to_name (mdi);
d_filename = g_strdup_printf ("%s/cur/%s", df->folder_path, tmp);
g_free (tmp);
s_filename = g_strdup_printf("%s/cur/%s", lf->folder_path, camel_maildir_info_filename (mdi));
if (g_rename (s_filename, d_filename) != 0) {
if (errno == EXDEV) {
i = uids->len + 1;
fallback = TRUE;
} else {
g_set_error (
error, G_IO_ERROR,
g_io_error_from_errno (errno),
_("Cannot transfer message to destination folder: %s"),
g_strerror (errno));
camel_message_info_free (info);
break;
}
} else {
camel_folder_set_message_flags (
source, uid, CAMEL_MESSAGE_DELETED |
CAMEL_MESSAGE_SEEN, ~0);
camel_folder_summary_remove (source->summary, info);
}
camel_message_info_free (info);
g_free (s_filename);
g_free (d_filename);
}
camel_folder_thaw (source);
camel_folder_thaw (dest);
camel_operation_pop_message (cancellable);
} else
fallback = TRUE;
if (fallback) {
CamelFolderClass *folder_class;
/* Chain up to parent's transfer_messages_to() method. */
folder_class = CAMEL_FOLDER_CLASS (camel_maildir_folder_parent_class);
return folder_class->transfer_messages_to_sync (
source, uids, dest, delete_originals,
transferred_uids, cancellable, error);
}
return TRUE;
}
static gboolean
maildir_folder_transfer_messages_to_sync (CamelFolder *source,
GPtrArray *uids,
CamelFolder *dest,
gboolean delete_originals,
GPtrArray **transferred_uids,
GCancellable *cancellable,
GError **error)
{
gboolean fallback = FALSE;
if (delete_originals && CAMEL_IS_MAILDIR_FOLDER (source) && CAMEL_IS_MAILDIR_FOLDER (dest)
&& camel_folder_get_parent_store (source) == camel_folder_get_parent_store (dest)) {
gint i;
CamelLocalFolder *lf = (CamelLocalFolder *) source;
CamelLocalFolder *df = (CamelLocalFolder *) dest;
camel_operation_push_message (
cancellable, _("Moving messages"));
camel_folder_freeze (dest);
camel_folder_freeze (source);
for (i = 0; i < uids->len; i++) {
gchar *uid = (gchar *) uids->pdata[i];
gchar *s_filename, *d_filename, *new_filename;
CamelMaildirMessageInfo *mdi;
CamelMessageInfo *info;
if ((info = camel_folder_summary_get (source->summary, uid)) == NULL) {
set_cannot_get_message_ex (
error, CAMEL_FOLDER_ERROR_INVALID_UID,
uid, lf->folder_path, _("No such message"));
return FALSE;
}
mdi = (CamelMaildirMessageInfo *) info;
new_filename = camel_maildir_summary_info_to_name (mdi);
d_filename = g_strdup_printf ("%s/cur/%s", df->folder_path, new_filename);
s_filename = g_strdup_printf ("%s/cur/%s", lf->folder_path, camel_maildir_info_filename (mdi));
if (g_rename (s_filename, d_filename) != 0) {
if (errno == EXDEV) {
i = uids->len + 1;
fallback = TRUE;
} else {
g_set_error (
error, G_IO_ERROR,
g_io_error_from_errno (errno),
_("Cannot transfer message to destination folder: %s"),
g_strerror (errno));
camel_message_info_unref (info);
g_free (s_filename);
g_free (d_filename);
g_free (new_filename);
break;
}
} else {
CamelMessageInfo *clone;
CamelMaildirMessageInfo *mclone;
clone = camel_message_info_clone (info);
clone->summary = dest->summary;
mclone = (CamelMaildirMessageInfo *) clone;
/* preserve also UID, as it matches the file name */
mclone->info.info.uid = camel_pstring_strdup (camel_message_info_get_uid (info));
camel_maildir_info_set_filename (clone, g_strdup (new_filename));
/* unset deleted flag when transferring from trash folder */
if ((source->folder_flags & CAMEL_FOLDER_IS_TRASH) != 0)
camel_message_info_set_flags (info, CAMEL_MESSAGE_DELETED, 0);
/* unset junk flag when transferring from junk folder */
if ((source->folder_flags & CAMEL_FOLDER_IS_JUNK) != 0)
camel_message_info_set_flags (info, CAMEL_MESSAGE_JUNK, 0);
camel_folder_summary_add (dest->summary, clone);
camel_folder_change_info_add_uid (df->changes, camel_message_info_get_uid (clone));
camel_folder_set_message_flags (
source, uid, CAMEL_MESSAGE_DELETED |
CAMEL_MESSAGE_SEEN, ~0);
camel_folder_change_info_remove_uid (lf->changes, camel_message_info_get_uid (info));
camel_folder_summary_remove (source->summary, info);
}
camel_message_info_unref (info);
g_free (s_filename);
g_free (d_filename);
g_free (new_filename);
}
if (lf && camel_folder_change_info_changed (lf->changes)) {
camel_folder_changed (source, lf->changes);
camel_folder_change_info_clear (lf->changes);
}
if (df && camel_folder_change_info_changed (df->changes)) {
camel_folder_changed (dest, df->changes);
camel_folder_change_info_clear (df->changes);
}
camel_folder_thaw (source);
camel_folder_thaw (dest);
camel_operation_pop_message (cancellable);
} else
fallback = TRUE;
if (fallback) {
CamelFolderClass *folder_class;
/* Chain up to parent's transfer_messages_to() method. */
folder_class = CAMEL_FOLDER_CLASS (camel_maildir_folder_parent_class);
return folder_class->transfer_messages_to_sync (
source, uids, dest, delete_originals,
transferred_uids, cancellable, error);
}
return TRUE;
}
static void
dbx_import_file (DbxImporter *m)
{
EShell *shell;
EShellBackend *shell_backend;
EMailSession *session;
GCancellable *cancellable;
gchar *filename;
CamelFolder *folder;
gint tmpfile;
gint i;
gint missing = 0;
m->status_what = NULL;
filename = g_filename_from_uri (
((EImportTargetURI *) m->target)->uri_src, NULL, NULL);
/* Destination folder, was set in our widget */
m->parent_uri = g_strdup (((EImportTargetURI *) m->target)->uri_dest);
cancellable = m->base.cancellable;
/* XXX Dig up the EMailSession from the default EShell.
* Since the EImport framework doesn't allow for user
* data, I don't see how else to get to it. */
shell = e_shell_get_default ();
shell_backend = e_shell_get_backend_by_name (shell, "mail");
session = e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend));
camel_operation_push_message (NULL, _("Importing “%s”"), filename);
folder = e_mail_session_uri_to_folder_sync (
session, m->parent_uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, &m->base.error);
if (!folder)
return;
d (printf ("importing to %s\n", camel_folder_get_full_name (folder)));
camel_folder_freeze (folder);
filename = g_filename_from_uri (
((EImportTargetURI *) m->target)->uri_src, NULL, NULL);
m->dbx_fd = g_open (filename, O_RDONLY, 0);
g_free (filename);
if (m->dbx_fd == -1) {
g_set_error (
&m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
"Failed to open import file");
goto out;
}
if (!dbx_load_indices (m))
goto out;
tmpfile = e_mkstemp ("dbx-import-XXXXXX");
if (tmpfile == -1) {
g_set_error (
&m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
"Failed to create temporary file for import");
goto out;
}
for (i = 0; i < m->index_count; i++) {
CamelMessageInfo *info;
CamelMimeMessage *msg;
CamelMimeParser *mp;
gint dbx_flags = 0;
gint flags = 0;
gboolean success;
camel_operation_progress (NULL, 100 * i / m->index_count);
camel_operation_progress (cancellable, 100 * i / m->index_count);
if (!dbx_read_email (m, m->indices[i], tmpfile, &dbx_flags)) {
d (
printf ("Cannot read email index %d at %x\n",
i, m->indices[i]));
if (m->base.error != NULL)
goto out;
missing++;
continue;
}
if (dbx_flags & 0x40)
flags |= CAMEL_MESSAGE_DELETED;
if (dbx_flags & 0x80)
flags |= CAMEL_MESSAGE_SEEN;
if (dbx_flags & 0x80000)
flags |= CAMEL_MESSAGE_ANSWERED;
mp = camel_mime_parser_new ();
lseek (tmpfile, 0, SEEK_SET);
camel_mime_parser_init_with_fd (mp, tmpfile);
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (msg);
g_object_unref (mp);
break;
}
info = camel_message_info_new (NULL);
camel_message_info_set_flags (info, flags, ~0);
success = camel_folder_append_message_sync (
folder, msg, info, NULL,
cancellable, &m->base.error);
g_clear_object (&info);
g_object_unref (msg);
if (!success) {
g_object_unref (mp);
break;
}
}
out:
if (m->dbx_fd != -1)
close (m->dbx_fd);
if (m->indices)
g_free (m->indices);
/* FIXME Not passing GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
g_object_unref (folder);
if (missing && m->base.error == NULL) {
g_set_error (
&m->base.error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
"%d messages imported correctly; %d message "
"bodies were not present in the DBX file",
m->index_count - missing, missing);
}
camel_operation_pop_message (NULL);
}
static void
import_kmail_folder (struct _import_mbox_msg *m,
gchar *k_path_in,
GCancellable *cancellable,
GError **error)
{
const gchar *special_folders []= {"cur", "tmp", "new", NULL};
gchar *special_path;
const CamelStore *store;
CamelFolder *folder;
CamelMimeParser *mp = NULL;
CamelMessageInfo *info;
CamelMimeMessage *msg;
guint32 flags = 0;
gchar *e_uri, *e_path;
gchar *k_path;
const gchar *d;
gchar *mail_url;
GDir *dir;
struct stat st;
gint fd, i;
e_uri = kuri_to_euri (k_path_in);
/* we need to drop some folders, like: Trash */
if (!e_uri)
return;
/* In case we using async way in the future */
k_path = g_strdup (k_path_in);
store = evolution_get_local_store ();
e_path = e_uri + strlen (EVOLUTION_LOCAL_BASE) + 1;
e_mail_store_create_folder_sync ((CamelStore *)store, e_path, NULL, NULL);
folder = e_mail_session_uri_to_folder_sync (
m->session, e_uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, NULL);
if (folder == NULL) {
g_free (k_path);
g_warning ("evolution error: cannot get the folder\n");
return;
}
camel_operation_push_message (
cancellable, _("Importing '%s'"),
camel_folder_get_display_name (folder));
camel_folder_freeze (folder);
for (i = 0; special_folders [i]; i++) {
camel_operation_progress (cancellable, 100*i/3);
special_path = g_build_filename (k_path, special_folders[i], NULL);
dir = g_dir_open (special_path, 0, NULL);
while ((d = g_dir_read_name (dir))) {
if ((strcmp (d, ".") == 0) || (strcmp (d, "..") == 0)) {
continue;
}
mail_url = g_build_filename (special_path, d, NULL);
if (g_stat (mail_url, &st) == -1) {
g_free (mail_url);
continue;
}
if (S_ISREG (st.st_mode)) {
fd = g_open (mail_url, O_RDONLY | O_BINARY, 0);
g_free (mail_url);
if (fd == -1) {
continue;
}
mp = camel_mime_parser_new ();
camel_mime_parser_scan_from (mp, FALSE);
if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
/* will never happen - 0 is unconditionally returned */
g_object_unref (mp);
continue;
}
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (mp);
g_object_unref (msg);
continue;
}
info = camel_message_info_new (NULL);
if (strcmp (special_folders[i], "cur") == 0) {
flags |= CAMEL_MESSAGE_SEEN;
} else if (strcmp (special_folders[i], "tmp") == 0) {
flags |= CAMEL_MESSAGE_DELETED; /* Mark the 'tmp' mails as 'deleted' */
}
camel_message_info_set_flags (info, flags, ~0);
camel_folder_append_message_sync (
folder, msg, info, NULL,
cancellable, error);
camel_message_info_unref (info);
g_object_unref (msg);
g_object_unref (mp);
} else {
g_free (mail_url);
}
}
}
camel_operation_progress (cancellable, 100);
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
camel_operation_pop_message (cancellable);
g_free (k_path);
}
static void
import_mbox_exec (struct _import_mbox_msg *m,
GCancellable *cancellable,
GError **error)
{
CamelFolder *folder;
CamelMimeParser *mp = NULL;
struct stat st;
gint fd;
if (g_stat (m->path, &st) == -1) {
g_warning (
"cannot find source file to import '%s': %s",
m->path, g_strerror (errno));
return;
}
if (m->uri == NULL || m->uri[0] == 0)
folder = e_mail_session_get_local_folder (
m->session, E_MAIL_LOCAL_FOLDER_INBOX);
else
folder = e_mail_session_uri_to_folder_sync (
m->session, m->uri, CAMEL_STORE_FOLDER_CREATE,
cancellable, error);
if (folder == NULL)
return;
if (S_ISREG (st.st_mode)) {
gboolean any_read = FALSE;
fd = g_open (m->path, O_RDONLY | O_BINARY, 0);
if (fd == -1) {
g_warning (
"cannot find source file to import '%s': %s",
m->path, g_strerror (errno));
goto fail1;
}
mp = camel_mime_parser_new ();
camel_mime_parser_scan_from (mp, TRUE);
if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
/* will never happen - 0 is unconditionally returned */
goto fail2;
}
camel_operation_push_message (
cancellable, _("Importing '%s'"),
camel_folder_get_display_name (folder));
camel_folder_freeze (folder);
while (camel_mime_parser_step (mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM &&
!g_cancellable_is_cancelled (cancellable)) {
CamelMimeMessage *msg;
gint pc = 0;
any_read = TRUE;
if (st.st_size > 0)
pc = (gint) (100.0 * ((gdouble)
camel_mime_parser_tell (mp) /
(gdouble) st.st_size));
camel_operation_progress (cancellable, pc);
msg = camel_mime_message_new ();
if (!camel_mime_part_construct_from_parser_sync (
(CamelMimePart *) msg, mp, NULL, NULL)) {
/* set exception? */
g_object_unref (msg);
break;
}
import_mbox_add_message (folder, msg, cancellable, error);
g_object_unref (msg);
if (error && *error != NULL)
break;
camel_mime_parser_step (mp, NULL, NULL);
}
if (!any_read && !g_cancellable_is_cancelled (cancellable)) {
CamelStream *stream;
stream = camel_stream_fs_new_with_name (m->path, O_RDONLY, 0, NULL);
if (stream) {
CamelMimeMessage *msg;
msg = camel_mime_message_new ();
if (camel_data_wrapper_construct_from_stream_sync ((CamelDataWrapper *) msg, stream, NULL, NULL))
import_mbox_add_message (folder, msg, cancellable, error);
g_object_unref (msg);
g_object_unref (stream);
}
}
/* Not passing a GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
camel_folder_thaw (folder);
camel_operation_pop_message (cancellable);
fail2:
g_object_unref (mp);
}
fail1:
/* Not passing a GCancellable or GError here. */
camel_folder_synchronize_sync (folder, FALSE, NULL, NULL);
g_object_unref (folder);
/* 'fd' is freed together with 'mp' */
/* coverity[leaked_handle] */
}
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;
}
