diff options
Diffstat (limited to 'camel/providers/imap')
| -rw-r--r-- | camel/providers/imap/camel-imap-stream.c | 208 | ||||
| -rw-r--r-- | camel/providers/imap/camel-imap-stream.h | 70 | ||||
| -rw-r--r-- | camel/providers/imap/camel-imap-summary.c | 771 |
3 files changed, 1049 insertions, 0 deletions
diff --git a/camel/providers/imap/camel-imap-stream.c b/camel/providers/imap/camel-imap-stream.c new file mode 100644 index 0000000000..24198bfd49 --- /dev/null +++ b/camel/providers/imap/camel-imap-stream.c @@ -0,0 +1,208 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * Authors: Jeffrey Stedfast <fejj@helixcode.com> + * + * Copyright 2000 Helix Code, Inc. (www.helixcode.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA. + * + */ + + +#include <config.h> +#include "camel-imap-stream.h" +#include <sys/types.h> +#include <errno.h> + +static CamelStreamClass *parent_class = NULL; + +/* Returns the class for a CamelImapStream */ +#define CIS_CLASS(so) CAMEL_IMAP_STREAM_CLASS (GTK_OBJECT(so)->klass) + +static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n); +static int stream_reset (CamelStream *stream); +static gboolean stream_eos (CamelStream *stream); + +static void finalize (GtkObject *object); + +static void +camel_imap_stream_class_init (CamelImapStreamClass *camel_imap_stream_class) +{ + CamelStreamClass *camel_stream_class = + CAMEL_STREAM_CLASS (camel_imap_stream_class); + GtkObjectClass *gtk_object_class = + GTK_OBJECT_CLASS (camel_imap_stream_class); + + parent_class = gtk_type_class (camel_stream_get_type ()); + + /* virtual method overload */ + camel_stream_class->read = stream_read; + /*camel_stream_class->write = stream_write;*/ + camel_stream_class->reset = stream_reset; + camel_stream_class->eos = stream_eos; + + gtk_object_class->finalize = finalize; +} + +static void +camel_imap_stream_init (gpointer object, gpointer klass) +{ + CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (object); + + imap_stream->cache = NULL; + imap_stream->cache_ptr = NULL; +} + +GtkType +camel_imap_stream_get_type (void) +{ + static GtkType camel_imap_stream_type = 0; + + if (!camel_imap_stream_type) { + GtkTypeInfo camel_imap_stream_info = + { + "CamelImapStream", + sizeof (CamelImapStream), + sizeof (CamelImapStreamClass), + (GtkClassInitFunc) camel_imap_stream_class_init, + (GtkObjectInitFunc) camel_imap_stream_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + camel_imap_stream_type = gtk_type_unique (camel_stream_get_type (), &camel_imap_stream_info); + } + + return camel_imap_stream_type; +} + +CamelStream * +camel_imap_stream_new (CamelImapFolder *folder, char *command) +{ + CamelImapStream *imap_stream; + + imap_stream = gtk_type_new (camel_imap_stream_get_type ()); + + imap_stream->folder = folder; + gtk_object_ref(GTK_OBJECT (imap_stream->folder)); + + imap_stream->command = g_strdup(command); + + return CAMEL_STREAM (imap_stream); +} + +static void +finalize (GtkObject *object) +{ + CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (object); + + g_free(imap_stream->cache); + g_free(imap_stream->command); + + if (imap_stream->folder) + gtk_object_unref(imap_stream->folder); + + GTK_OBJECT_CLASS (parent_class)->finalize (object); +} + +static ssize_t +stream_read (CamelStream *stream, char *buffer, size_t n) +{ + ssize_t nread; + + /* do we want to do any IMAP specific parsing in here? If not, maybe rename to camel-stream-cache? */ + CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream); + + if (!imap_stream->cache) { + /* We need to send the IMAP command since this is our first fetch */ + CamelImapStore *store = CAMEL_IMAP_STORE (imap_stream->folder->parent_store); + gint status; + + status = camel_imap_command_extended(store->ostream, imap_stream->cache, "%s", + imap_stream->command); + + if (status != CAMEL_IMAP_OK) { + /* we got an error, dump this stuff */ + g_free(imap_stream->cache); + imap_stream->cache = NULL; + + return -1; + } + + /* we don't need the folder anymore... */ + gtk_object_unref(GTK_OBJECT (imap_stream->folder)); + + imap_stream->cache_ptr = imap_stream->cache; + } + + /* we've already read this stream, so return whats in the cache */ + nread = MIN (n, strlen(imap_stream->cache_ptr)); + + if (nread > 0) { + memcpy(buffer, imap_stream->cache_ptr, nread); + imap_stream->cache_ptr += nread; + } else { + nread = -1; + } + + return nread; +} + +static int +stream_write (CamelStream *stream, const char *buffer, unsigned int n) +{ + /* I don't think we need/want this functionality */ + CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream); + + if (!imap_stream->cache) { + imap_stream->cache = g_malloc0(n + 1); + memcpy(imap_stream->cache, buffer, n); + } else { + imap_stream->cache = g_realloc(strlen(imap_stream->cache) + n + 1); + memcpy(imap_stream->cache[strlen(imap_stream->cache)], buffer, n); + } + + return n; +} + +static int +stream_reset (CamelStream *stream) +{ + CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream); + + imap_stream->cache_ptr = imap_stream->cache; + + return 1; +} + +static gboolean +stream_eos (CamelStream *stream) +{ + CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream); + + return (imap_stream->cache_ptr && strlen(imap_stream->cache_ptr)); +} + + + + + + + + + + + diff --git a/camel/providers/imap/camel-imap-stream.h b/camel/providers/imap/camel-imap-stream.h new file mode 100644 index 0000000000..01e7e59e18 --- /dev/null +++ b/camel/providers/imap/camel-imap-stream.h @@ -0,0 +1,70 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * Authors: Jeffrey Stedfast <fejj@helixcode.com> + * + * Copyright 2000 Helix Code, Inc. (www.helixcode.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA. + * + */ + + + +#ifndef CAMEL_IMAP_STREAM_H +#define CAMEL_IMAP_STREAM_H + + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus }*/ + +#include <camel/camel-stream.h> +#include <camel/providers/imap/camel-imap-folder.h> +#include <camel/providers/imap/camel-imap-store.h> +#include <sys/types.h> + +#define CAMEL_IMAP_STREAM_TYPE (camel_imap_stream_get_type ()) +#define CAMEL_IMAP_STREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_IMAP_STREAM_TYPE, CamelImapStream)) +#define CAMEL_IMAP_STREAM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_IMAP_STREAM_TYPE, CamelImapStreamClass)) +#define CAMEL_IS_IMAP_STREAM(o) (GTK_CHECK_TYPE((o), CAMEL_IMAP_STREAM_TYPE)) + +struct _CamelImapStream +{ + CamelStream parent_object; + + CamelImapFolder *folder; + char *command; + char *cache; + char *cache_ptr; +}; + +typedef struct { + CamelStreamClass parent_class; + + /* Virtual methods */ +} CamelImapStreamClass; + +/* Standard Gtk function */ +GtkType camel_imap_stream_get_type (void); + +/* public methods */ +CamelStream *camel_imap_stream_new (CamelImapFolder *folder, char *command); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* CAMEL_IMAP_STREAM_H */ diff --git a/camel/providers/imap/camel-imap-summary.c b/camel/providers/imap/camel-imap-summary.c new file mode 100644 index 0000000000..29fece6831 --- /dev/null +++ b/camel/providers/imap/camel-imap-summary.c @@ -0,0 +1,771 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * Authors: Jeffrey Stedfast <fejj@helixcode.com> + * + * Copyright 2000 Helix Code, Inc. (www.helixcode.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA. + * + */ + + +#include "camel-imap-summary.h" +#include <camel/camel-mime-message.h> + +#include <sys/stat.h> +#include <sys/uio.h> +#include <unistd.h> +#include <errno.h> +#include <string.h> +#include <stdlib.h> + +#define io(x) +#define d(x) + +#define CAMEL_IMAP_SUMMARY_VERSION (0x1000) + +struct _CamelImapSummaryPrivate { +}; + +#define _PRIVATE(o) (((CamelImapSummary *)(o))->priv) + +static int summary_header_load (CamelFolderSummary *, FILE *); +static int summary_header_save (CamelFolderSummary *, FILE *); + +static CamelMessageInfo *message_info_new (CamelFolderSummary *, struct _header_raw *); +static CamelMessageInfo *message_info_new_from_parser (CamelFolderSummary *, CamelMimeParser *); +static CamelMessageInfo *message_info_load (CamelFolderSummary *, FILE *); +static int message_info_save (CamelFolderSummary *, FILE *, CamelMessageInfo *); +/*static void message_info_free (CamelFolderSummary *, CamelMessageInfo *);*/ + +static void camel_imap_summary_class_init (CamelImapSummaryClass *klass); +static void camel_imap_summary_init (CamelImapSummary *obj); +static void camel_imap_summary_finalise (GtkObject *obj); + +static CamelFolderSummaryClass *camel_imap_summary_parent; + +enum SIGNALS { + LAST_SIGNAL +}; + +static guint signals[LAST_SIGNAL] = { 0 }; + +guint +camel_imap_summary_get_type (void) +{ + static guint type = 0; + + if (!type) { + GtkTypeInfo type_info = { + "CamelImapSummary", + sizeof (CamelImapSummary), + sizeof (CamelImapSummaryClass), + (GtkClassInitFunc) camel_imap_summary_class_init, + (GtkObjectInitFunc) camel_imap_summary_init, + (GtkArgSetFunc) NULL, + (GtkArgGetFunc) NULL + }; + + type = gtk_type_unique (camel_folder_summary_get_type (), &type_info); + } + + return type; +} + +static void +camel_imap_summary_class_init (CamelImapSummaryClass *klass) +{ + GtkObjectClass *object_class = (GtkObjectClass *) klass; + CamelFolderSummaryClass *sklass = (CamelFolderSummaryClass *) klass; + + camel_imap_summary_parent = gtk_type_class (camel_folder_summary_get_type ()); + + object_class->finalize = camel_imap_summary_finalise; + + sklass->summary_header_load = summary_header_load; + sklass->summary_header_save = summary_header_save; + + sklass->message_info_new = message_info_new; + sklass->message_info_new_from_parser = message_info_new_from_parser; + sklass->message_info_load = message_info_load; + sklass->message_info_save = message_info_save; + /*sklass->message_info_free = message_info_free;*/ + + gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL); +} + +static void +camel_imap_summary_init (CamelImapSummary *obj) +{ + struct _CamelImapSummaryPrivate *p; + struct _CamelFolderSummary *s = (CamelFolderSummary *)obj; + + p = _PRIVATE(obj) = g_malloc0(sizeof(*p)); + + /* subclasses need to set the right instance data sizes */ + s->message_info_size = sizeof(CamelImapMessageInfo); + s->content_info_size = sizeof(CamelImapMessageContentInfo); + + /* and a unique file version */ + s->version += CAMEL_IMAP_SUMMARY_VERSION; +} + +static void +camel_imap_summary_finalise (GtkObject *obj) +{ + CamelImapSummary *mbs = (CamelImapSummary *)obj; + + g_free(mbs->folder_path); + + ((GtkObjectClass *)(camel_imap_summary_parent))->finalize((GtkObject *)obj); +} + +/** + * camel_imap_summary_new: + * + * Create a new CamelImapSummary object. + * + * Return value: A new CamelImapSummary widget. + **/ +CamelImapSummary * +camel_imap_summary_new (const char *filename, const char *imap_name, ibex *index) +{ + CamelImapSummary *new = CAMEL_IMAP_SUMMARY ( gtk_type_new (camel_imap_summary_get_type ())); + if (new) { + /* ?? */ + camel_folder_summary_set_build_content(CAMEL_FOLDER_SUMMARY (new), TRUE); + camel_folder_summary_set_filename(CAMEL_FOLDER_SUMMARY (new), filename); + new->folder_path = g_strdup(imap_name); + new->index = index; + } + + return new; +} + + +static int +summary_header_load (CamelFolderSummary *s, FILE *in) +{ + CamelImapSummary *mbs = CAMEL_IMAP_SUMMARY (s); + + if (((CamelFolderSummaryClass *)camel_imap_summary_parent)->summary_header_load(s, in) == -1) + return -1; + + return camel_folder_summary_decode_uint32(in, &mbs->folder_size); +} + +static int +summary_header_save(CamelFolderSummary *s, FILE *out) +{ + CamelImapSummary *mbs = CAMEL_IMAP_SUMMARY (s); + + if (((CamelFolderSummaryClass *)camel_imap_summary_parent)->summary_header_save(s, out) == -1) + return -1; + + return camel_folder_summary_encode_uint32(out, mbs->folder_size); +} + +static int +header_evolution_decode(const char *in, guint32 *uid, guint32 *flags) +{ + char *header; + + if (in && (header = header_token_decode(in))) { + if (strlen(header) == strlen("00000000-0000") + && sscanf(header, "%08x-%04x", uid, flags) == 2) { + g_free(header); + return *uid; + } + g_free(header); + } + + return -1; +} + +static char * +header_evolution_encode (guint32 uid, guint32 flags) +{ + return g_strdup_printf("%08x-%04x", uid, flags & 0xffff); +} + +static CamelMessageInfo * +message_info_new (CamelFolderSummary *s, struct _header_raw *h) +{ + CamelMessageInfo *mi; + + mi = CAMEL_FOLDER_SUMMARY_CLASS (camel_imap_summary_parent)->message_info_new(s, h); + if (mi) { + const char *xev; + guint32 uid, flags; + CamelImapMessageInfo *mbi = CAMEL_IMAP_MESSAGE_INFO (mi); + + xev = header_raw_find(&h, "X-Evolution", NULL); + if (xev && header_evolution_decode(xev, &uid, &flags) != -1) { + g_free(mi->uid); + mi->uid = g_strdup_printf("%u", uid); + mi->flags = flags; + } else { + /* to indicate it has no xev header? */ + mi->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED | CAMEL_MESSAGE_FOLDER_NOXEV; + mi->uid = g_strdup_printf("%u", camel_folder_summary_next_uid(s)); + } + mbi->frompos = -1; + } + + return mi; +} + +static CamelMessageInfo * +message_info_new_from_parser (CamelFolderSummary *s, CamelMimeParser *mp) +{ + CamelMessageInfo *mi; + CamelImapSummary *mbs = CAMEL_IMAP_SUMMARY (s); + + mi = ((CamelFolderSummaryClass *)camel_imap_summary_parent)->message_info_new_from_parser(s, mp); + if (mi) { + CamelImapMessageInfo *mbi = (CamelImapMessageInfo *)mi; + + mbi->frompos = camel_mime_parser_tell_start_from(mp); + + /* do we want to index this message as we add it, as well? */ + if (mbs->index_force + || (mi->flags & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0 + || !ibex_contains_name(mbs->index, mi->uid)) { + camel_folder_summary_set_index(s, mbs->index); + } else { + camel_folder_summary_set_index(s, NULL); + } + } + return mi; +} + +static CamelMessageInfo * +message_info_load (CamelFolderSummary *s, FILE *in) +{ + CamelMessageInfo *mi; + + io(printf("loading imap message info\n")); + + mi = ((CamelFolderSummaryClass *)camel_imap_summary_parent)->message_info_load(s, in); + if (mi) { + CamelImapMessageInfo *mbi = CAMEL_IMAP_MESSAGE_INFO (mi); + + camel_folder_summary_decode_uint32(in, &mbi->frompos); + } + return mi; +} + +static int +message_info_save (CamelFolderSummary *s, FILE *out, CamelMessageInfo *mi) +{ + CamelImapMessageInfo *mbi = (CamelImapMessageInfo *)mi; + + io(printf("saving imap message info\n")); + + ((CamelFolderSummaryClass *)camel_imap_summary_parent)->message_info_save(s, out, mi); + + return camel_folder_summary_encode_uint32(out, mbi->frompos); +} + +static int +summary_rebuild (CamelImapSummary *mbs, off_t offset) +{ + CamelMimeParser *mp; + int fd; + int ok = 0; + + printf("(re)Building summary from %d (%s)\n", (int)offset, mbs->folder_path); + + fd = open(mbs->folder_path, O_RDONLY); + mp = camel_mime_parser_new(); + camel_mime_parser_init_with_fd(mp, fd); + camel_mime_parser_scan_from(mp, TRUE); + camel_mime_parser_seek(mp, offset, SEEK_SET); + + if (offset > 0) { + if (camel_mime_parser_step(mp, NULL, NULL) == HSCAN_FROM) { + if (camel_mime_parser_tell_start_from(mp) != offset) { + g_warning("The next message didn't start where I expected\nbuilding summary from start"); + camel_mime_parser_drop_step(mp); + offset = 0; + camel_mime_parser_seek(mp, offset, SEEK_SET); + camel_folder_summary_clear(CAMEL_FOLDER_SUMMARY (mbs)); + } else { + camel_mime_parser_unstep(mp); + } + } else { + gtk_object_unref(GTK_OBJECT (mp)); + /* end of file - no content? */ + printf("We radn out of file?\n"); + return -1; + } + } + + while (camel_mime_parser_step(mp, NULL, NULL) == HSCAN_FROM) { + CamelMessageInfo *info; + + info = camel_folder_summary_add_from_parser(CAMEL_FOLDER_SUMMARY (mbs), mp); + if (info == NULL) { + printf("Could not build info from file?\n"); + ok = -1; + break; + } + + g_assert(camel_mime_parser_step(mp, NULL, NULL) == HSCAN_FROM_END); + } + + /* update the file size in the summary */ + if (ok != -1) + mbs->folder_size = camel_mime_parser_seek(mp, 0, SEEK_CUR); + printf("updating folder size = %d\n", mbs->folder_size); + gtk_object_unref(GTK_OBJECT (mp)); + + return ok; +} + +int +camel_imap_summary_update (CamelImapSummary *mbs, off_t offset) +{ + int ret; + + mbs->index_force = FALSE; + ret = summary_rebuild(mbs, offset); + +#if 0 +#warning "Saving full summary and index after every summarisation is slow ..." + if (ret != -1) { + if (camel_folder_summary_save(CAMEL_FOLDER_SUMMARY (mbs)) == -1) + g_warning("Could not save summary: %s", strerror(errno)); + printf("summary saved\n"); + if (mbs->index) + ibex_save(mbs->index); + printf("ibex saved\n"); + } +#endif + return ret; +} + +int +camel_imap_summary_load (CamelImapSummary *mbs, int forceindex) +{ + CamelFolderSummary *s = CAMEL_FOLDER_SUMMARY (mbs); + struct stat st; + int ret = 0; + off_t minstart; + + mbs->index_force = forceindex; + + /* is the summary out of date? */ + if (stat(mbs->folder_path, &st) == -1) { + camel_folder_summary_clear(s); + printf("Cannot summarise folder: '%s': %s\n", mbs->folder_path, strerror(errno)); + return -1; + } + + if (forceindex || camel_folder_summary_load(s) == -1) { + camel_folder_summary_clear(s); + ret = summary_rebuild(mbs, 0); + } else { + minstart = st.st_size; +#if 0 + /* find out the first unindexed message ... */ + /* TODO: For this to work, it has to check that the message is + indexable, and contains content ... maybe it cannot be done + properly? */ + for (i=0;i<camel_folder_summary_count(s);i++) { + CamelMessageInfo *mi = camel_folder_summary_index(s, i); + if (!ibex_contains_name(mbs->index, mi->uid)) { + minstart = ((CamelImapMessageInfo *)mi)->frompos; + printf("Found unindexed message: %s\n", mi->uid); + break; + } + } +#endif + /* is the summary uptodate? */ + if (st.st_size == mbs->folder_size && st.st_mtime == s->time) { + printf("Summary time and date match imap\n"); + if (minstart < st.st_size) { + /* FIXME: Only clear the messages and reindex from this point forward */ + camel_folder_summary_clear(s); + ret = summary_rebuild(mbs, 0); + } + } else { + if (mbs->folder_size < st.st_size) { + printf("Index is for a smaller imap\n"); + if (minstart < mbs->folder_size) { + /* FIXME: only make it rebuild as necessary */ + camel_folder_summary_clear(s); + ret = summary_rebuild(mbs, 0); + } else { + ret = summary_rebuild(mbs, mbs->folder_size); + } + } else { + printf("index is for a bigger imap\n"); + camel_folder_summary_clear(s); + ret = summary_rebuild(mbs, 0); + } + } + } + + if (ret != -1) { + mbs->folder_size = st.st_size; + s->time = st.st_mtime; + printf("saving summary\n"); + if (camel_folder_summary_save(s) == -1) + g_warning("Could not save summary: %s", strerror(errno)); + printf("summary saved\n"); + if (mbs->index) + ibex_save(mbs->index); + printf("ibex saved\n"); + } + + return ret; +} + +static int +header_write (int fd, struct _header_raw *header, char *xevline) +{ + struct iovec iv[4]; + int outlen = 0, len; + + iv[1].iov_base = ":"; + iv[1].iov_len = 1; + iv[3].iov_base = "\n"; + iv[3].iov_len = 1; + + while (header) { + if (strcasecmp(header->name, "X-Evolution")) { + iv[0].iov_base = header->name; + iv[0].iov_len = strlen(header->name); + iv[2].iov_base = header->value; + iv[2].iov_len = strlen(header->value); + + do { + len = writev(fd, iv, 4); + } while (len == -1 && errno == EINTR); + + if (len == -1) + return -1; + outlen += len; + } + header = header->next; + } + + iv[0].iov_base = "X-Evolution: "; + iv[0].iov_len = strlen(iv[0].iov_base); + iv[1].iov_base = xevline; + iv[1].iov_len = strlen(xevline); + iv[2].iov_base = "\n\n"; + iv[2].iov_len = 2; + + do { + len = writev(fd, iv, 3); + } while (len == -1 && errno == EINTR); + + if (len == -1) + return -1; + + outlen += 1; + + d(printf("Wrote %d bytes of headers\n", outlen)); + + return outlen; +} + +static int +copy_block (int fromfd, int tofd, off_t start, size_t bytes) +{ + char buffer[4096]; + int written = 0; + + d(printf("writing %d bytes ... ", bytes)); + + if (lseek(fromfd, start, SEEK_SET) != start) + return -1; + + while (bytes > 0) { + int toread, towrite; + + toread = bytes; + if (bytes>4096) + toread = 4096; + else + toread = bytes; + do { + towrite = read(fromfd, buffer, toread); + } while (towrite == -1 && errno == EINTR); + + if (towrite == -1) + return -1; + + /* check for 'end of file' */ + if (towrite == 0) { + d(printf("end of file?\n")); + break; + } + + do { + toread = write(tofd, buffer, towrite); + } while (toread == -1 && errno == EINTR); + + if (toread == -1) + return -1; + + written += toread; + bytes -= toread; + } + + d(printf("written %d bytes\n", written)); + + return written; +} + +int +camel_imap_summary_expunge (CamelImapSummary *mbs) +{ + CamelMimeParser *mp = NULL; + int i, count; + CamelImapMessageInfo *info; + CamelFolderSummary *s = CAMEL_FOLDER_SUMMARY mbs); + int fd = -1, fdout= -1; + off_t offset = 0; + char *tmpname = 0; + char *buffer, *xevnew = NULL; + const char *xev; + int len; + guint32 uid, flags; + int quick = TRUE, work = FALSE; + + /* make sure we're in sync */ + count = camel_folder_summary_count(s); + if (count>0) { + CamelMessageInfo *mi = camel_folder_summary_index(s, count-1); + camel_imap_summary_update(mbs, mi->content->endpos); + } else { + camel_imap_summary_update(mbs, 0); + } + + /* check if we have any work to do */ + d(printf("Performing expunge, %d messages in inbox\n", count)); + for (i=0;quick && i<count;i++) { + info = (CamelImapMessageInfo *)camel_folder_summary_index(s, i); + if (info->info.flags & (CAMEL_MESSAGE_DELETED|CAMEL_MESSAGE_FOLDER_NOXEV)) + quick = FALSE; + else + work |= (info->info.flags & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0; + } + + d(printf("Options: %s %s\n", quick?"quick":"", work?"Work":"")); + + if (quick && !work) + return 0; + + fd = open(mbs->folder_path, O_RDWR); + if (fd == -1) + return -1; + + mp = camel_mime_parser_new(); + camel_mime_parser_scan_from(mp, TRUE); + camel_mime_parser_init_with_fd(mp, fd); + + if (!quick) { + tmpname = alloca(strlen(mbs->folder_path)+5); + sprintf(tmpname, "%s.tmp", mbs->folder_path); + d(printf("Writing tmp file to %s\n", tmpname)); + retry_out: + fdout = open(tmpname, O_WRONLY|O_CREAT|O_EXCL, 0600); + if (fdout == -1) { + if (errno == EEXIST) + if (unlink(tmpname) != -1) + goto retry_out; + tmpname = 0; + goto error; + } + } + + for (i = 0; i < count; i++) { + off_t frompos, bodypos; + off_t xevoffset; + + info = (CamelImapMessageInfo *)camel_folder_summary_index(s, i); + + g_assert(info); + + d(printf("Looking at message %s\n", info->info.uid)); + + if (info->info.flags & CAMEL_MESSAGE_DELETED) { + d(printf("Deleting %s\n", info->info.uid)); + + g_assert(!quick); + offset -= (info->info.content->endpos - info->frompos); + if (mbs->index) + ibex_unindex(mbs->index, info->info.uid); + camel_folder_summary_remove(s, (CamelMessageInfo *)info); + count--; + i--; + info = NULL; + } else if (info->info.flags & (CAMEL_MESSAGE_FOLDER_NOXEV|CAMEL_MESSAGE_FOLDER_FLAGGED)) { + int xevok = FALSE; + + d(printf("Updating header for %s flags = %08x\n", info->info.uid, info->info.flags)); + + /* find the next message, header parts */ + camel_mime_parser_seek(mp, info->frompos, SEEK_SET); + if (camel_mime_parser_step(mp, &buffer, &len) != HSCAN_FROM) + goto error; + + if (camel_mime_parser_tell_start_from(mp) != info->frompos) { + g_error("Summary/imap mismatch, aborting expunge"); + goto error; + } + + if (camel_mime_parser_step(mp, &buffer, &len) == HSCAN_FROM_END) + goto error; + + xev = camel_mime_parser_header(mp, "X-Evolution", (int *)&xevoffset); + if (xev && header_evolution_decode(xev, &uid, &flags) != -1) { + char name[64]; + + sprintf(name, "%u", uid); + if (strcmp(name, info->info.uid)) { + d(printf("Summary mismatch, aborting leaving mailbox intact\n")); + goto error; + } + xevok = TRUE; + } + xevnew = header_evolution_encode(strtoul(info->info.uid, NULL, 10), info->info.flags & 0xffff); + if (quick) { + if (!xevok) { + g_error("The summary told me I had an X-Evolution header, but i dont!"); + goto error; + } + buffer = g_strdup_printf("X-Evolution: %s", xevnew); + do { + len = write(fd, buffer, strlen(buffer)); + } while (len == -1 && errno == EINTR); + g_free(buffer); + if (len == -1) { + goto error; + } + } else { + frompos = lseek(fdout, 0, SEEK_CUR); + write(fdout, "From -\n", strlen("From -\n")); + if (header_write(fdout, camel_mime_parser_headers_raw(mp), xevnew) == -1) { + d(printf("Error writing to tmp mailbox\n")); + goto error; + } + bodypos = lseek(fdout, 0, SEEK_CUR); + d(printf("pos = %d, endpos = %d, bodypos = %d\n", + info->info.content->pos, + info->info.content->endpos, + info->info.content->bodypos)); + if (copy_block(fd, fdout, info->info.content->bodypos, + info->info.content->endpos - info->info.content->bodypos) == -1) { + g_warning("Cannot copy data to output fd"); + goto error; + } + info->frompos = frompos; + offset = bodypos - info->info.content->bodypos; + } + info->info.flags &= 0xffff; + g_free(xevnew); xevnew = NULL; + camel_mime_parser_drop_step(mp); + camel_mime_parser_drop_step(mp); + } else { + if (!quick) { + if (copy_block(fd, fdout, info->frompos, + info->info.content->endpos - info->frompos) == -1) { + g_warning("Cannot copy data to output fd"); + goto error; + } + /* update from pos here? */ + info->frompos += offset; + } else { + d(printf("Nothing to do for this message\n")); + } + } + if (!quick && info!=NULL && offset!=0) { + d(printf("offsetting content: %d\n", offset)); + camel_folder_summary_offset_content(info->info.content, offset); + d(printf("pos = %d, endpos = %d, bodypos = %d\n", + info->info.content->pos, + info->info.content->endpos, + info->info.content->bodypos)); + } + } + + d(printf("Closing folders\n")); + + if (close(fd) == -1) { + g_warning("Cannot close source folder: %s", strerror(errno)); + goto error; + } + + if (!quick) { + struct stat st; + + if (close(fdout) == -1) { + g_warning("Cannot close tmp folder: %s", strerror(errno)); + goto error; + } + + if (rename(tmpname, mbs->folder_path) == -1) { + g_warning("Cannot rename folder: %s", strerror(errno)); + goto error; + } + tmpname = 0; + + if (stat(mbs->folder_path, &st) == -1) + goto error; + + camel_folder_summary_touch(s); + s->time = st.st_mtime; + mbs->folder_size = st.st_size; + camel_folder_summary_save(s); + if (mbs->index) + ibex_save(mbs->index); + } + + gtk_object_unref((GtkObject *)mp); + + return 0; +error: + d(printf("Error occured: %s\n", strerror(errno))); + count = errno; + + close(fd); + close(fdout); + + g_free(xevnew); + + if (tmpname) + unlink(tmpname); + if (mp) + gtk_object_unref((GtkObject *)mp); + + errno = count; + return -1; +} + + + + + + + + + + + |