path: root/mail/em-migrate.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 *  Authors: Jeffrey Stedfast <fejj@ximian.com>
 *
 *  Copyright 2003 Ximian, Inc. (www.ximian.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.
 *
 */


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>

#include <gtk/gtk.h>

#include <camel/camel.h>
#include <camel/camel-session.h>
#include <camel/camel-file-utils.h>

#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/xmlmemory.h>

#include <gal/util/e-xml-utils.h>

#include "em-migrate.h"


#define EM_MIGRATE_SESSION_TYPE     (em_migrate_session_get_type ())
#define EM_MIGRATE_SESSION(obj)     (CAMEL_CHECK_CAST((obj), EM_MIGRATE_SESSION_TYPE, EMMigrateSession))
#define EM_MIGRATE_SESSION_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), EM_MIGRATE_SESSION_TYPE, EMMigrateSessionClass))
#define EM_MIGRATE_IS_SESSION(o)    (CAMEL_CHECK_TYPE((o), EM_MIGRATE_SESSION_TYPE))

typedef struct _EMMigrateSession {
    CamelSession parent_object;
    
    CamelStore *store;   /* new folder tree store */
    char *srcdir;        /* old folder tree path */
} EMMigrateSession;

typedef struct _EMMigrateSessionClass {
    CamelSessionClass parent_class;
    
} EMMigrateSessionClass;

static CamelType em_migrate_session_get_type (void);
static CamelSession *em_migrate_session_new (const char *path);

static void
class_init (EMMigrateSessionClass *klass)
{
    ;
}

static CamelType
em_migrate_session_get_type (void)
{
    static CamelType type = CAMEL_INVALID_TYPE;
    
    if (type == CAMEL_INVALID_TYPE) {
        type = camel_type_register (
            camel_session_get_type (),
            "EMMigrateSession",
            sizeof (EMMigrateSession),
            sizeof (EMMigrateSessionClass),
            (CamelObjectClassInitFunc) class_init,
            NULL,
            NULL,
            NULL);
    }
    
    return type;
}

static CamelSession *
em_migrate_session_new (const char *path)
{
    CamelSession *session;
    
    session = CAMEL_SESSION (camel_object_new (EM_MIGRATE_SESSION_TYPE));
    
    camel_session_construct (session, path);
    
    return session;
}


static GtkWidget *window;
static GtkLabel *label;
static GtkProgressBar *progress;

static void
em_migrate_setup_progress_dialog (void)
{
    GtkWidget *vbox, *hbox, *w;
    
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title ((GtkWindow *) window, _("Migrating..."));
    gtk_window_set_modal ((GtkWindow *) window, TRUE);
    gtk_container_set_border_width ((GtkContainer *) window, 6);
    
    vbox = gtk_vbox_new (FALSE, 6);
    gtk_widget_show (vbox);
    gtk_container_add ((GtkContainer *) window, vbox);
    
    w = gtk_label_new (_("The location and hierarchy of the Evolution mailbox "
                 "folders has changed since Evolution 1.x.\n\nPlease be "
                 "patient while Evolution migrates your folders..."));
    gtk_label_set_line_wrap ((GtkLabel *) w, TRUE);
    gtk_widget_show (w);
    gtk_box_pack_start_defaults ((GtkBox *) vbox, w);
    
    hbox = gtk_hbox_new (FALSE, 6);
    gtk_widget_show (hbox);
    gtk_box_pack_start_defaults ((GtkBox *) vbox, hbox);
    
    label = (GtkLabel *) gtk_label_new ("");
    gtk_widget_show ((GtkWidget *) label);
    gtk_box_pack_start_defaults ((GtkBox *) hbox, (GtkWidget *) label);
    
    progress = (GtkProgressBar *) gtk_progress_bar_new ();
    gtk_widget_show ((GtkWidget *) progress);
    gtk_box_pack_start_defaults ((GtkBox *) hbox, (GtkWidget *) progress);
    
    gtk_widget_show (window);
}

static void
em_migrate_close_progress_dialog (void)
{
    gtk_widget_destroy ((GtkWidget *) window);
}

static void
em_migrate_set_folder_name (const char *folder_name)
{
    char *text;
    
    text = g_strdup_printf (_("Migrating `%s':"), folder_name);
    gtk_label_set_text (label, text);
    g_free (text);
    
    gtk_progress_bar_set_fraction (progress, 0.0);
    
    while (gtk_events_pending ())
        gtk_main_iteration ();
}

static void
em_migrate_set_progress (double percent)
{
    char text[5];
    
    snprintf (text, sizeof (text), "%d%%", (int) (percent * 100.0f));
    
    gtk_progress_bar_set_fraction (progress, percent);
    gtk_progress_bar_set_text (progress, text);
    
    while (gtk_events_pending ())
        gtk_main_iteration ();
}


static gboolean
is_mail_folder (const char *metadata)
{
    xmlNodePtr node;
    xmlDocPtr doc;
    char *type;
    
    if (!(doc = xmlParseFile (metadata))) {
        g_warning ("Cannot parse `%s'", metadata);
        return FALSE;
    }
    
    if (!(node = xmlDocGetRootElement (doc))) {
        g_warning ("`%s' corrupt: document contains no root node", metadata);
        xmlFreeDoc (doc);
        return FALSE;
    }
    
    if (!node->name || strcmp (node->name, "efolder") != 0) {
        g_warning ("`%s' corrupt: root node is not 'efolder'", metadata);
        xmlFreeDoc (doc);
        return FALSE;
    }
    
    node = node->children;
    while (node != NULL) {
        if (node->name && !strcmp (node->name, "type")) {
            type = xmlNodeGetContent (node);
            if (!strcmp (type, "mail")) {
                xmlFreeDoc (doc);
                xmlFree (type);
                
                return TRUE;
            }
            
            xmlFree (type);
            
            break;
        }
        
        node = node->next;
    }
    
    xmlFreeDoc (doc);
    
    return FALSE;
}

static char *
get_local_store_uri (const char *dirname, const char *metadata, char **namep, int *index, CamelException *ex)
{
    char *protocol, *name, *buf;
    struct stat st;
    xmlNodePtr node;
    xmlDocPtr doc;
    
    if (stat (metadata, &st) == -1 || !S_ISREG (st.st_mode)) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, "`%s' is not a regular file", metadata);
        return NULL;
    }
    
    if (!(doc = xmlParseFile (metadata))) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, "cannot parse `%s'", metadata);
        return NULL;
    }
    
    if (!(node = xmlDocGetRootElement (doc)) || strcmp (node->name, "folderinfo") != 0) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, "`%s' is malformed", metadata);
        xmlFreeDoc (doc);
        return NULL;
    }
    
    node = node->children;
    while (node != NULL) {
        if (node->name && !strcmp (node->name, "folder")) {
            protocol = xmlGetProp (node, "type");
            name = xmlGetProp (node, "name");
            buf = xmlGetProp (node, "index");
            if (buf != NULL) {
                *index = atoi (buf);
                xmlFree (buf);
            } else {
                *index = 0;
            }
            
            xmlFreeDoc (doc);
            
            buf = g_strdup_printf ("%s:%s", protocol, dirname);
            xmlFree (protocol);
            
            *namep = g_strdup (name);
            xmlFree (name);
            
            return buf;
        }
        
        node = node->next;
    }
    
    xmlFreeDoc (doc);
    
    camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, "`%s' does not contain needed info", metadata);
    
    return NULL;
}

