static gint maildir_folder_cmp_uids (CamelFolder *folder, const gchar *uid1, const gchar *uid2) { CamelMessageInfo *a, *b; time_t tma, tmb; g_return_val_if_fail (folder != NULL, 0); g_return_val_if_fail (folder->summary != NULL, 0); a = camel_folder_summary_uid (folder->summary, uid1); b = camel_folder_summary_uid (folder->summary, uid2); g_return_val_if_fail (a != NULL, 0); g_return_val_if_fail (b != NULL, 0); tma = camel_message_info_date_received (a); tmb = camel_message_info_date_received (b); camel_message_info_free (a); camel_message_info_free (b); return tma < tmb ? -1 : tma == tmb ? 0 : 1; }
static int groupwise_entry_play_transfer (CamelOfflineJournal *journal, CamelGroupwiseJournalEntry *entry, CamelException *ex) { CamelGroupwiseFolder *gw_folder = (CamelGroupwiseFolder *) journal->folder; CamelFolder *folder = journal->folder; CamelGroupwiseMessageInfo *real; CamelMessageInfoBase *info; GPtrArray *xuids, *uids; CamelException lex; CamelFolder *src; const char *name; if (!(info = (CamelMessageInfoBase *) camel_folder_summary_uid (folder->summary, entry->uid))) { /* Note: this should never happen, but rather than crash lets make a new info */ info = camel_message_info_new (NULL); } name = camel_groupwise_store_folder_lookup ((CamelGroupwiseStore *) folder->parent_store, entry->source_container); if (name && (src = camel_store_get_folder (folder->parent_store, name, 0, ex))) { uids = g_ptr_array_sized_new (1); g_ptr_array_add (uids, entry->original_uid); camel_exception_init (&lex); camel_folder_transfer_messages_to (src, uids, folder, &xuids, FALSE, &lex); if (!camel_exception_is_set (&lex)) { real = (CamelGroupwiseMessageInfo *) camel_folder_summary_uid (folder->summary, xuids->pdata[0]); /* transfer all the system flags, user flags/tags, etc */ gw_message_info_dup_to ((CamelMessageInfoBase *) real, (CamelMessageInfoBase *) info); camel_message_info_free (real); } else { camel_exception_xfer (ex, &lex); goto exception; } g_ptr_array_free (xuids, TRUE); g_ptr_array_free (uids, TRUE); camel_object_unref (src); } else if (!name) { camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot get folder container %s"), entry->source_container); goto exception; } /* message was successfully transferred, remove the fake item from the cache/summary */ camel_folder_summary_remove_uid (folder->summary, entry->uid); camel_data_cache_remove (gw_folder->cache, "cache", entry->uid, NULL); camel_message_info_free (info); return 0; exception: camel_message_info_free (info); return -1; }
static void imap4_fetch_all_add (struct imap4_fetch_all_t *fetch) { CamelFolderChangeInfo *changes = NULL; struct imap4_envelope_t *envelope; CamelMessageInfo *info; int i; changes = fetch->changes; for (i = 0; i < fetch->added->len; i++) { if (!(envelope = fetch->added->pdata[i])) { courier_imap_is_a_piece_of_shit (fetch->summary, i + fetch->first); break; } if (envelope->changed != IMAP4_FETCH_ALL) { d(fprintf (stderr, "Hmmm, IMAP4 server didn't give us everything for message %d\n", i + 1)); camel_message_info_free (envelope->info); g_free (envelope); continue; } if ((info = camel_folder_summary_uid (fetch->summary, camel_message_info_uid (envelope->info)))) { camel_message_info_free (envelope->info); camel_message_info_free (info); g_free (envelope); continue; } camel_folder_change_info_add_uid (changes, camel_message_info_uid (envelope->info)); if ((((CamelMessageInfoBase *) envelope->info)->flags & CAMEL_IMAP4_MESSAGE_RECENT)) camel_folder_change_info_recent_uid (changes, camel_message_info_uid (envelope->info)); camel_folder_summary_add (fetch->summary, envelope->info); g_free (envelope); } g_ptr_array_free (fetch->added, TRUE); g_hash_table_destroy (fetch->uid_hash); if (camel_folder_change_info_changed (changes)) camel_object_trigger_event (fetch->summary->folder, "folder_changed", changes); camel_folder_change_info_free (changes); g_free (fetch); }
/** * mail_importer_add_line: * importer: A MailImporter structure. * str: Next line of the mbox. * finished: TRUE if @str is the last line of the message. * * Adds lines to the message until it is finished, and then adds * the complete message to the folder. */ void mail_importer_add_line (MailImporter *importer, const char *str, gboolean finished) { CamelMimeMessage *msg; CamelMessageInfo *info; CamelException *ex; if (importer->mstream == NULL) importer->mstream = CAMEL_STREAM_MEM (camel_stream_mem_new ()); camel_stream_write (CAMEL_STREAM (importer->mstream), str, strlen (str)); if (finished == FALSE) return; camel_stream_reset (CAMEL_STREAM (importer->mstream)); info = camel_message_info_new(NULL); camel_message_info_set_flags(info, CAMEL_MESSAGE_SEEN, ~0); msg = camel_mime_message_new (); camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (msg), CAMEL_STREAM (importer->mstream)); camel_object_unref (importer->mstream); importer->mstream = NULL; ex = camel_exception_new (); camel_folder_append_message (importer->folder, msg, info, NULL, ex); camel_object_unref (msg); camel_exception_free (ex); camel_message_info_free(info); }
static gboolean vee_info_set_user_flag (CamelMessageInfo *mi, const gchar *name, gboolean value) { gint res = FALSE; CamelVeeFolder *vf = (CamelVeeFolder *) camel_folder_summary_get_folder (mi->summary); if (camel_debug("vfolderexp")) printf ( "Expression for vfolder '%s' is '%s'\n", camel_folder_get_full_name (camel_folder_summary_get_folder (mi->summary)), g_strescape (vf->expression, "")); if (mi->uid) { CamelMessageInfo *rmi = camel_folder_summary_get (((CamelVeeMessageInfo *) mi)->orig_summary, mi->uid + 8); HANDLE_NULL_INFO (FALSE); /* ignore changes done in the folder itself, * unless it's a vTrash or vJunk folder */ if (!CAMEL_IS_VTRASH_FOLDER (vf)) camel_vee_folder_ignore_next_changed_event (vf, camel_folder_summary_get_folder (rmi->summary)); res = camel_message_info_set_user_flag (rmi, name, value); camel_message_info_free (rmi); } return res; }
void groupwise_summary_clear (CamelFolderSummary *summary, gboolean uncache) { CamelFolderChangeInfo *changes; CamelMessageInfo *info; int i, count; const char *uid; changes = camel_folder_change_info_new (); count = camel_folder_summary_count (summary); for (i = 0; i < count; i++) { if (!(info = camel_folder_summary_index (summary, i))) continue; uid = camel_message_info_uid (info); camel_folder_change_info_remove_uid (changes, uid); camel_folder_summary_remove_uid (summary, uid); camel_message_info_free(info); } camel_folder_summary_clear (summary); camel_folder_summary_save (summary); if (uncache) camel_data_cache_clear (((CamelGroupwiseFolder *) summary->folder)->cache, "cache", NULL); if (camel_folder_change_info_changed (changes)) camel_object_trigger_event (summary->folder, "folder_changed", changes); camel_folder_change_info_free (changes); }
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); }
/** * camel_imap_message_cache_new: * @path: directory to use for storage * @summary: CamelFolderSummary for the folder we are caching * @ex: a CamelException * * Return value: a new CamelImapMessageCache object using @path for * storage. If cache files already exist in @path, then any that do not * correspond to messages in @summary will be deleted. **/ CamelImapMessageCache * camel_imap_message_cache_new (const char *path, CamelFolderSummary *summary, CamelException *ex) { CamelImapMessageCache *cache; GDir *dir; const char *dname; char *uid, *p; GPtrArray *deletes; CamelMessageInfo *info; GError *error = NULL; dir = g_dir_open (path, 0, &error); if (!dir) { camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Could not open cache directory: %s"), error->message); g_error_free (error); return NULL; } cache = (CamelImapMessageCache *)camel_object_new (CAMEL_IMAP_MESSAGE_CACHE_TYPE); cache->path = g_strdup (path); cache->parts = g_hash_table_new (g_str_hash, g_str_equal); cache->cached = g_hash_table_new (NULL, NULL); deletes = g_ptr_array_new (); while ((dname = g_dir_read_name (dir))) { if (!isdigit (dname[0])) continue; p = strchr (dname, '.'); if (p) uid = g_strndup (dname, p - dname); else uid = g_strdup (dname); info = camel_folder_summary_uid (summary, uid); if (info) { camel_message_info_free(info); cache_put (cache, uid, dname, NULL); } else g_ptr_array_add (deletes, g_strdup_printf ("%s/%s", cache->path, dname)); g_free (uid); } g_dir_close (dir); while (deletes->len) { g_unlink (deletes->pdata[0]); g_free (deletes->pdata[0]); g_ptr_array_remove_index_fast (deletes, 0); } g_ptr_array_free (deletes, TRUE); return cache; }
static gint exchange_entry_play_append (CamelOfflineJournal *journal, CamelExchangeJournalEntry *entry, GCancellable *cancellable, GError **error) { CamelExchangeFolder *exchange_folder = (CamelExchangeFolder *) journal->folder; CamelFolder *folder = journal->folder; CamelMimeMessage *message; CamelMessageInfo *info, *real; CamelStream *stream; gchar *uid = NULL; /* if the message isn't in the cache, the user went behind our backs so "not our problem" */ if (!exchange_folder->cache || !(stream = camel_data_cache_get (exchange_folder->cache, "cache", entry->uid, NULL))) goto done; message = camel_mime_message_new (); if (!camel_data_wrapper_construct_from_stream_sync ( (CamelDataWrapper *) message, stream, cancellable, NULL)) { g_object_unref (message); g_object_unref (stream); goto done; } g_object_unref (stream); if (!(info = camel_folder_summary_get (folder->summary, entry->uid))) { /* Should have never happened, but create a new info to avoid further crashes */ info = camel_message_info_new (NULL); } if (!camel_folder_append_message_sync ( folder, message, info, &uid, cancellable, error)) return -1; real = camel_folder_summary_info_new_from_message (folder->summary, message, NULL); g_object_unref (message); if (uid != NULL && real) { real->uid = camel_pstring_strdup (uid); exchange_message_info_dup_to ((CamelMessageInfoBase *) real, (CamelMessageInfoBase *) info); camel_folder_summary_add (folder->summary, real); /* FIXME: should a folder_changed event be triggered? */ } camel_message_info_free (info); g_free (uid); done: camel_exchange_folder_remove_message (exchange_folder, entry->uid); return 0; }
static time_t vee_info_time (const CamelMessageInfo *mi, gint id) { CamelMessageInfo *rmi = camel_folder_summary_uid (((CamelVeeMessageInfo *)mi)->summary, mi->uid+8); time_t ret; HANDLE_NULL_INFO (0); ret = camel_message_info_time (rmi, id); camel_message_info_free (rmi); return ret; }
static const gchar * vee_info_user_tag (const CamelMessageInfo *mi, const gchar *id) { CamelMessageInfo *rmi = camel_folder_summary_uid (((CamelVeeMessageInfo *)mi)->summary, mi->uid+8); const gchar *ret; HANDLE_NULL_INFO(""); ret = camel_message_info_user_tag (rmi, id); camel_message_info_free (rmi); return ret; }
static gboolean vee_info_user_flag (const CamelMessageInfo *mi, const gchar *id) { CamelMessageInfo *rmi = camel_folder_summary_get (((CamelVeeMessageInfo *) mi)->orig_summary, mi->uid + 8); gboolean ret; HANDLE_NULL_INFO (FALSE); ret = camel_message_info_user_flag (rmi, id); camel_message_info_free (rmi); return ret; }
static gconstpointer vee_info_ptr (const CamelMessageInfo *mi, gint id) { CamelVeeMessageInfo *vmi = (CamelVeeMessageInfo *) mi; CamelMessageInfo *rmi; gpointer p; rmi = camel_folder_summary_uid (vmi->summary, mi->uid+8); HANDLE_NULL_INFO (NULL); p = (gpointer) camel_message_info_ptr (rmi, id); camel_message_info_free (rmi); return p; }
static guint32 vee_info_uint32 (const CamelMessageInfo *mi, gint id) { CamelMessageInfo *rmi = camel_folder_summary_get (((CamelVeeMessageInfo *) mi)->orig_summary, mi->uid + 8); guint32 ret; HANDLE_NULL_INFO (0); ret = camel_message_info_uint32 (rmi, id); camel_message_info_free (rmi); return ret; }
static gboolean vee_info_set_user_tag (CamelMessageInfo *mi, const gchar *name, const gchar *value) { gint res = FALSE; if (mi->uid) { CamelMessageInfo *rmi = camel_folder_summary_uid (((CamelVeeMessageInfo *)mi)->summary, mi->uid+8); HANDLE_NULL_INFO (FALSE); res = camel_message_info_set_user_tag (rmi, name, value); camel_message_info_free (rmi); } return res; }
static int groupwise_entry_play_append (CamelOfflineJournal *journal, CamelGroupwiseJournalEntry *entry, CamelException *ex) { CamelGroupwiseFolder *gw_folder = (CamelGroupwiseFolder *) journal->folder; CamelFolder *folder = journal->folder; CamelMimeMessage *message; CamelMessageInfo *info; CamelStream *stream; CamelException lex; /* if the message isn't in the cache, the user went behind our backs so "not our problem" */ if (!gw_folder->cache || !(stream = camel_data_cache_get (gw_folder->cache, "cache", entry->uid, ex))) goto done; message = camel_mime_message_new (); if (camel_data_wrapper_construct_from_stream ((CamelDataWrapper *) message, stream) == -1) { camel_object_unref (message); camel_object_unref (stream); goto done; } camel_object_unref (stream); if (!(info = camel_folder_summary_uid (folder->summary, entry->uid))) { /* Note: this should never happen, but rather than crash lets make a new info */ info = camel_message_info_new (NULL); } camel_exception_init (&lex); camel_folder_append_message (folder, message, info, NULL, &lex); camel_message_info_free (info); camel_object_unref (message); if (camel_exception_is_set (&lex)) { camel_exception_xfer (ex, &lex); return -1; } done: camel_folder_summary_remove_uid (folder->summary, entry->uid); camel_data_cache_remove (gw_folder->cache, "cache", entry->uid, NULL); return 0; }
static void imap4_fetch_all_free (struct imap4_fetch_all_t *fetch) { struct imap4_envelope_t *envelope; int i; for (i = 0; i < fetch->added->len; i++) { if (!(envelope = fetch->added->pdata[i])) continue; camel_message_info_free (envelope->info); g_free (envelope); } g_ptr_array_free (fetch->added, TRUE); g_hash_table_destroy (fetch->uid_hash); camel_folder_change_info_free (fetch->changes); g_free (fetch); }
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); }
static CamelMessageInfo * gw_message_info_load (CamelFolderSummary *s, FILE *in) { CamelMessageInfo *info ; CamelGroupwiseMessageInfo *gw_info ; info = camel_groupwise_summary_parent->message_info_load(s,in) ; if (info) { gw_info = (CamelGroupwiseMessageInfo*) info ; if (camel_file_util_decode_uint32 (in, &gw_info->server_flags) == -1) goto error ; } return info ; error: camel_message_info_free (info) ; return NULL ; }
static gboolean vee_info_set_flags (CamelMessageInfo *mi, guint32 flags, guint32 set) { gint res = FALSE; CamelVeeFolder *vf = CAMEL_VEE_FOLDER (camel_folder_summary_get_folder (mi->summary)); if (camel_debug("vfolderexp")) printf ( "Expression for vfolder '%s' is '%s'\n", camel_folder_get_full_name (CAMEL_FOLDER (vf)), g_strescape (vf->expression, "")); /* first update original message info... */ if (mi->uid) { CamelMessageInfo *rmi = camel_folder_summary_get (((CamelVeeMessageInfo *) mi)->orig_summary, mi->uid + 8); HANDLE_NULL_INFO (FALSE); /* ignore changes done in the folder itself, * unless it's a vTrash or vJunk folder */ if (!CAMEL_IS_VTRASH_FOLDER (vf)) camel_vee_folder_ignore_next_changed_event (vf, camel_folder_summary_get_folder (rmi->summary)); camel_folder_freeze (camel_folder_summary_get_folder (rmi->summary)); res = camel_message_info_set_flags (rmi, flags, set); ((CamelVeeMessageInfo *) mi)->old_flags = camel_message_info_flags (rmi); camel_folder_thaw (camel_folder_summary_get_folder (rmi->summary)); camel_message_info_free (rmi); } if (res) CAMEL_FOLDER_SUMMARY_CLASS (camel_vee_summary_parent_class)->info_set_flags (mi, flags, set); return res; }
static gboolean vee_info_set_user_flag (CamelMessageInfo *mi, const gchar *name, gboolean value) { gint res = FALSE; gboolean hacked_unread_folder = FALSE; CamelVeeFolder *vf = (CamelVeeFolder *)mi->summary->folder; if (camel_debug("vfolderexp")) printf ( "Expression for vfolder '%s' is '%s'\n", camel_folder_get_full_name (mi->summary->folder), g_strescape (vf->expression, "")); if (camel_vee_folder_get_unread_vfolder (vf) == -1) camel_vee_summary_load_check_unread_vfolder (CAMEL_VEE_SUMMARY (mi->summary)); if (camel_vee_folder_get_unread_vfolder (vf) == 1) hacked_unread_folder = TRUE; if (mi->uid) { CamelMessageInfo *rmi = camel_folder_summary_uid (((CamelVeeMessageInfo *)mi)->summary, mi->uid+8); HANDLE_NULL_INFO (FALSE); if (hacked_unread_folder) camel_vee_folder_mask_event_folder_changed ((CamelVeeFolder *)mi->summary->folder, rmi->summary->folder); res = camel_message_info_set_user_flag (rmi, name, value); if (hacked_unread_folder) camel_vee_folder_unmask_event_folder_changed ((CamelVeeFolder *)mi->summary->folder, rmi->summary->folder); camel_message_info_free (rmi); } return res; }
static gchar * maildir_folder_get_filename (CamelFolder *folder, const gchar *uid, GError **error) { CamelLocalFolder *lf = (CamelLocalFolder *)folder; CamelMaildirMessageInfo *mdi; CamelMessageInfo *info; gchar *res; /* get the message summary info */ if ((info = camel_folder_summary_uid (folder->summary, uid)) == NULL) { set_cannot_get_message_ex ( error, CAMEL_FOLDER_ERROR_INVALID_UID, uid, lf->folder_path, _("No such message")); return NULL; } mdi = (CamelMaildirMessageInfo *)info; /* what do we do if the message flags (and :info data) changes? filename mismatch - need to recheck I guess If filename is NULL, it means folder_summary_check is not yet executed. */ if (!camel_maildir_info_filename (mdi)) { gchar *temp; temp = camel_maildir_summary_info_to_name (mdi); res = g_strdup_printf("%s/cur/%s", lf->folder_path, temp); g_free (temp); } else res = g_strdup_printf("%s/cur/%s", lf->folder_path, camel_maildir_info_filename (mdi)); camel_message_info_free (info); return res; }
static gboolean vee_info_set_user_tag (CamelMessageInfo *mi, const gchar *name, const gchar *value) { gint res = FALSE; if (mi->uid) { CamelMessageInfo *rmi = camel_folder_summary_get (((CamelVeeMessageInfo *) mi)->orig_summary, mi->uid + 8); CamelFolder *folder = camel_folder_summary_get_folder (mi->summary); HANDLE_NULL_INFO (FALSE); /* ignore changes done in the folder itself, * unless it's a vTrash or vJunk folder */ if (!CAMEL_IS_VTRASH_FOLDER (folder)) camel_vee_folder_ignore_next_changed_event ((CamelVeeFolder *) folder, camel_folder_summary_get_folder (rmi->summary)); res = camel_message_info_set_user_tag (rmi, name, value); camel_message_info_free (rmi); } return res; }
static gint exchange_entry_play_transfer (CamelOfflineJournal *journal, CamelExchangeJournalEntry *entry, GCancellable *cancellable, GError **error) { CamelExchangeFolder *exchange_folder = (CamelExchangeFolder *) journal->folder; CamelFolder *folder = journal->folder; CamelMessageInfo *info, *real; GPtrArray *xuids, *uids; CamelFolder *src; CamelExchangeStore *store; CamelStream *stream; CamelMimeMessage *message; CamelStore *parent_store; if (!exchange_folder->cache || !(stream = camel_data_cache_get (exchange_folder->cache, "cache", entry->uid, NULL))) goto done; message = camel_mime_message_new (); if (!camel_data_wrapper_construct_from_stream_sync ( (CamelDataWrapper *) message, stream, cancellable, NULL)) { g_object_unref (message); g_object_unref (stream); goto done; } g_object_unref (stream); if (!(info = camel_folder_summary_get (folder->summary, entry->uid))) { /* Note: this should never happen, but rather than crash lets make a new info */ info = camel_message_info_new (NULL); } if (!entry->folder_name) { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("No folder name found")); goto exception; } parent_store = camel_folder_get_parent_store (folder); store = CAMEL_EXCHANGE_STORE (parent_store); g_mutex_lock (store->folders_lock); src = (CamelFolder *) g_hash_table_lookup (store->folders, entry->folder_name); g_mutex_unlock (store->folders_lock); if (src) { gboolean success; uids = g_ptr_array_sized_new (1); g_ptr_array_add (uids, entry->original_uid); success = camel_folder_transfer_messages_to_sync ( src, uids, folder, entry->delete_original, &xuids, cancellable, error); if (!success) goto exception; real = camel_folder_summary_info_new_from_message ( folder->summary, message, NULL); g_object_unref (message); real->uid = camel_pstring_strdup ( (gchar *) xuids->pdata[0]); /* Transfer flags */ exchange_message_info_dup_to ( (CamelMessageInfoBase *) real, (CamelMessageInfoBase *) info); camel_folder_summary_add (folder->summary, real); /* FIXME: should a folder_changed event be triggered? */ g_ptr_array_free (xuids, TRUE); g_ptr_array_free (uids, TRUE); /* g_object_unref (src); FIXME: should we? */ } else { g_set_error ( error, CAMEL_ERROR, CAMEL_ERROR_GENERIC, _("Folder doesn't exist")); goto exception; } camel_message_info_free (info); done: camel_exchange_folder_remove_message (exchange_folder, entry->uid); return 0; exception: camel_message_info_free (info); return -1; }
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 CamelMimeMessage * mh_folder_get_message_sync (CamelFolder *folder, const gchar *uid, GCancellable *cancellable, GError **error) { CamelLocalFolder *lf = (CamelLocalFolder *) folder; CamelStream *message_stream = NULL; CamelMimeMessage *message = NULL; CamelMessageInfo *info; gchar *name = NULL; d(printf("getting message: %s\n", uid)); if (!lf || camel_local_folder_lock (lf, CAMEL_LOCK_WRITE, error) == -1) return NULL; /* get the message summary info */ if ((info = camel_folder_summary_get (folder->summary, uid)) == NULL) { set_cannot_get_message_ex ( error, CAMEL_FOLDER_ERROR_INVALID_UID, uid, lf->folder_path, _("No such message")); goto fail; } /* we only need it to check the message exists */ camel_message_info_free (info); name = g_strdup_printf("%s/%s", lf->folder_path, uid); message_stream = camel_stream_fs_new_with_name ( name, O_RDONLY, 0, error); if (message_stream == NULL) { g_prefix_error ( error, _("Cannot get message %s from folder %s: "), name, lf->folder_path); goto fail; } message = camel_mime_message_new (); if (!camel_data_wrapper_construct_from_stream_sync ( (CamelDataWrapper *) message, message_stream, cancellable, error)) { g_prefix_error ( error, _("Cannot get message %s from folder %s: "), name, lf->folder_path); g_object_unref (message); message = NULL; } g_object_unref (message_stream); fail: g_free (name); camel_local_folder_unlock (lf); if (camel_folder_change_info_changed (lf->changes)) { camel_folder_changed (folder, lf->changes); camel_folder_change_info_clear (lf->changes); } return message; }
static void import_mbox_exec (struct _import_mbox_msg *m) { CamelFolder *folder; CamelMimeParser *mp = NULL; struct stat st; int fd; CamelMessageInfo *info; 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 = mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_INBOX); else folder = mail_tool_uri_to_folder(m->uri, CAMEL_STORE_FOLDER_CREATE, &m->base.ex); if (folder == NULL) return; if (S_ISREG(st.st_mode)) { CamelOperation *oldcancel = NULL; 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; } if (m->cancel) oldcancel = camel_operation_register(m->cancel); camel_operation_start(NULL, _("Importing `%s'"), folder->full_name); camel_folder_freeze(folder); while (camel_mime_parser_step(mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM) { CamelMimeMessage *msg; const char *tmp; int pc = 0; guint32 flags = 0; if (st.st_size > 0) pc = (int)(100.0 * ((double)camel_mime_parser_tell(mp) / (double)st.st_size)); camel_operation_progress(NULL, pc); msg = camel_mime_message_new(); if (camel_mime_part_construct_from_parser((CamelMimePart *)msg, mp) == -1) { /* set exception? */ camel_object_unref(msg); break; } info = camel_message_info_new(NULL); tmp = camel_medium_get_header((CamelMedium *)msg, "X-Mozilla-Status"); if (tmp) flags |= decode_mozilla_status(tmp); tmp = camel_medium_get_header((CamelMedium *)msg, "Status"); if (tmp) flags |= decode_status(tmp); tmp = camel_medium_get_header((CamelMedium *)msg, "X-Status"); if (tmp) flags |= decode_status(tmp); camel_message_info_set_flags(info, flags, ~0); camel_folder_append_message(folder, msg, info, NULL, &m->base.ex); camel_message_info_free(info); camel_object_unref(msg); if (camel_exception_is_set(&m->base.ex)) break; camel_mime_parser_step(mp, NULL, NULL); } camel_folder_sync(folder, FALSE, NULL); camel_folder_thaw(folder); camel_operation_end(NULL); /* TODO: these api's are a bit weird, registering the old is the same as deregistering */ if (m->cancel) camel_operation_register(oldcancel); fail2: camel_object_unref(mp); } fail1: camel_folder_sync(folder, FALSE, NULL); camel_object_unref(folder); }
static guint32 imap4_fetch_all_update (struct imap4_fetch_all_t *fetch) { CamelIMAP4MessageInfo *iinfo, *new_iinfo; CamelFolderChangeInfo *changes = NULL; struct imap4_envelope_t *envelope; CamelMessageInfo *info; guint32 first = 0; guint32 flags; int total, i; changes = fetch->changes; total = camel_folder_summary_count (fetch->summary); for (i = 0; i < total; i++) { info = camel_folder_summary_index (fetch->summary, i); if (!(envelope = g_hash_table_lookup (fetch->uid_hash, camel_message_info_uid (info)))) { /* remove it */ camel_folder_change_info_remove_uid (changes, camel_message_info_uid (info)); camel_folder_summary_remove (fetch->summary, info); total--; i--; } else if (envelope->changed & IMAP4_FETCH_FLAGS) { /* update it with the new flags */ new_iinfo = (CamelIMAP4MessageInfo *) envelope->info; iinfo = (CamelIMAP4MessageInfo *) info; flags = iinfo->info.flags; iinfo->info.flags = camel_imap4_merge_flags (iinfo->server_flags, iinfo->info.flags, new_iinfo->server_flags); iinfo->server_flags = new_iinfo->server_flags; if (iinfo->info.flags != flags) camel_folder_change_info_change_uid (changes, camel_message_info_uid (info)); } camel_message_info_free (info); } for (i = 0; i < fetch->added->len; i++) { if (!(envelope = fetch->added->pdata[i])) { courier_imap_is_a_piece_of_shit (fetch->summary, i + fetch->first); break; } info = envelope->info; if (!first && camel_message_info_uid (info)) { if ((info = camel_folder_summary_uid (fetch->summary, camel_message_info_uid (info)))) { camel_message_info_free(info); } else { first = i + fetch->first; } } camel_message_info_free(envelope->info); g_free (envelope); } g_ptr_array_free (fetch->added, TRUE); g_hash_table_destroy (fetch->uid_hash); if (camel_folder_change_info_changed (changes)) camel_object_trigger_event (fetch->summary->folder, "folder_changed", changes); camel_folder_change_info_free (changes); g_free (fetch); return first; }
static gboolean vee_info_set_flags (CamelMessageInfo *mi, guint32 flags, guint32 set) { gint res = FALSE; CamelVeeFolder *vf = (CamelVeeFolder *)mi->summary->folder; gboolean hacked_unread_folder = FALSE; if (camel_debug("vfolderexp")) printf ( "Expression for vfolder '%s' is '%s'\n", camel_folder_get_full_name (mi->summary->folder), g_strescape (vf->expression, "")); if (camel_vee_folder_get_unread_vfolder (vf) == -1) camel_vee_summary_load_check_unread_vfolder (CAMEL_VEE_SUMMARY (mi->summary)); if (camel_vee_folder_get_unread_vfolder (vf) == 1) hacked_unread_folder = TRUE; if (mi->uid) { guint32 old_visible, visible, old_unread; CamelMessageInfo *rmi = camel_folder_summary_uid (((CamelVeeMessageInfo *)mi)->summary, mi->uid+8); CamelVeeSummary *vsummary = (CamelVeeSummary *)mi->summary; HANDLE_NULL_INFO (FALSE); old_visible = rmi->summary->visible_count; old_unread = mi->summary->unread_count; camel_folder_summary_update_counts_by_flags (mi->summary, camel_message_info_flags (rmi), TRUE); if (hacked_unread_folder) camel_vee_folder_mask_event_folder_changed ((CamelVeeFolder *)mi->summary->folder, rmi->summary->folder); camel_folder_freeze (rmi->summary->folder); res = camel_message_info_set_flags (rmi, flags, set); ((CamelVeeMessageInfo *) mi)->old_flags = camel_message_info_flags (rmi); camel_folder_thaw (rmi->summary->folder); if (hacked_unread_folder) camel_vee_folder_unmask_event_folder_changed ((CamelVeeFolder *)mi->summary->folder, rmi->summary->folder); visible = rmi->summary->visible_count; /* Keep the summary in sync */ camel_folder_summary_update_counts_by_flags (mi->summary, camel_message_info_flags (rmi), FALSE); if (hacked_unread_folder && !vsummary->fake_visible_count) vsummary->fake_visible_count = mi->summary->visible_count; if (vsummary->fake_visible_count || hacked_unread_folder) vsummary->fake_visible_count += visible - old_visible; d(printf("VF %d %d %d %d %d\n", mi->summary->unread_count, mi->summary->deleted_count, mi->summary->junk_count, mi->summary->junk_not_deleted_count, mi->summary->visible_count)); /* This is where the ugly-created-hack is used */ if (hacked_unread_folder && mi->summary->unread_count - old_unread != 0) { CamelFolderChangeInfo *changes = camel_folder_change_info_new (); GPtrArray *match, *array; camel_folder_change_info_change_uid (changes, mi->uid); array = g_ptr_array_new (); g_ptr_array_add (array, (gpointer)rmi->uid); match = camel_folder_search_by_uids (rmi->summary->folder, vf->expression, array, NULL); if ((match && !match->len) || !match) { vsummary->fake_visible_count--; } else { vsummary->fake_visible_count++; } g_ptr_array_free (array, TRUE); if (match) camel_folder_search_free (rmi->summary->folder, match); camel_folder_changed (mi->summary->folder, changes); camel_folder_change_info_free (changes); } camel_message_info_free (rmi); } return res; }