path: root/mail/importers/evolution-mbox-importer.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Iain Holmes <iain@ximian.com>
 *      Michael Zucchi <notzed@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

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

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>

#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>

#include "shell/e-shell.h"
#include "shell/e-shell-window.h"
#include "shell/e-shell-view.h"
#include "shell/e-shell-sidebar.h"

#include "libemail-engine/mail-mt.h"

#include "mail/e-mail-backend.h"
#include "mail/em-folder-selection-button.h"
#include "mail/em-folder-tree-model.h"
#include "mail/em-folder-tree.h"

#include "mail-importer.h"

typedef struct {
    EImport *import;
    EImportTarget *target;

    GMutex status_lock;
    gchar *status_what;
    gint status_pc;
    gint status_timeout_id;
    GCancellable *cancellable;  /* cancel/status port */

    gchar *uri;
} MboxImporter;

static void
folder_selected (EMFolderSelectionButton *button,
                 EImportTargetURI *target)
{
    g_free (target->uri_dest);
    target->uri_dest = g_strdup (em_folder_selection_button_get_folder_uri (button));
}

static GtkWidget *
mbox_getwidget (EImport *ei,
                EImportTarget *target,
                EImportImporter *im)
{
    EShell *shell;
    EShellBackend *shell_backend;
    EMailBackend *backend;
    EMailSession *session;
    GtkWindow *window;
    GtkWidget *hbox, *w;
    GtkLabel *label;
    gchar *select_uri = NULL;

    /* XXX Dig up the mail backend from the default EShell.
     *     Since the EImport framework doesn't allow for user
     *     data, I don't see how else to get to it. */
    shell = e_shell_get_default ();
    shell_backend = e_shell_get_backend_by_name (shell, "mail");

    backend = E_MAIL_BACKEND (shell_backend);
    session = e_mail_backend_get_session (backend);

    /* preselect the folder selected in a mail view */
    window = e_shell_get_active_window (shell);
    if (E_IS_SHELL_WINDOW (window)) {
        EShellWindow *shell_window;
        const gchar *view;

        shell_window = E_SHELL_WINDOW (window);
        view = e_shell_window_get_active_view (shell_window);

        if (view && g_str_equal (view, "mail")) {
            EShellView *shell_view;
            EShellSidebar *shell_sidebar;
            EMFolderTree *folder_tree = NULL;

            shell_view = e_shell_window_get_shell_view (
                shell_window, view);

            shell_sidebar =
                e_shell_view_get_shell_sidebar (shell_view);

            g_object_get (
                shell_sidebar, "folder-tree",
                &folder_tree, NULL);

            select_uri =
                em_folder_tree_get_selected_uri (folder_tree);

            g_object_unref (folder_tree);
        }
    }

    if (!select_uri) {
        const gchar *uri;
        uri = e_mail_session_get_local_folder_uri (
            session, E_MAIL_LOCAL_FOLDER_INBOX);
        select_uri = g_strdup (uri);
    }

    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

    w = gtk_label_new_with_mnemonic (_("_Destination folder:"));
    gtk_box_pack_start ((GtkBox *) hbox, w, FALSE, TRUE, 6);

    label = GTK_LABEL (w);

    w = em_folder_selection_button_new (
        session, _("Select folder"),
        _("Select folder to import into"));
    gtk_label_set_mnemonic_widget (label, w);
    em_folder_selection_button_set_folder_uri (
        EM_FOLDER_SELECTION_BUTTON (w), select_uri);
    folder_selected (
        EM_FOLDER_SELECTION_BUTTON (w), (EImportTargetURI *) target);
    g_signal_connect (
        w, "selected",
        G_CALLBACK (folder_selected), target);
    gtk_box_pack_start ((GtkBox *) hbox, w, FALSE, TRUE, 6);

    w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_pack_start ((GtkBox *) w, hbox, FALSE, FALSE, 0);
    gtk_widget_show_all (w);

    g_free (select_uri);

    return w;
}

static gboolean
mbox_supported (EImport *ei,
                EImportTarget *target,
                EImportImporter *im)
{
    gchar signature[6];
    gboolean ret = FALSE;
    gint fd, n;
    EImportTargetURI *s;
    gchar *filename;

    if (target->type != E_IMPORT_TARGET_URI)
        return FALSE;

    s = (EImportTargetURI *) target;
    if (s->uri_src == NULL)
        return TRUE;

    if (strncmp (s->uri_src, "file:///", strlen ("file:///")) != 0)
        return FALSE;

    filename = g_filename_from_uri (s->uri_src, NULL, NULL);
    fd = g_open (filename, O_RDONLY, 0);
    g_free (filename);
    if (fd != -1) {
        n = read (fd, signature, 5);
        ret = n == 5 && memcmp (signature, "From ", 5) == 0;
        close (fd);
    }

    return ret;
}