static int
cp (const char *src, const char *dest, gboolean show_progress)
{
    unsigned char readbuf[4096];
    ssize_t nread, nwritten;
    int errnosav, fd[2];
    size_t total = 0;
    struct stat st;
    
    if (stat (src, &st) == -1)
        return -1;
    
    if ((fd[0] = open (src, O_RDONLY)) == -1)
        return -1;
    
    if ((fd[1] = open (dest, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1) {
        errnosav = errno;
        close (fd[0]);
        errno = errnosav;
        return -1;
    }
    
    do {
        do {
            nread = read (fd[0], readbuf, sizeof (readbuf));
        } while (nread == -1 && errno == EINTR);
        
        if (nread == 0)
            break;
        else if (nread < 0)
            goto exception;
        
        do {
            nwritten = write (fd[1], readbuf, nread);
        } while (nwritten == -1 && errno == EINTR);
        
        if (nwritten < nread)
            goto exception;
        
        total += nwritten;
        
        if (show_progress)
            em_migrate_set_progress (((double) total) / ((double) st.st_size));
    } while (total < st.st_size);
    
    if (fsync (fd[1]) == -1)
        goto exception;
    
    close (fd[0]);
    close (fd[1]);
    
    return 0;
    
 exception:
    
    errnosav = errno;
    
    close (fd[0]);
    close (fd[1]);
    unlink (dest);
    
    errno = errnosav;
    
    return -1;
}

static GString *
mbox_build_filename (const char *toplevel_dir, const char *full_name)
{
    const char *start, *inptr = full_name;
    int subdirs = 0;
    GString *path;
    
    while (*inptr != '\0') {
        if (*inptr == '/')
            subdirs++;
        inptr++;
    }
    
    path = g_string_new (toplevel_dir);
    g_string_append_c (path, '/');
    
    inptr = full_name;
    while (*inptr != '\0') {
        start = inptr;
        while (*inptr != '/' && *inptr != '\0')
            inptr++;
        
        g_string_append_len (path, start, inptr - start);
        
        if (*inptr == '/') {
            g_string_append (path, ".sbd/");
            inptr++;
            
            /* strip extranaeous '/'s */
            while (*inptr == '/')
                inptr++;
        }
    }
    
    return path;
}

#define mbox_store_build_filename(s,n) mbox_build_filename (((CamelService *) s)->url->path, n)

static void
em_migrate_dir (EMMigrateSession *session, const char *dirname, const char *full_name)
{
    guint32 flags = CAMEL_STORE_FOLDER_CREATE;
    CamelFolder *old_folder, *new_folder;
    CamelStore *local_store;
    struct dirent *dent;
    CamelException ex;
    char *path, *name, *uri;
    GPtrArray *uids;
    struct stat st;
    int index, i;
    DIR *dir;
    
    path = g_strdup_printf ("%s/folder-metadata.xml", dirname);
    if (stat (path, &st) == -1 || !S_ISREG (st.st_mode)) {
        g_free (path);
        return;
    }
    
    if (!is_mail_folder (path)) {
        g_free (path);
        
        goto try_subdirs;
    }
    
    g_free (path);
    
    camel_exception_init (&ex);
    
    /* get old store & folder */
    path = g_strdup_printf ("%s/local-metadata.xml", dirname);
    if (!(uri = get_local_store_uri (dirname, path, &name, &index, &ex))) {
        g_warning ("error opening old store for `%s': %s", full_name, ex.desc);
        camel_exception_clear (&ex);
        g_free (path);
        
        /* try subfolders anyway? */
        goto try_subdirs;
    }
    
    g_free (path);
    
    em_migrate_set_folder_name (full_name);
    
    if (!strncmp (uri, "mbox:", 5)) {
        GString *src, *dest;
        size_t slen, dlen;
        char *p;
        
        src = g_string_new ("");
        g_string_append_printf (src, "%s/%s", uri + 5, name);
        g_free (name);
        
        dest = mbox_store_build_filename (session->store, full_name);
        p = strrchr (dest->str, '/');
        *p = '\0';
        
        slen = src->len;
        dlen = dest->len;
        
        if (camel_mkdir (dest->str, 0777) == -1 && errno != EEXIST) {
            g_string_free (dest, TRUE);
            g_string_free (src, TRUE);
            goto try_subdirs;
        }
        
        *p = '/';
        if (cp (src->str, dest->str, TRUE) == -1) {
            g_string_free (dest, TRUE);
            g_string_free (src, TRUE);
            goto try_subdirs;
        }
        
        g_string_append (src, ".ev-summary");
        g_string_append (dest, ".ev-summary");
        cp (src->str, dest->str, FALSE);
        
        if (index) {
            static char *ibex_ext[] = { ".ibex.index", ".ibex.index.data" };
            FILE *fp;
            int i;
            
            /* create a .cmeta file specifying to index the folder */
            g_string_truncate (dest, dlen);
            g_string_append (dest, ".cmeta");
            if ((fp = fopen (dest->str, "w+")) != NULL) {
                int fd = fileno (fp);
                
                /* write the magic string */
                if (fwrite ("CLMD", 4, 1, fp) != 1)
                    goto cmeta_err;
                
                /* write the version (1) */
                if (camel_file_util_encode_uint32 (fp, 1) == -1)
                    goto cmeta_err;
                
                /* write the meta count */
                if (camel_file_util_encode_uint32 (fp, 0) == -1)
                    goto cmeta_err;
                
                /* write the prop count (only prop is the index prop) */
                if (camel_file_util_encode_uint32 (fp, 1) == -1)
                    goto cmeta_err;
                
                /* write the index prop tag (== CAMEL_FOLDER_ARG_LAST|CAMEL_ARG_BOO) */
                if (camel_file_util_encode_uint32 (fp, CAMEL_FOLDER_ARG_LAST|CAMEL_ARG_BOO) == -1)
                    goto cmeta_err;
                
                /* write the index prop value */
                if (camel_file_util_encode_uint32 (fp, 1) == -1)
                    goto cmeta_err;
                
                fflush (fp);
                
                fd = fileno (fp);
                if (fsync (fd) == -1) {
                cmeta_err:
                    fclose (fp);
                    unlink (dest->str);
                } else {
                    fclose (fp);
                }
            }
            
            /* copy over the ibex files */
            for (i = 0; i < 2; i++) {
                g_string_truncate (src, slen);
                g_string_truncate (dest, dlen);
                
                g_string_append (src, ibex_ext[i]);
                g_string_append (dest, ibex_ext[i]);
                cp (src->str, dest->str, FALSE);
            }
        }
        
        g_string_free (dest, TRUE);
        g_string_free (src, TRUE);
    } else {
        if (!(local_store = camel_session_get_store ((CamelSession *) session, uri, &ex))) {
            g_warning ("error opening old store for `%s': %s", full_name, ex.desc);
            camel_exception_clear (&ex);
            g_free (name);
            g_free (uri);
            
            /* try subfolders anyway? */
            goto try_subdirs;
        }
        
        if (!(old_folder = camel_store_get_folder (local_store, name, 0, &ex))) {
            g_warning ("error opening old folder `%s': %s", full_name, ex.desc);
            camel_object_unref (local_store);
            camel_exception_clear (&ex);
            g_free (name);
            
            /* try subfolders anyway? */
            goto try_subdirs;
        }
        
        g_free (name);
        
        flags |= (index ? CAMEL_STORE_FOLDER_BODY_INDEX : 0);
        if (!(new_folder = camel_store_get_folder (session->store, full_name, flags, &ex))) {
            g_warning ("error creating new mbox folder `%s': %s", full_name, ex.desc);
            camel_object_unref (local_store);
            camel_object_unref (old_folder);
            camel_exception_clear (&ex);
            
            /* try subfolders anyway? */
            goto try_subdirs;
        }
        
        uids = camel_folder_get_uids (old_folder);
        for (i = 0; i < uids->len; i++) {
            CamelMimeMessage *message;
            CamelMessageInfo *info;
            
            if (!(info = camel_folder_get_message_info (old_folder, uids->pdata[i])))
                continue;
            
            if (!(message = camel_folder_get_message (old_folder, uids->pdata[i], &ex))) {
                camel_folder_free_message_info (old_folder, info);
                break;
            }
            
            camel_folder_append_message (new_folder, message, info, NULL, &ex);
            camel_folder_free_message_info (old_folder, info);
            camel_object_unref (message);
            
            if (camel_exception_is_set (&ex))
                break;
            
            em_migrate_set_progress (((double) i + 1) / ((double) uids->len));
        }
        
        camel_folder_free_uids (old_folder, uids);
        
        if (camel_exception_is_set (&ex)) {
            g_warning ("error migrating folder `%s': %s", full_name, ex.desc);
            camel_object_unref (local_store);
            camel_object_unref (old_folder);
            camel_object_unref (new_folder);
            camel_exception_clear (&ex);
            
            /* try subfolders anyway? */
            goto try_subdirs;
        }
        
        /*camel_object_unref (local_store);*/
        camel_object_unref (old_folder);
        camel_object_unref (new_folder);
    }
    
 try_subdirs:
    
    path = g_strdup_printf ("%s/subfolders", dirname);
    if (stat (path, &st) == -1 || !S_ISDIR (st.st_mode)) {
        g_free (path);
        return;
    }
    
    if (!(dir = opendir (path))) {
        g_warning ("cannot open `%s': %s", path, strerror (errno));
        g_free (path);
        return;
    }
    
    while ((dent = readdir (dir))) {
        char *full_path;
        
        if (dent->d_name[0] == '.')
            continue;
        
        full_path = g_strdup_printf ("%s/%s", path, dent->d_name);
        if (stat (full_path, &st) == -1 || !S_ISDIR (st.st_mode)) {
            g_free (full_path);
            continue;
        }
        
        name = g_strdup_printf ("%s/%s", full_name, dent->d_name);
        em_migrate_dir (session, full_path, name);
        g_free (full_path);
        g_free (name);
    }
    
    closedir (dir);
    
    g_free (path);
}

static void
em_migrate_local_folders (EMMigrateSession *session)
{
    struct dirent *dent;
    struct stat st;
    DIR *dir;
    
    if (!(dir = opendir (session->srcdir))) {
        g_warning ("cannot open `%s': %s", session->srcdir, strerror (errno));
        return;
    }
    
    em_migrate_setup_progress_dialog ();
    
    while ((dent = readdir (dir))) {
        char *full_path;
        
        if (dent->d_name[0] == '.')
            continue;
        
        full_path = g_strdup_printf ("%s/%s", session->srcdir, dent->d_name);
        if (stat (full_path, &st) == -1 || !S_ISDIR (st.st_mode)) {
            g_free (full_path);
            continue;
        }
        
        em_migrate_dir (session, full_path, dent->d_name);
        g_free (full_path);
    }
    
    closedir (dir);
    
    em_migrate_close_progress_dialog ();
}


static xmlNodePtr
xml_find_node (xmlNodePtr parent, const char *name)
{
    xmlNodePtr node;
    
    node = parent->children;
    while (node != NULL) {
        if (node->name && !strcmp (node->name, name))
            return node;
        
        node = node->next;
    }
    
    return NULL;
}

static char *
em_migrate_uri (const char *uri)
{
    char *path, *prefix, *p;
    CamelURL *url;
    
    if (!strncmp (uri, "file:", 5)) {
        url = camel_url_new (uri, NULL);
        camel_url_set_protocol (url, "email");
        camel_url_set_user (url, "local");
        camel_url_set_host (url, "local");
        
        prefix = g_build_filename (g_get_home_dir (), "evolution", "local", NULL);
        g_assert (strncmp (url->path, prefix, strlen (prefix)) == 0);
        path = g_strdup (url->path + strlen (prefix));
        g_free (prefix);
        
        /* modify the path in-place */
        p = path + strlen (path) - 12;
        while (p > path) {
            if (!strncmp (p, "/subfolders/", 12))
                memmove (p, p + 11, strlen (p + 11) + 1);
            
            p--;
        }
        
        camel_url_set_path (url, path);
        g_free (path);
        
        path = camel_url_to_string (url, 0);
        camel_url_free (url);
        
        return path;
    } else {
        return em_uri_from_camel (uri);
    }
}

static int
em_migrate_filter_file (const char *evolution_dir, const char *filename, CamelException *ex)
{
    char *path, *uri, *new;
    xmlNodePtr node;
    xmlDocPtr doc;
    int retval;
    
    path = g_build_filename (g_get_home_dir (), "evolution", filename, NULL);
    
    if (!(doc = xmlParseFile (path))) {
        /* can't parse - this means nothing to upgrade */
        g_free (path);
        return 0;
    }
    
    g_free (path);
    
    if (!(node = xmlDocGetRootElement (doc))) {
        /* document contains no root node - nothing to upgrade */
        xmlFreeDoc (doc);
        return 0;
    }
    
    if (!node->name || strcmp (node->name, "filteroptions") != 0) {
        /* root node is not <filteroptions>, nothing to upgrade */
        xmlFreeDoc (doc);
        return 0;
    }
    
    if (!(node = xml_find_node (node, "ruleset"))) {
        /* no ruleset node, nothing to upgrade */
        xmlFreeDoc (doc);
        return 0;
    }
    
    node = node->children;
    while (node != NULL) {
        if (node->name && !strcmp (node->name, "rule")) {
            xmlNodePtr actionset, part, val, n;
            
            if ((actionset = xml_find_node (node, "actionset"))) {
                /* filters.xml */
                part = actionset->children;
                while (part != NULL) {
                    if (part->name && !strcmp (part->name, "part")) {
                        val = part->children;
                        while (val != NULL) {
                            if (val->name && !strcmp (val->name, "value")) {
                                char *type;
                                
                                type = xmlGetProp (val, "type");
                                if (type && !strcmp (type, "folder")) {
                                    if ((n = xml_find_node (val, "folder"))) {
                                        uri = xmlGetProp (n, "uri");
                                        new = em_migrate_uri (uri);
                                        xmlFree (uri);
                                        
                                        xmlSetProp (n, "uri", new);
                                        g_free (new);
                                    }
                                }
                                
                                xmlFree (type);
                            }
                            
                            val = val->next;
                        }
                    }
                    
                    part = part->next;
                }
            } else if ((actionset = xml_find_node (node, "sources"))) {
                /* vfolders.xml */
                n = actionset->children;
                while (n != NULL) {
                    if (n->name && !strcmp (n->name, "folder")) {
                        uri = xmlGetProp (n, "uri");
                        new = em_uri_from_camel (uri);
                        xmlFree (uri);
                        
                        xmlSetProp (n, "uri", new);
                        g_free (new);
                    }
                    
                    n = n->next;
                }
            }
        }
        
        node = node->next;
    }
    
    path = g_build_filename (evolution_dir, "mail", filename, NULL);
    if ((retval = e_xml_save_file (path, doc)) == -1) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      _("Failed to migrate `%s': %s"),
                      filename, g_strerror (errno));
    }
    
    g_free (path);
    
    xmlFreeDoc (doc);
    
    return retval;
}

