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