static void
mbox_status (CamelOperation *op,
             const gchar *what,
             gint pc,
             gpointer data)
{
    MboxImporter *importer = data;

    g_mutex_lock (&importer->status_lock);
    g_free (importer->status_what);
    importer->status_what = g_strdup (what);
    importer->status_pc = pc;
    g_mutex_unlock (&importer->status_lock);
}

static gboolean
mbox_status_timeout (gpointer data)
{
    MboxImporter *importer = data;
    gint pc;
    gchar *what;

    if (importer->status_what) {
        g_mutex_lock (&importer->status_lock);
        what = importer->status_what;
        importer->status_what = NULL;
        pc = importer->status_pc;
        g_mutex_unlock (&importer->status_lock);

        e_import_status (
            importer->import, (EImportTarget *)
            importer->target, what, pc);
    }

    return TRUE;
}

static void
mbox_import_done (gpointer data,
                  GError **error)
{
    MboxImporter *importer = data;

    g_source_remove (importer->status_timeout_id);
    g_free (importer->status_what);
    g_mutex_clear (&importer->status_lock);
    g_object_unref (importer->cancellable);

    e_import_complete (importer->import, importer->target);
    g_free (importer);
}

static void
mbox_import (EImport *ei,
             EImportTarget *target,
             EImportImporter *im)
{
    EShell *shell;
    EShellBackend *shell_backend;
    EMailSession *session;
    MboxImporter *importer;
    gchar *filename;

    /* XXX Dig up the EMailSession from the default EShell.
     *     Since the EImport framework doesn't allow for user
     *     data, I don't see how else to get to it. */
    shell = e_shell_get_default ();
    shell_backend = e_shell_get_backend_by_name (shell, "mail");
    session = e_mail_backend_get_session (E_MAIL_BACKEND (shell_backend));

    /* TODO: do we validate target? */

    importer = g_malloc0 (sizeof (*importer));
    g_datalist_set_data (&target->data, "mbox-data", importer);
    importer->import = ei;
    importer->target = target;
    g_mutex_init (&importer->status_lock);
    importer->status_timeout_id = g_timeout_add (100, mbox_status_timeout, importer);
    importer->cancellable = camel_operation_new ();

    g_signal_connect (
        importer->cancellable, "status",
        G_CALLBACK (mbox_status), importer);

    filename = g_filename_from_uri (
        ((EImportTargetURI *) target)->uri_src, NULL, NULL);
    mail_importer_import_mbox (
        session, filename, ((EImportTargetURI *) target)->uri_dest,
        importer->cancellable, mbox_import_done, importer);
    g_free (filename);
}

static void
mbox_cancel (EImport *ei,
             EImportTarget *target,
             EImportImporter *im)
{
    MboxImporter *importer = g_datalist_get_data (&target->data, "mbox-data");

    if (importer)
        g_cancellable_cancel (importer->cancellable);
}

static MboxImporterCreatePreviewFunc create_preview_func = NULL;
static MboxImporterFillPreviewFunc fill_preview_func = NULL;

void
mbox_importer_set_preview_funcs (MboxImporterCreatePreviewFunc create_func,
                                 MboxImporterFillPreviewFunc fill_func)
{
    create_preview_func = create_func;
    fill_preview_func = fill_func;
}

static void
preview_selection_changed_cb (GtkTreeSelection *selection,
                              EWebViewPreview *preview)
{
    GtkTreeIter iter;
    GtkTreeModel *model = NULL;
    gboolean found = FALSE;

    g_return_if_fail (selection != NULL);
    g_return_if_fail (preview != NULL);
    g_return_if_fail (fill_preview_func != NULL);

    if (gtk_tree_selection_get_selected (selection, &model, &iter) && model) {
        CamelMimeMessage *msg = NULL;

        gtk_tree_model_get (model, &iter, 2, &msg, -1);

        if (msg) {
            found = TRUE;
            fill_preview_func (G_OBJECT (preview), msg);
            g_object_unref (msg);
        }
    }

    if (!found) {
        e_web_view_preview_begin_update (preview);
        e_web_view_preview_end_update (preview);
    }
}