static int
em_migrate_pop_uid_caches (const char *evolution_dir, CamelException *ex)
{
    GString *oldpath, *newpath;
    struct dirent *dent;
    size_t olen, nlen;
    char *cache_dir;
    DIR *dir;
    
    /* open the old cache dir */
    cache_dir = g_build_filename (g_get_home_dir (), "evolution", "mail", "pop3", NULL);
    if (!(dir = opendir (cache_dir))) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      _("Failed to migrate pop3 uid caches: %s"),
                      g_strerror (errno));
        g_warning ("cannot open `%s': %s", cache_dir, strerror (errno));
        g_free (cache_dir);
        return -1;
    }
    
    oldpath = g_string_new (cache_dir);
    g_string_append_c (oldpath, '/');
    olen = oldpath->len;
    g_free (cache_dir);
    
    cache_dir = g_build_filename (evolution_dir, "mail", "pop", NULL);
    if (camel_mkdir (cache_dir, 0777) == -1) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      _("Failed to migrate pop3 uid caches: %s"),
                      g_strerror (errno));
        g_warning ("cannot create `%s': %s", cache_dir, strerror (errno));
        g_string_free (oldpath, TRUE);
        g_free (cache_dir);
        closedir (dir);
        return -1;
    }
    
    newpath = g_string_new (cache_dir);
    g_string_append_c (newpath, '/');
    nlen = newpath->len;
    g_free (cache_dir);
    
    while ((dent = readdir (dir))) {
        if (strncmp (dent->d_name, "cache-pop:__", 12) != 0)
            continue;
        
        g_string_truncate (oldpath, olen);
        g_string_truncate (newpath, nlen);
        
        g_string_append (oldpath, dent->d_name);
        g_string_append (newpath, dent->d_name + 12);
        
        /* strip the trailing '_' */
        g_string_truncate (newpath, newpath->len - 1);
        
        if (camel_mkdir (newpath->str, 0777) == -1) {
            g_warning ("cannot create `%s': %s", newpath->str, strerror (errno));
            continue;
        }
        
        g_string_append (newpath, "/uid-cache");
        cp (oldpath->str, newpath->str, FALSE);
    }
    
    g_string_free (oldpath, TRUE);
    g_string_free (newpath, TRUE);
    
    closedir (dir);
    
    return 0;
}


int
em_migrate (MailComponent *component, CamelException *ex)
{
    const char *evolution_dir;
    EMMigrateSession *session;
    CamelException lex;
    struct stat st;
    char *path;
    
    evolution_dir = mail_component_peek_base_directory (component);
    path = g_strdup_printf ("%s/mail", evolution_dir);
    if (stat (path, &st) == -1) {
        if (errno != ENOENT || camel_mkdir (path, 0777) == -1) {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, 
                          _("Failed to create directory `%s': %s"),
                          path, g_strerror (errno));
            g_free (path);
            return -1;
        }
    }
    
    camel_init (path, TRUE);
    session = (EMMigrateSession *) em_migrate_session_new (path);
    g_free (path);
    
    session->srcdir = g_strdup_printf ("%s/evolution/local", g_get_home_dir ());
    
    path = g_strdup_printf ("mbox:%s/.evolution/mail/local", g_get_home_dir ());
    if (stat (path + 5, &st) == -1) {
        if (errno != ENOENT || camel_mkdir (path + 5, 0777) == -1) {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                          _("Failed to create directory `%s': %s"),
                          path + 5, g_strerror (errno));
            g_free (session->srcdir);
            camel_object_unref (session);
            g_free (path);
            return -1;
        }
    }
    
    camel_exception_init (&lex);
    if (!(session->store = camel_session_get_store ((CamelSession *) session, path, &lex))) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      _("Failed to open store for `%s': %s"),
                      path, lex.desc);
        g_free (session->srcdir);
        camel_object_unref (session);
        camel_exception_clear (&lex);
        g_free (path);
        return -1;
    }
    g_free (path);
    
    em_migrate_local_folders (session);
    
    camel_object_unref (session->store);
    g_free (session->srcdir);
    
    camel_object_unref (session);
    
    if (em_migrate_filter_file (evolution_dir, "filters.xml", ex) == -1)
        return -1;
    
    if (em_migrate_filter_file (evolution_dir, "vfolders.xml", ex) == -1)
        return -1;
    
    if (em_migrate_pop_uid_caches (evolution_dir, ex) == -1)
        return -1;
    
    return 0;
}