static GtkWidget *
mbox_get_preview (EImport *ei,
                  EImportTarget *target,
                  EImportImporter *im)
{
    GtkWidget *preview = NULL;
    EImportTargetURI *s = (EImportTargetURI *) target;
    gchar *filename;
    gint fd;
    CamelMimeParser *mp;
    GtkListStore *store = NULL;
    GtkTreeIter iter;
    GtkWidget *preview_widget = NULL;

    if (!create_preview_func || !fill_preview_func)
        return NULL;

    filename = g_filename_from_uri (s->uri_src, NULL, NULL);
    if (!filename) {
        g_message (G_STRLOC ": Couldn't get filename from URI '%s'", s->uri_src);
        return NULL;
    }

    fd = g_open (filename, O_RDONLY | O_BINARY, 0);
    if (fd == -1) {
        g_warning (
            "Cannot find source file to import '%s': %s",
            filename, g_strerror (errno));
        g_free (filename);
        return NULL;
    }

    g_free (filename);

    mp = camel_mime_parser_new ();
    camel_mime_parser_scan_from (mp, TRUE);
    if (camel_mime_parser_init_with_fd (mp, fd) == -1) {
        g_object_unref (mp);
        return NULL;
    }

    while (camel_mime_parser_step (mp, NULL, NULL) == CAMEL_MIME_PARSER_STATE_FROM) {
        CamelMimeMessage *msg;
        gchar *from;

        msg = camel_mime_message_new ();
        if (!camel_mime_part_construct_from_parser_sync (
            (CamelMimePart *) msg, mp, NULL, NULL)) {
            g_object_unref (msg);
            break;
        }

        if (!store)
            store = gtk_list_store_new (
                3, G_TYPE_STRING, G_TYPE_STRING,
                CAMEL_TYPE_MIME_MESSAGE);

        from = NULL;
        if (camel_mime_message_get_from (msg))
            from = camel_address_encode (
                CAMEL_ADDRESS (
                camel_mime_message_get_from (msg)));

        gtk_list_store_append (store, &iter);
        gtk_list_store_set (
            store, &iter,
            0, camel_mime_message_get_subject (msg) ?
            camel_mime_message_get_subject (msg) : "",
            1, from ? from : "", 2, msg, -1);

        g_object_unref (msg);
        g_free (from);

        camel_mime_parser_step (mp, NULL, NULL);
    }

    if (store) {
        GtkTreeView *tree_view;
        GtkTreeSelection *selection;
        gboolean valid;

        preview = e_web_view_preview_new ();
        gtk_widget_show (preview);

        tree_view = e_web_view_preview_get_tree_view (
            E_WEB_VIEW_PREVIEW (preview));
        g_return_val_if_fail (tree_view != NULL, NULL);

        gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (store));
        g_object_unref (store);

        /* Translators: Column header for a message subject */
        gtk_tree_view_insert_column_with_attributes (
            tree_view, -1, C_("mboxImp", "Subject"),
            gtk_cell_renderer_text_new (), "text", 0, NULL);

        /* Translators: Column header for a message From address */
        gtk_tree_view_insert_column_with_attributes (
            tree_view, -1, C_("mboxImp", "From"),
            gtk_cell_renderer_text_new (), "text", 1, NULL);

        if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) > 1)
            e_web_view_preview_show_tree_view (
                E_WEB_VIEW_PREVIEW (preview));

        create_preview_func (G_OBJECT (preview), &preview_widget);
        g_return_val_if_fail (preview_widget != NULL, NULL);

        e_web_view_preview_set_preview (
            E_WEB_VIEW_PREVIEW (preview), preview_widget);
        gtk_widget_show (preview_widget);

        selection = gtk_tree_view_get_selection (tree_view);
        valid = gtk_tree_model_get_iter_first (
            GTK_TREE_MODEL (store), &iter);
        g_return_val_if_fail (valid, NULL);
        gtk_tree_selection_select_iter (selection, &iter);

        g_signal_connect (
            selection, "changed",
            G_CALLBACK (preview_selection_changed_cb), preview);

        preview_selection_changed_cb (
            selection, E_WEB_VIEW_PREVIEW (preview));
    }

    return preview;
}

static EImportImporter mbox_importer = {
    E_IMPORT_TARGET_URI,
    0,
    mbox_supported,
    mbox_getwidget,
    mbox_import,
    mbox_cancel,
    mbox_get_preview,
};

EImportImporter *
mbox_importer_peek (void)
{
    mbox_importer.name = _("Berkeley Mailbox (mbox)");
    mbox_importer.description = _("Importer Berkeley Mailbox format folders");

    return &mbox_importer;
}