trunk/Src/wptFileManager.cpp

/* wptFileManager.cpp - File Manager routines
 *      Copyright (C) 2001-2007, 2009 Timo Schulz
 *      Copyright (C) 2005 g10 Code GmbH
 *
 * This file is part of WinPT.
 *
 * WinPT 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.
 *  
 * WinPT 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.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <sys/types.h>
#include <windows.h>
#include <commdlg.h>
#include <io.h>
#include <stdio.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptGPG.h"
#include "wptAgent.h"
#include "wptCommonCtl.h"
#include "wptContext.h"
#include "wptErrors.h"
#include "wptKeylist.h"
#include "wptFileManager.h"
#include "wptNLS.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptDlgs.h"
#include "wptUTF8.h"
#include "wptRegistry.h"
#include "wptImport.h"
#include "wptCrypto.h"
#include "wptKeyManager.h"
#include "wptKeyserver.h"
#include "openpgp.h"


void progress_cleanup (progress_filter_s *pfx);
gpgme_error_t sym_passphrase_cb (void *hook, const char *hint, const char *pass_inf,
                                 int prev_was_bad, int fd);
void verify_show_signature_state (gpgme_signature_t sig);


/* Add a new file to the model @fm. */
static void
fm_model_add_file (fm_model_t *fm, fm_model_t file)
{
    fm_model_t m;

    if (!*fm) {
        *fm = file;
        return;
    }
    for (m = *fm; m->next; m = m->next)
        ;
    m->next = file;
}


/* Search for a file model based on the name @name. 
static fm_model_t
fm_model_find_file (fm_model_t fm, const char *name)
{
    fm_model_t m;

    for (m=fm; m; m=m->next) {
        if (!stricmp (m->name, name))
            return m;
    }
    return NULL;
}
*/

/* Check if the drive given by @fname is a floppy disc.
   Return value: -1 for success. */
static int
is_floppy_disc (const char *fname)
{
    char drv[32] = {0};    
    int max = DIM (drv)-1;
    int i=0;

    if (!strstr (fname, ":\\"))
        return 0;

    while (fname && *fname && *fname != '\\' && i < max)
        drv[i++] = *fname++;
    drv[i++] = '\\';
    drv[i++] = '\0';
    i = GetDriveType (drv);
    if (i == DRIVE_REMOVABLE)
        return -1;
    return 0;
}


/* Ask the user to overwrite file @fname.
   Return value: 0 for cancel. */
static int
overwrite_file (const char *fname)
{
    int id;

    if (file_exist_check (fname))
        return -1;
    id = log_box (_("File Manager"), MB_YESNO,
                  _("\"%s\" already exists.\n"
                    "Replace existing file?"), fname);
    return id == IDNO ? 0 : -1;
}


/* Removes 'critical' attributes from the file @fname.
   If @force is 1, the user is not asked for permission. */
void
remove_crit_file_attrs (const char *fname, int force)
{
    DWORD fattr;
    int id = 0;

    if (file_exist_check (fname))
        return; /* file does not exist */
        
    fattr = GetFileAttributes (fname);
    if ((fattr & FILE_ATTRIBUTE_READONLY) && force)
        id = IDYES;
    else if (fattr & FILE_ATTRIBUTE_READONLY)
        id = log_box (_("File Manager"), MB_YESNO,          
                      _("\"%s\" has read-only attribute.\n"
                        "Set attribute to normal?"), fname);
    if (id == IDYES) {
        if (!SetFileAttributes (fname, FILE_ATTRIBUTE_NORMAL))
            msg_box (NULL, _("Could not reset file attribute to normal."),
                     _("File Manager"), MB_ERR);
    }
}


/* Return 1 if the given path @fname is a directory, 0 otherwise. */
static int
is_directory (const char *fname)
{
    return GetFileAttributes (fname) & FILE_ATTRIBUTE_DIRECTORY? 1 : 0;
}


/* Return -1 if the given name @name is a valid GPG extension. */
int
is_openpgp_ext (const char *name)
{
    if (stristr (name, ".gpg") || 
        stristr (name, ".asc") ||
        stristr (name, ".sig") ||
        stristr (name, ".pgp"))
        return -1;
    return 0;
}


/* Return a GPG file extension which depends on the operation
   mode in @ctx and the sig mode @sigmode. */
const char*
file_get_extension (gpgme_ctx_t ctx, gpgme_sig_mode_t sigmode)
{
    int use_armor = gpgme_get_armor (ctx);

    if (use_armor || sigmode == GPGME_SIG_MODE_CLEAR)
        return ".asc";
    if (!use_armor && sigmode == GPGME_SIG_MODE_DETACH)
        return ".sig";
    return reg_prefs.default_ext == 1? ".pgp" : ".gpg";
}


/* Quote a file to avoid shell problems with spaces in the files. */
char*
fm_quote_file (const char * name)
{
    char *p;
    size_t len = strlen (name) + 8;

    if (*name == '"')
        return m_strdup (name); /* avoid double quotes */
    p = new char[len + 1];
    if (!p)
        BUG (0);
    _snprintf (p, len, "\"%s\"", name);

    return p;
}


/* Check the armor type of the file @fname and return
   a string representation of it. */
static const char*
fm_check_armor_type (const char *fname, int *r_type)
{
    FILE *fp;
    char header[512], *p;
    
    if (r_type)
        *r_type = PGP_NONE;
    fp = fopen (fname, "rb");
    if (!fp)
        return "UNKNOWN";
    p = fgets (header, DIM (header) - 1, fp);
    fclose (fp);
    if (!p)
        return "UNKNOWN";

    if (strncmp (header, "-----", 5))
        goto leave;
    if (strstr (header, "BEGIN PGP PUBLIC KEY" )) {
        if (r_type) *r_type = PGP_PUBKEY;
        return "PUBKEY";
    }
    else if (strstr (header, "BEGIN PGP PRIVATE KEY") || 
             strstr (header, "BEGIN PGP SECRET KEY")) {
        if (r_type) *r_type = PGP_SECKEY;
        return "SECKEY";
    }
    else if (strstr (header, "BEGIN PGP MESSAGE")) {
        if (r_type) *r_type = PGP_MESSAGE;
        return "ENCRYPTED";
    }
    else if (strstr( header, "BEGIN PGP SIGNED MESSAGE")) {
        if (r_type) *r_type = PGP_CLEARSIG;
        return "SIGNED-CLEAR";
    }
    else if (strstr(header, "BEGIN PGP SIGNATURE")) {
        if (r_type) *r_type = PGP_SIG;
        return "SIGNED-DETACH";
    }

leave:
    return "UNKNOWN";
}


/* Extract file type from @fname. If @r_type is valid,
   it contains the PGP type on success. */
static const char*
fm_get_file_type (const char *fname, int *r_type)
{        
    gpg_iobuf_t inp;
    armor_filter_context_t afx;
    PACKET *pkt;
    const char *s = NULL;
    size_t count = 0, compr = 0;
    int rc = 0;

    if (r_type)
        *r_type = PGP_NONE;
    if (!fname) {
        log_debug ("fm_get_file_type: !fname\r\n");
        return NULL;
    }

    /* to avoid lengthy operations on floppy disks, we use a quick check. */
    if (is_floppy_disc (fname)) 
        return fm_check_armor_type (fname, r_type);

    inp = gpg_iobuf_open (fname);
    if (!inp) {
        const char *err = winpt_strerror (WPTERR_FILE_OPEN);
        log_box (_("File Manager"), MB_ERR, "\"%s\": %s", fname, err);
        return NULL;
    }
    gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */
    if (gpg_iobuf_get_filelength (inp) > 32000000 /* 32MB */
        && !is_openpgp_ext (fname)) {
        gpg_iobuf_close (inp);
        return "UNKNOWN";
    }

    if (gpg_use_armor_filter(inp)) {
        memset (&afx, 0, sizeof (afx));
        gpg_iobuf_push_filter (inp, gpg_armor_filter, &afx);
    }
    pkt = (PACKET *)calloc (1, sizeof *pkt);
    if (!pkt)
        BUG (NULL);
    gpg_init_packet (pkt);
    /* XXX: for larger files, we could just look for the first ~3 packets
            and stop if we found a packet which were sufficient to idenitfy
            the file contents. */
    while (!(rc = gpg_parse_packet (inp, pkt))) {
        switch (pkt->pkttype) {
        case PKT_PUBKEY_ENC:
            s = "ENCRYPTED";rc = -2; 
            if (r_type) *r_type = PGP_MESSAGE;
            break;

        case PKT_SYMKEY_ENC:
        case PKT_ENCRYPTED:
            s = "SYMKEYENC";rc = -2; 
            if (r_type) *r_type = PGP_MESSAGE;
            break;

        case PKT_SIGNATURE:
        case PKT_ONEPASS_SIG:
            s = "SIGNED";   rc = -2; 
            if (r_type) *r_type = PGP_SIG;
            break;

        case PKT_PUBLIC_KEY:
            s = "PUBKEY";   rc = -2; 
            if (r_type) *r_type = PGP_PUBKEY;
            break;

        case PKT_SECRET_KEY:
            s = "SECKEY";   rc = -2;
            if (r_type) *r_type = PGP_SECKEY;
            break;

        case PKT_COMPRESSED:
            /* If we only find 1 packet and it is compressed,
               we assume a compressed one-pass signature. */
            if (count != 0)
                break;
            s = "SIGNED"; rc = -2;
            compr = 1;
            break;

        default:
            break;
        }
        count++;
        gpg_free_packet (pkt);
        gpg_init_packet (pkt);
        if (rc == -2)
            break; /* found */
    }
    safe_free (pkt);
    gpg_iobuf_close (inp);
    if (!s)
        s = fm_check_armor_type (fname, r_type);
    if (!s)
        s = "UNKNOWN";
    if (!strcmp (s, "SIGNED") && !compr
        && strcmp (fm_check_armor_type (fname, r_type), "SIGNED-CLEAR")) {
        if (r_type) *r_type = PGP_SIG;
        s = "SIGNED-DETACH";
    }
    return s;
}


/* Build the File Manager dialog context. */
void
fm_build (fm_info_t *r_fm, HWND ctrl)
{    
    fm_info_t fm;
    struct listview_column_s col[] = {
        {0,  80, (char *)_("Status") },
        {1, 256, (char *)_("Name") },
        {2, 128, (char *)_("Operation") },
        {0,   0, NULL}  
    };

    fm = new fm_info_s;
    memset (fm, 0, sizeof *fm);
    listview_new (&fm->lv, ctrl);
    for (int i = 0; col[i].width; i++)
        listview_add_column (fm->lv, &col[i]);
    listview_set_ext_style (fm->lv);
    fm->model = NULL; /*init*/
    *r_fm = fm;
}


/* Release the file model in @mod. */
static void
fm_model_release (fm_model_t mod)
{
    fm_model_t m;

    while (mod) {
        m = mod->next;
        free_if_alloc (mod->name);
        free_if_alloc (mod->op);
        free_if_alloc (mod->status);
        free_if_alloc (mod);
        mod = m;
    }
}


/* Reset the File Manager info context @fm. */
void
fm_reset (fm_info_t fm)
{
    listview_del_all_items (fm->lv);
    fm_model_release (fm->model);
    fm->model = NULL;
}


/* Release the File Manager dialog context @fm. */
void
fm_delete (fm_info_t fm)
{
    if (!fm)
        return;
    if (fm->menu)
        DestroyMenu (fm->menu);
    listview_release (fm->lv);
    fm_model_release (fm->model);
    free_if_alloc (fm);   
}


int
fm_state_new (fm_state_t * ctx)
{
    fm_state_s *c;

    c = new fm_state_s;
    if (!c)
        BUG (0);
    memset (c, 0, sizeof *c);
    if (gpgme_new (&c->ctx))
        BUG (0);
    *ctx = c;
    return 0;
}


/* Release the FM state handle @c. */
void
fm_state_release (fm_state_t c)
{
    if (!c)
        return;
    if (c->ctx) {
        gpgme_release (c->ctx);
        c->ctx = NULL;  
    }
    safe_free (c->recp);
    free_if_alloc (c->opaque);
    free_if_alloc (c->output);
    delete c;
}


/* Check if file @file is already in the list view. */
static int
fm_check_for_entry (listview_ctrl_t lv, const char *file)
{
    char name[MAX_PATH+128];

    memset (name, 0, sizeof (name));
    for (int i = 0; i < listview_count_items (lv, 0); i++) {
        listview_get_item_text (lv, i, FM_COL_NAME, name, DIM (name) - 1);
        if (!stricmp (name, file))
            return 1; /* found */       
    }

    return 0;
}


static int
fm_set_ftype (listview_ctrl_t lv, fm_model_t *fm, const char *name)
{
    fm_model_t m;
    const char *type;
    int rc;

    rc = fm_check_for_entry (lv, name);
    if (rc)
        return 0; /* already present. */
    m = new fm_model_s;
    memset (m, 0, sizeof *m);
    type = fm_get_file_type (name, NULL);
    if (!type || !strcmp (type, "UNKNOWN"))
        type = gnupg_check_file_ext (name, NULL);
    listview_add_item2 (lv, " ", (void*)m);
    listview_add_sub_item (lv, 0, FM_COL_STAT, type);
    listview_add_sub_item (lv, 0, FM_COL_NAME, name);
    m->name = m_strdup (name);
    m->status = m_strdup (type);
    m->op = NULL;
    fm_model_add_file (fm, m);
    return 0;
}


/* Add all files from the directory @path to the list view @lv. */
static int
fm_add_dir_files (listview_ctrl_t lv, fm_model_t *fm, char *path)
{
    WIN32_FIND_DATA fd;
    HANDLE hd;
    char *p;

    strcat (path, "\\*");
    hd = FindFirstFile (path, &fd);
    if (hd == INVALID_HANDLE_VALUE)
        return -1;
    do {
        if (fd.cFileName[0] == '.' && strlen (fd.cFileName) < 3)
            continue;
        p = new char [strlen (path) + strlen (fd.cFileName)+1];
        if (!p)
            BUG (0);
        memcpy (p, path, strlen (path)-1);
        p[strlen (path)-1] = 0;
        strcat (p, fd.cFileName);
        if (!is_directory (p))
            fm_set_ftype (lv, fm, p);
        free_if_alloc (p);
    } while (FindNextFile (hd, &fd));
    FindClose (hd);
    return 0;
}


/* Add the drag & drop files from @dd_files to the 
   list view control @lv. */
int
fm_add_dropped_files (fm_info_t fm, HDROP dd_files)
{
    char name[MAX_PATH+32+4];
    int rc = 0;
    UINT i;

    for (i = 0;  i < DragQueryFile (dd_files, 0xFFFFFFFF, NULL, 0); i++) {
        memset (name, 0, sizeof (name));
        DragQueryFile (dd_files, i, name, DIM (name) -1);
        if (is_directory (name))
            rc = fm_add_dir_files (fm->lv, &fm->model, name);
        else
            rc = fm_set_ftype (fm->lv, &fm->model, name);
        if (rc == -1)
            break; /* XXX: fixme? */
    }
    DragFinish (dd_files);
    return rc;
}


/* Add a single file @name to the list view and before
   figure out the type of it. 
   Return value: 0 on success. */
static int
add_single_file (listview_ctrl_t lv, fm_model_t *fm, const char *name)
{
    fm_model_t m;
    const char *type;
    int rc;
    
    type = fm_get_file_type (name, NULL);
    if (!type)
        return WPTERR_FILE_OPEN;
    m = new fm_model_s;
    memset (m, 0, sizeof *m);
    if (!strcmp (type, "UNKNOWN"))      
        type = gnupg_check_file_ext (name, NULL);
    rc = listview_add_item2 (lv, "", (void*)m);
    if (!rc) {
        listview_add_sub_item (lv, 0, FM_COL_STAT, type);
        listview_add_sub_item (lv, 0, FM_COL_NAME, name);
    }
    m->status = m_strdup (type);
    m->name = m_strdup (name);
    m->op = NULL;
    fm_model_add_file (fm, m);
    return rc;
}


/* Use the common Open-File-Dialog to allow the user to
   add one ore more selected files to the listview @lv. */
int
fm_add_opened_files (fm_info_t fm, HWND dlg)
{
    OPENFILENAME open;
    char file[512], filter[512], name[MAX_PATH+1];
    char *path = NULL;
    const char *s;
    int i, len=0, n=0;
    int rc=0;
    
    memset (&open, 0, sizeof (open));
    open.lStructSize = sizeof (OPENFILENAME);
    open.hInstance = glob_hinst;
    open.lpstrTitle = _("File Open");
    strcpy (filter, _("All Files (*.*)")); // FIXME: use length check
    memcpy (filter+strlen (filter)+1, "*.*\0\0", 5);
    open.lpstrFilter = filter;
    open.hwndOwner = dlg;
    open.lpstrFile = file;
    open.nMaxFile = DIM (file) - 1;
    open.Flags = OFN_ALLOWMULTISELECT|OFN_EXPLORER;
    
    memset (file, 0, sizeof file);
    if (!GetOpenFileName (&open))
        return 0;

    /* It is possible that multiple files are returned
       and then they are separated by \0 chars. */
    s = file;
    len = DIM (file)-1;
    for (;;) {
        if (len < 2 || (*s == '\0' && *(s+1) == '\0'))
            break;
        memset (name, 0, sizeof (name));
        for (i=0; len > 0; len--, i++) {
            if (*s == '\0') {
                name[i] = *s++;
                break;
            }
            name[i] = *s++;
        }
        if (n == 0)
            path = m_strdup (name);
        else {
            char *p = make_filename (path, name, NULL);
            rc = add_single_file (fm->lv, &fm->model, p);
            free_if_alloc (p);
        }
        n++;
    }
    if (n == 1) /* single file selected. */
        rc = add_single_file (fm->lv, &fm->model, path);
    free_if_alloc (path);
    return rc;
}


int
fm_assume_onepass_sig (const char *fname)
{    
    armor_filter_context_t afx;
    gpg_iobuf_t fp;
    gpgme_data_t dat;
    PACKET *pkt;
    char tmpfile[MAX_PATH+1];
    int check = 0;

    pkt = (PACKET *)calloc (1, sizeof *pkt);
    if (!fname) {
        get_temp_name (tmpfile, DIM (tmpfile)-1, "gpgme.tmp");
        gpg_data_new_from_clipboard (&dat, 0);
        gpg_data_release_and_set_file (dat, tmpfile);

        fp = gpg_iobuf_open (tmpfile);
        if (!fp)
            return 0;
        gpg_iobuf_ioctl (fp, 3, 1, NULL); /* disable cache. */
        if (gpg_use_armor_filter(fp)) {
            memset (&afx, 0, sizeof (afx));
            gpg_iobuf_push_filter (fp, gpg_armor_filter, &afx);
        }
        gpg_init_packet (pkt);
        if (!gpg_parse_packet (fp, pkt)
            && pkt->pkttype == PKT_COMPRESSED)
            check = 1;  
        gpg_free_packet (pkt);
        gpg_iobuf_close (fp);
        DeleteFile (tmpfile);
    }
    /* XXX: implement it for real files */
    safe_free (pkt);
    return check;
}


int
fm_get_current_pos (listview_ctrl_t lv)
{
    int i = 0;
    int items;

    items = listview_count_items (lv, 0);
    if (!items)
        return -1;
    else if (items == 1) {
        listview_select_one (lv, 0);
        return 0;
    }
    else if (items > 1) {
        i = listview_get_curr_pos (lv);
        if (i == -1) {
            msg_box (lv->ctrl, _("Please select a file."), 
                     _("File Manager"), MB_ERR);
            return -1;
        }
        return i;
    }

    return -1;
}


static int
fm_check_detached_sig (listview_ctrl_t lv, int pos)
{
    char type[64];

    listview_get_item_text (lv, pos, 0, type, DIM (type)-1);
    return !strcmp (type, "SIGNED-DETACH")? 1 : 0;
}


/* Check if the given file on position @pos is useful for
   command @fmd_cmd. For example sign can be used for all files
   which are not already signed. */
int
fm_check_file_type (listview_ctrl_t lv, int pos, int fm_cmd)
{
    char status[64];
    int rc = 0;
    
    listview_get_item_text (lv, pos, 0, status, DIM (status) - 1);
    
    switch (fm_cmd) {
    case FM_ENCRYPT:
    case FM_SIGNENCRYPT:   
        if (strcmp (status, "ENCRYPTED") 
            && strcmp (status, "SYMKEYENC"))
            rc = 1;
        break;
        
    case FM_DECRYPT: 
        if (!strcmp (status, "DATA") ||
            !strcmp (status, "ENCRYPTED") ||
            !strcmp (status, "SYMKEYENC") ||
            !strcmp (status, "ARMORED"))
            rc = 1;
        break;
        
    case FM_SIGN: 
        if (strncmp( status, "SIGNED", 6)) 
            rc = 1;
        break;
        
    case FM_VERIFY: 
        if(!strncmp (status, "SIGNED", 6) ||
           !strcmp (status, "COMPRESSED"))
            rc = 1;
        break;
        
    case FM_SYMENC:
        if (strcmp (status, "SYMKEYENC"))
            rc = 1;
        break;
        
    case FM_IMPORT:
        if (!strcmp (status, "PUBKEY") ||
            !strcmp (status, "SECKEY"))
            rc = 1;
        break;
        
    case FM_LIST:
        rc = 1; 
        break;  
    }
    
    return rc;
}


/* Set the file status of the given command @fm_cmd.
   @success is 0 on success. */
static void
fm_set_status (listview_ctrl_t lv, int pos, int fm_cmd, 
               gpgme_sig_mode_t sigmode, int success, const char *output)
{
    char status[128], operat[128];
    int update = 1;
    const char *s;

    if (fm_cmd == FM_LIST)
        return;
    success ? s = "SUCCESS" : s = "FAILED";
    strcpy (operat, s);

    switch (fm_cmd) {
    case FM_ENCRYPT: 
    case FM_SIGNENCRYPT: 
        strcpy (status, "ENCRYPTED");
        break;

    case FM_DECRYPT:
        strcpy (status, "UNKNOWN");
        break;

    case FM_SIGN:
        if (sigmode == GPGME_SIG_MODE_DETACH)
            strcpy (status, "SIGNED-DETACH");
        else if (sigmode == GPGME_SIG_MODE_CLEAR)
            strcpy (status, "SIGNED-CLEAR");
        else
            strcpy (status, "SIGNED");
        break;
    case FM_VERIFY:
        update = 0;
        break;

    case FM_SYMENC:
        strcpy (status, "SYMKEYENC");
        break;

    case FM_IMPORT:
        update = 0;                    
        break;

    default:
        strcpy (status, "UNKNOWN");
        break;
    }

    if (success && update) {
        listview_add_sub_item (lv, pos, FM_COL_STAT, status);
        listview_add_sub_item (lv, pos, FM_COL_NAME, output);
    }
    listview_add_sub_item (lv, pos, FM_COL_OP, operat);
}


int
fm_clearsign_8bit (listview_ctrl_t lv, fm_state_s *ctx)
{
    FILE *f;
    BYTE buf[32];
    char name[MAX_PATH+1];
    int i, n, cnt=0;

    if (ctx->sigmode != GPGME_SIG_MODE_CLEAR)
        return 0;
    listview_get_item_text (lv, -1, FM_COL_NAME, name, DIM (name)-1);
    if (stristr (name, ".txt"))
        return 0;
    f = fopen (name, "rb");
    if (!f)
        return -1; /* should never happen */
    n = fread (buf, 1, 32, f);
    fclose (f);
    for (i = 0; i < n; i++) {
        if (buf[i] == 0x00 || buf[i] > 170)
            cnt++;
    }
    if (!cnt)
        return 0;
    n = -1;
    i = log_box (_("File Manager"), MB_WARN|MB_YESNO,
                 _("\"%s\" does not seems to be a text file.\n"
                   "Do you really want to clearsign it?"), name);
    if (i == IDYES)
        n = 0;
    return n;
}

int
fm_parse_files (listview_ctrl_t lv, HWND dlg, int cmd)
{
    struct progress_filter_s pfx/*, pfx2*/;
    fm_state_s * ctx;
    int fm_cmd, sig_detached = 0;
    int rc = 0, i, n;
    char fname[2*MAX_PATH+1], status[128];
    
    switch (cmd) {
    case ID_FILEMISC_ENCRYPT: fm_cmd = FM_ENCRYPT; break;
    case ID_FILEMISC_DECRYPT: fm_cmd = FM_DECRYPT; break;
    case ID_FILEMISC_SYMENC:  fm_cmd = FM_SYMENC;  break;
    case ID_FILEMISC_SIGN:    fm_cmd = FM_SIGN;    break;    
    case ID_FILEMISC_VERIFY:  fm_cmd = FM_VERIFY;  break;
    case ID_FILEMISC_IMPORT:  fm_cmd = FM_IMPORT;  break;
    case ID_FILEMISC_LIST:    fm_cmd = FM_LIST;    break;
    case ID_FILEMISC_SIGNENC: fm_cmd = FM_SIGNENCRYPT; break;
    default: return 1; /* unknown command */
    }
    
    if (fm_get_current_pos (lv) == -1)
        return WPTERR_GENERAL;
    rc = fm_state_new (&ctx);
    if (rc)
        BUG (0);
    ctx->dlg = dlg;

    // TODO: for file operations the progress dialog will be
    //       reloaded somewhere and thus a 'dummy' dialog remains

    /* we use it here to make sure that pfx_cleanup will not use
       any weird values. */
    memset (&pfx, 0, sizeof (pfx));
    ctx->prog_cb = NULL;
    if (cmd != FM_VERIFY && cmd != FM_SIGN /*&& reg_prefs.fm.progress > 0*/) {
        pfx.hwnd = dlg;
        /*gpgme_set_progress_cb (ctx->ctx, progress_callback, &pfx);*/
        /*ctx->prog_cb = &pfx;*/
    }
    
    /* Commands we need before we can perform the main command */
    switch (fm_cmd) {    
    case FM_ENCRYPT:
    case FM_SIGNENCRYPT:
        if (fm_cmd == FM_SIGNENCRYPT)
            ctx->req_signer = 1;
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_ENCRYPT, 
                        ctx->dlg, file_encrypt_dlg_proc, (LPARAM)ctx);
        if (ctx->cancel == 1) {
            rc = WPTERR_GENERAL;
            goto leave;
        }
        break;
        
    case FM_SIGN:
        DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FILE_SIGN, dlg,
                        file_sign_dlg_proc, (LPARAM) ctx);
        if (ctx->cancel == 1 || fm_clearsign_8bit (lv, ctx)) {
            rc = WPTERR_GENERAL; 
            goto leave;
        }
        break;
    }
    
    for (i = 0, n = 0;  i < listview_count_items (lv, 0); i++) {
        if (!listview_get_item_state (lv, i))
            continue;
        listview_get_item_text (lv, i, FM_COL_STAT, status, DIM (status) -1);
        if (!strcmp (status, "ENCRYPTED") && fm_cmd == FM_DECRYPT)
            n++;
        if (!strcmp (status, "UNKNOWN") && fm_cmd == FM_SIGN)
            n++;
    }
    
    if (n > 1 && fm_cmd != FM_SYMENC)
        ctx->cache_cb = 1;

    for (i = 0; i < listview_count_items (lv, 0); i++) {
        if (!listview_get_item_state (lv, i))
            continue;
        listview_get_item_text (lv, i, FM_COL_NAME, fname, DIM (fname) - 1);
        if (file_exist_check (fname) && !is_directory (fname)) {
            log_box (_("File Manager"), MB_ERR, 
                     _("\"%s\" does not exist"), fname);
            continue;
        }       
        if (!fm_check_file_type (lv, i, fm_cmd))
            continue;
        sig_detached = fm_check_detached_sig (lv, i);
        switch (fm_cmd) {
        case FM_LIST:        fm_list( fname, dlg );       break;
        case FM_ENCRYPT:     rc = fm_encrypt( ctx, fname, 0 ); break;
        case FM_SIGNENCRYPT: rc = fm_encrypt( ctx, fname, 1 ); break;
        case FM_DECRYPT:     rc = fm_decrypt( ctx, fname );    break;
        case FM_SIGN:        rc = fm_sign( ctx, fname );       break;
        case FM_SYMENC:      rc = fm_sym_encrypt (ctx, fname); break;
        case FM_VERIFY:      rc = fm_verify (ctx, sig_detached, fname);break;
        case FM_IMPORT:
            free_if_alloc (ctx->opaque);
            ctx->opaque = m_strdup (fname);
            DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,
                            file_import_dlg_proc, (LPARAM)ctx);
            if (ctx->cancel == 1)
                continue;
            rc = fm_import (ctx, fname);
            break;
        }
        if (ctx->cancel == 1) {
            ctx->cancel = 0;
            continue;
        }
        fm_set_status (lv, i, fm_cmd, ctx->sigmode, !rc, ctx->output);
        free_if_alloc (ctx->output);
        progress_cleanup (&pfx);
    }

    if (ctx->cache_cb) {
        release_gpg_passphrase_cb (&ctx->pass_cb);
        ctx->cache_cb = 0; /* make sure it's only used for this session! */
    }
    
leave:
    if (!rc)
        fm_state_release (ctx);
    progress_cleanup (&pfx);
    return rc;
}


/* Dump out the given PGP packets from file @name in a dialog. */
void
fm_list (const char *name, HWND dlg)
{
    dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_STAT, dlg,
                      file_stat_dlg_proc, (LPARAM)name, _("File Status"),
                      IDS_WINPT_FILE_STAT);
}


static int
ask_filename (fm_state_t c, const char *msg, const char *oldfile, char **dst)
{
    const char *s;

    s = get_filesave_dlg (c->dlg, msg, NULL, oldfile);
    if (!s)
        return WPTERR_GENERAL;

    if (dst != NULL)
        free_if_alloc (*dst);
    free_if_alloc (c->output);
    c->output = m_strdup (s);
    if (dst != NULL)
        *dst = fm_quote_file (s);
    return 0;
}


int
fm_encrypt (fm_state_t c, const char *name, int sign)
{
    gpgme_error_t err;
    gpgme_key_t key = NULL;
    gpgme_ctx_t ctx = c->ctx;
    file_data_t in=NULL, out=NULL;
    char *keyid = NULL, ext[5];
    int rc = 0;

    c->output = new char[strlen (name) + 5 + 1];
    if (!c->output)
        BUG (0);
    strcpy (ext, file_get_extension (ctx, c->sigmode));
    strcpy (c->output, name);
    strcat (c->output, ext); 
    
    if (!overwrite_file (c->output)) {
        rc = ask_filename (c, _("Enter Filename for Encrypted File"), c->output, NULL);
        if (rc)
            goto leave;
    }

    err = gpg_file_data_new (name, F_DATA_READ, &in);
    if (err)
        goto leave;
    remove_crit_file_attrs (c->output, 0);
    err = gpg_file_data_new (c->output, F_DATA_WRITE, &out);
    if (err)
        goto leave;

    /*
    int no_compr = 0;
    if (c->prog_cb) {
        c->prog_cb->what = name;
        gpg_file_data_set_cb (in, c->prog_cb);
    }
    */
    
    // TODO: disable compression for multi-media files.
    
    if (sign) {
        if (gpgme_signers_enum (ctx, 0) == NULL) {
            keyid = get_gnupg_default_key ();
            if (!keyid) {
                msg_box (c->dlg, _("Could not get default secret key."),
                         _("Signing"), MB_ERR);
                rc = WPTERR_GENERAL;
                goto leave;
            }
            if (get_seckey (keyid, &key))
                BUG (0);
            gpgme_signers_add (ctx, key);
        }
        else {
            gpgme_key_t sigkey = gpgme_signers_enum (ctx, 0);
            if (sigkey && sigkey->subkeys) {
                keyid = m_strdup (sigkey->subkeys->keyid);
            }
        }
        if (!c->init_cb || !c->cache_cb) {
            set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_SIGN, 
                                   c->dlg, _("Signing"));
            c->init_cb = 1;
        }
        op_begin ();
        err = gpgme_op_encrypt_sign (ctx, c->recp, GPGME_ENCRYPT_ALWAYS_TRUST, 
                                     in->dat, out->dat);
        op_end ();
        if (!c->cache_cb)
            release_gpg_passphrase_cb (&c->pass_cb);
        if (c->pass_cb.cancel) {
            rc = WPTERR_GENERAL;
            goto leave;
        }
        if (err) {
            msg_box (c->dlg, gpgme_strerror (err), _("Sign"), MB_ERR);
            if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
                agent_del_cache (keyid);
            rc = WPTERR_GENERAL; 
            goto leave;
        }
    }
    else {
        op_begin ();
        err = gpgme_op_encrypt (ctx, c->recp, GPGME_ENCRYPT_ALWAYS_TRUST,
                                in->dat, out->dat);
        op_end ();
        if (err) {
            msg_box (c->dlg, gpgme_strerror (err), _("Encrypt"), MB_ERR);
            rc = WPTERR_GENERAL; 
            goto leave;
        }
    }
    
leave:
    if (in)
        gpg_file_data_release (in);
    if (out)
        gpg_file_data_release (out);
    free_if_alloc (keyid);
    return rc;
}


int
fm_sym_encrypt (fm_state_t c, const char * name)
{
    gpgme_ctx_t ctx = c->ctx;
    gpgme_error_t err;    
    file_data_t in=NULL, out=NULL;
    int rc = 0, cancel = 0;
    char ext[5], *pass;    
    
    pass = request_passphrase2 (_("Symmetric Encryption"), 0, &cancel);
    if (cancel) {
        c->cancel = 1;
        return 0;
    }
    
    /* XXX: a convenient feature could be to select the preferred
            symmetric algorithm. */
    c->output = new char[strlen (name) + 5 + 1];
    if (!c->output)
        BUG (0);
    strcpy (ext, file_get_extension (ctx, c->sigmode));
    strcpy (c->output, name);
    strcat (c->output, ext);

    if (overwrite_file (c->output) == 0) {
        rc = WPTERR_GENERAL;
        goto leave;     
    }

    gpgme_set_passphrase_cb (ctx, sym_passphrase_cb, pass);
    err = gpg_file_data_new (name, 1, &in);
    if (err)
        goto leave;
    err = gpg_file_data_new (c->output, 0, &out);
    if (err)
        goto leave;

    op_begin ();
    err = gpgme_op_encrypt (ctx, NULL, GPGME_ENCRYPT_ALWAYS_TRUST, 
                            in->dat, out->dat);
    op_end ();
    if (err) {
        msg_box (c->dlg, gpgme_strerror (err), _("Symmetric"), MB_ERR);
        rc = WPTERR_GENERAL;
        goto leave;
    }
    if (file_exist_check (c->output)) {
        msg_box (c->dlg, _("Encryption failed."), _("Symmetric"), MB_ERR);
        rc = WPTERR_GENERAL;
    }
    
leave:
    if (in)
        gpg_file_data_release (in);
    if (out)
        gpg_file_data_release (out);
    sfree_if_alloc (pass);
    return rc;
}


/* Check the recipients if we have at least one secret key. */
bool
is_seckey_available (gpgme_recipient_t rset)
{
    gpgme_recipient_t r;
    winpt_key_s key;

    for (r=rset; r; r = r->next) {
        if (gpgme_err_code (r->status) == GPG_ERR_NO_SECKEY)
            continue;
        else {
            memset (&key, 0, sizeof (key));
            /* extra check to make sure the key is available right now. */
            if (!winpt_get_seckey (r->keyid, &key)) {
                winpt_release_pubkey (&key);
                return true;
            }
            winpt_release_pubkey (&key);
        }
    }
    return false;
}


/* If the decrypt result contains the original file name,
   we use it instead of the artificial "output - .gpg" string. */
static int
restore_original_name (const char *output, const char *file_name)
{
    char *dir;
    char *orig;
    int rc = 0;

    dir = strrchr (output, '\\');
    if (!dir)
        orig = strdup (file_name);
    else {
        orig = (char*)calloc (1, strlen (file_name)+ 1 + 
                                 strlen (output)+1);
        if (!orig)
            BUG (0);
        memcpy (orig, output, (dir-output)+1);
        strcat (orig, file_name);
    }
    /* XXX: we need to find out if the string needs to be utf8 decoded. */
    if (overwrite_file (orig)) {
        DeleteFile (orig);
        if (!MoveFile (output, orig))
            rc = -1;
    }
    safe_free (orig);
    return rc;
}


/* Decrypt the file @name. */
int
fm_decrypt (fm_state_t c, const char *name)
{
    gpgme_error_t err;
    gpgme_ctx_t ctx = c->ctx;    
    gpgme_decrypt_result_t res;
    gpgme_verify_result_t sigres;
    file_data_t in = NULL, out = NULL;
    int rc = 0;
    
    if (!c->init_cb || !c->cache_cb) {
        set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_DECRYPT,
                               c->dlg, _("Decryption"));
        c->init_cb = 1;
    }
    
    c->output = m_strdup (name);
    if (is_openpgp_ext (c->output))
        c->output[strlen (c->output)-4] = '\0';
    else {
        const char *s;
        s = get_filesave_dlg (c->dlg, _("Choose Filename for Output"),
                              NULL, NULL);
        if (s) {
            free_if_alloc (c->output);
            c->output = m_strdup (s);
        }
    }

    if (overwrite_file (c->output) == 0) {
        rc = ask_filename (c, _("Enter Filename for Plaintext File"), c->output, NULL);
        if (rc)
            goto leave;
    }

    /* we fetch all recipients here to make sure they list is complete. */
    release_gpg_recipients (&c->pass_cb.recipients);
    gpg_get_recipients (name, &c->pass_cb.recipients);

    err = gpg_file_data_new (name, F_DATA_READ, &in);
    if (err)
        goto leave;
    remove_crit_file_attrs (c->output, 0);
    err = gpg_file_data_new (c->output, F_DATA_WRITE, &out);
    if (err)
        goto leave;
    
    op_begin ();
    err = gpgme_op_decrypt_verify (ctx, in->dat, out->dat);
    op_end ();
    if (!c->cache_cb)
        release_gpg_passphrase_cb (&c->pass_cb);
    if (c->pass_cb.cancel) {
        rc = WPTERR_GENERAL;
        goto leave;
    }

    res = gpgme_op_decrypt_result (ctx);
    if (res && res->recipients && !is_seckey_available (res->recipients)) {
        const char *keyid = get_keyid_from_fpr (res->recipients->keyid);
        char *p = get_key_userid (keyid);
        gpgme_pubkey_algo_t pkalgo = res->recipients->pubkey_algo;
        
        log_box (_("Decryption"), MB_ERR, 
                 _("Encrypted with %s key, ID 0x%s.%s\n"
                   "Decryption failed: secret key not available."), 
                   get_key_pubalgo (pkalgo), keyid, p);
        rc = WPTERR_GENERAL;
        free_if_alloc (p);
        goto leave;
    }
    else if (err) {
        msg_box (c->dlg, gpgme_strerror (err), _("Decrypt"), MB_ERR);
        rc = WPTERR_GENERAL;
        goto leave;
    }
    if (file_exist_check (c->output)) {
        log_box ("Decrypt", MB_ERR, 
                 _("Decryption failed.\n%s: does not exist."), c->output);
        rc = WPTERR_GENERAL;
        goto leave;
    }
    else if (res && res->file_name) {
        char *file;
        int id = IDNO;

        file = strrchr (c->output, '\\');
        if (!file)
            file = c->output;
        else
            file++;
        if (strcmp (res->file_name, file))
            id = log_box (_("Decrypt"), MB_QUEST_ASK,
                          _("The original file name is '%s'.\n\n"
                            "Do you want to use this instead of '%s'?"),
                      res->file_name, file);
        if (id == IDYES) {
            /* before we can move the file, it needs to be closed first. */
            gpg_file_data_release (out);
            out = NULL;
            restore_original_name (c->output, res->file_name);
        }
    }
    sigres = gpgme_op_verify_result (ctx);
    if (sigres && sigres->signatures)
        verify_show_signature_state (sigres->signatures);
    
leave:
    if (in)
        gpg_file_data_release (in);
    if (out)
        gpg_file_data_release (out);

    return rc;
}


int
fm_sign (fm_state_t c, const char * name)
{
    gpgme_ctx_t ctx = c->ctx;
    gpgme_error_t err;
    file_data_t in=NULL, out=NULL;
    char ext[5];
    int rc = 0;

    if (!c->init_cb || !c->cache_cb) {
        set_gpg_passphrase_cb (&c->pass_cb, c->ctx, 
                               GPG_CMD_SIGN, c->dlg, _("Signing"));
        c->init_cb = 1;
    }
    
    free_if_alloc (c->output);
    c->output = new char[strlen (name) + 5 + 1];
    if (!c->output)
        BUG (NULL);
    strcpy (ext, file_get_extension (ctx, c->sigmode));
    strcpy (c->output, name);
    strcat (c->output, ext);
    
    if (!overwrite_file (c->output)) {
        rc = ask_filename (c, _("Enter Filename for Signed File"), c->output, NULL);
        if (rc)
            goto leave;
    }
    
    err = gpg_file_data_new (name, F_DATA_READ, &in);
    if (err)
        goto leave;
    remove_crit_file_attrs (c->output, 0);
    err = gpg_file_data_new (c->output, F_DATA_WRITE, &out);
    if (err)
        goto leave;

    op_begin ();
    err = gpgme_op_sign (ctx, in->dat, out->dat, c->sigmode);
    op_end ();
    if (!c->cache_cb)
        release_gpg_passphrase_cb (&c->pass_cb);
    if (c->pass_cb.cancel) {
        rc = WPTERR_GENERAL;
        goto leave;
    }
    if (err) {
        msg_box (c->dlg, gpgme_strerror (err), _("Sign"), MB_ERR);
        rc = WPTERR_GENERAL;
        goto leave;     
    }

leave:
    if (in)
        gpg_file_data_release (in);
    if (out)
        gpg_file_data_release (out);
    return rc;
}


static void
fm_add_sig_stat (file_sig_ctx_t log)
{
    struct winpt_key_s key;
    const char *kid;

    memset (&key, 0, sizeof (key));
    kid = get_keyid_from_fpr (log->sig->fpr);
    log->use_uid = 0;
    if (!winpt_get_pubkey (kid, &key)) {
        log->user_id = key.ext->uids->uid;
        log->use_uid = 1;
    }
    file_verify_add_state (log);
    winpt_release_pubkey (&key); 
}


/* Verify a detached signature from the clipboard. */   
static int
verify_pasted (listview_ctrl_t lv, fm_state_t ctx, 
               const char *dat, int pos, HWND dlg)
{
    FILE *fp;
    char stat[32];
    char file[MAX_PATH+1], *fname = NULL;
    int del_end = 0;

    listview_get_item_text (lv, pos, FM_COL_STAT, stat, DIM (stat)-1);
    listview_get_item_text (lv, pos, FM_COL_NAME, file, DIM (file)-1);
    if (strcmp (stat, "UNKNOWN"))
        return 0;
    fname = make_filename (NULL, file, "asc");
    if (file_exist_check (fname) != 0) {
        fp = fopen (fname, "wb");
        if (fp == NULL) {
            log_box (_("File Manager"), MB_ERR, "Could not create '%s'", fname);
            free_if_alloc (fname);
            return WPTERR_GENERAL;
        }
        fwrite (dat, 1, strlen (dat), fp);
        fclose (fp);
        del_end = 1;
    }
    fm_verify (ctx, 1, fname);
    if (del_end)
        DeleteFile (fname);
    free_if_alloc (fname);
    return 0;
}


/* Figure out if the clipboard contains a detached signature. */
int
fm_verify_pasted_detsig (listview_ctrl_t lv, HWND dlg)
{
    fm_state_t ctx = NULL;
    char * dat=NULL;
    int i, fnd = 0;

    dat = get_clip_text (NULL);
    if (!dat || !strstr (dat, "BEGIN PGP SIGNATURE")) {
        msg_box (dlg, _("Could not find detached signature in the clipboard."),
                 _("File Manager"), MB_ERR);
        free_if_alloc (dat);
        return WPTERR_GENERAL;
    }
    /* XXX find a way to filter out bad signatures or just ignore all in 
           this case */
    fm_state_new (&ctx);
    i = listview_get_curr_pos (lv);
    if (i == -1) {
        verify_pasted (lv, ctx, dat, i, dlg);
        fnd = 1;
    }
    else {
        for (i=0; i < listview_count_items (lv, 0); i++) {
            verify_pasted (lv, ctx, dat, i, dlg);
            fnd = 1;
        }
    }
    if (!fnd)
        msg_box (dlg, _("No files to check."), _("File Manager"), MB_INFO);
    free_if_alloc (dat);
    fm_state_release (ctx);
    return 0;
}


/* Extract automatically the output file name from @name.
   If @detached is 1, a detached sig is assumed. */
static int
get_output_file (fm_state_t c, const char *name, int detached)
{
    const char *file = NULL;
    const char *title;
    char fname[384];
    
    if (detached)
        title = _("Select Data File");
    else
        title = _("Selected Output File");

    if (is_openpgp_ext (name)) {
        _snprintf (fname, DIM (fname) - 1, "%s", name);
        fname[strlen (fname) - 4] = '\0';
        if (file_exist_check (fname) == 0 && detached)  
            file = fname;
        else if (!detached) {
            /* If the signature is clear or normal, make sure we do not
               overwrite the original file if it exists. */
            if (file_exist_check (fname) == 0 && !overwrite_file (fname)) {
                file = get_filesave_dlg (c->dlg, title, NULL, NULL);
                if (!file)
                    return WPTERR_GENERAL;
            }
            else
                file = fname;
        }
    }
    if (!file)
        file = get_fileopen_dlg (c->dlg, title, NULL, NULL);
    if (file) {    
        free_if_alloc (c->output);    
        c->output = m_strdup (file);
    }
    else {
        msg_box (c->dlg, _("Invalid file name. Exit"), _("Verify"), MB_ERR);
        return WPTERR_GENERAL;  
    }
    if (detached)
        c->sigmode = GPGME_SIG_MODE_DETACH;
    else {
        if (stristr (name, ".asc"))
            c->sigmode = GPGME_SIG_MODE_CLEAR;
        else
            c->sigmode = GPGME_SIG_MODE_NORMAL;
    }
    return 0;
}


/* Handy function to kick of the gpg verify process. */
static gpgme_error_t
fm_gpg_verify (gpgme_sig_mode_t sigmode, gpgme_ctx_t ctx,
               file_data_t in, file_data_t out)
{
    gpgme_error_t err;

    op_begin ();
    if (sigmode == GPGME_SIG_MODE_DETACH)
        err = gpgme_op_verify (ctx, in->dat, out->dat, NULL);
    else
        err = gpgme_op_verify (ctx, in->dat, in->dat, out->dat);
    op_end ();
    return err;
}


/* Verify the signature from the file @name. If @detached 1,
   it is assumed that a detached signature should be checked. */
int
fm_verify (fm_state_t c, int detached, const char *name)
{
    gpgme_error_t err;
    gpgme_signature_t s;
    gpgme_verify_result_t res;
    struct file_sig_ctx_s log;
    file_data_t in=NULL, out=NULL;
    int rc = 0;

    if (stristr (name, ".sig"))
        detached = 1;

    if (get_output_file (c, name, detached))
        return WPTERR_GENERAL;

    file_verify_create_dlg ();

    memset (&log, 0, sizeof (log));
    log.file = m_strdup (name);    

    err = gpg_file_data_new (name, F_DATA_READ, &in);
    if (err)
        goto leave;
    err = gpg_file_data_new (c->output, 
                             detached? F_DATA_READ : F_DATA_WRITE, &out);
    if (err)
        goto leave;

    err = fm_gpg_verify (c->sigmode, c->ctx, in, out);
    if (err) {
        msg_box (c->dlg, gpgme_strerror (err), _("Verify"), MB_ERR);
        rc = WPTERR_GENERAL; 
        goto leave;
    }    

    res = gpgme_op_verify_result (c->ctx);
    if (!res)
        goto leave;
    if (res->signatures != NULL &&
        gpgme_err_code (res->signatures->status) == GPG_ERR_NO_PUBKEY) {
        /* We need to call gpg again to get the actual sig state
           and the data files must be rewinded also. */
        if (fetch_key_from_keyserver (c->dlg, res->signatures)) {
            rc = WPTERR_GENERAL;
            goto leave;
        }
        gpg_file_data_rewind (in);
        gpg_file_data_rewind (out);
        err = fm_gpg_verify (c->sigmode, c->ctx, in, out);
        if (err) {
            msg_box (c->dlg, gpgme_strerror (err), _("Verify"), MB_ERR);
            rc = WPTERR_GENERAL;
            goto leave;
        }
        /* Refresh the pointer because a new GPG instance has been
           created for the new verify operation. */
        res = gpgme_op_verify_result (c->ctx);
    }
    
    for (s=res->signatures; s; s=s->next) {
        log.sig = s;
        fm_add_sig_stat (&log);
    }
    if (!c->output)
        c->output = m_strdup (name); /* for later use */

leave:
    if (in)
        gpg_file_data_release (in);
    if (out)
        gpg_file_data_release (out);
    free_if_alloc (log.file);
    return rc;
}


/* Import the keys from the file @name.
   Return value: 0 on success. */
int
fm_import (fm_state_t c, const char *name)
{
    gpgme_ctx_t ctx = c->ctx;
    gpgme_error_t err;
    gpgme_import_result_t res;
    file_data_t keydata = NULL;
    int rc = 0;

    free_if_alloc (c->output);
    c->output = m_strdup (name);

    err = gpg_file_data_new (name, F_DATA_READ, &keydata);
    if (err)
        goto leave;

    op_begin ();
    err = gpgme_op_import (ctx, keydata->dat);
    op_end ();
    if (err) {
        msg_box (c->dlg, gpgme_strerror (err), _("Import"), MB_ERR);
        rc = WPTERR_GENERAL;
        goto leave;
    }

    res = gpgme_op_import_result (ctx);
    print_import_status (res);
    if (res->no_user_id > 0) {
        msg_box (c->dlg, _("Key without a self signature was dectected!\n"
                           "(This key is NOT usable for encryption, etc)\n"
                           "\n" 
                           "Cannot import these key(s)!"), _("Import"), MB_INFO);
    }

leave:
    if (keydata)
        gpg_file_data_release (keydata);
    return rc;
}


/* Parse the command line and process the given file. */   
int
fm_parse_command_line (char *cmdl)
{
    fm_state_t ctx;
    const char *s;
    char *p, *fn = NULL;
    int count = 0, detached = 0;
    int type;
    
    if (!cmdl || !*cmdl)
        return 0;

    fm_state_new (&ctx);    
    ctx->dlg = GetActiveWindow ();
    ctx->cache_cb = 1;
    
    p = cmdl;
    if (p && *p > 32 && !stristr (p, "winpt.exe") 
                     && !strstr (p, "--" )) {
        count++;
        if (*p == '"') { /* need to remove quotes */
            fn = new char[strlen (p)];
            if (!fn)
                BUG (NULL);
            memcpy (fn, p + 1, strlen (p) - 2);
            fn[strlen (p) - 2] = '\0';
        }
        else
            fn = m_strdup (p);
        s = fm_get_file_type (fn, &type);
        if (!s || !strcmp (s, "UNKNOWN"))
            s = gnupg_check_file_ext (fn, &type);
        if (type == PGP_NONE) {
            log_box (_("File Manager"), MB_ERR, 
                     _("%s: no valid OpenPGP data found."), p);
            free_if_alloc (fn);
            return count;
        }
        switch (type) {
        case PGP_MESSAGE:
            fm_decrypt (ctx, fn); 
            break;

        case PGP_PUBKEY:
        case PGP_SECKEY:
            fm_import (ctx, fn); 
            break;

        case PGP_SIG:
        case PGP_CLEARSIG:
            if (type == PGP_SIG)    
                detached = 1;
            fm_verify (ctx, detached, fn);
            file_verify_wait ();
            break;

        default:
            break;
        }
    }

    wipememory (&ctx->pass_cb, sizeof (ctx->pass_cb));
    free_if_alloc (fn);
    fm_state_release (ctx);
    return count;
}


/* Extract the last folder name from @name. */
const char*
default_dirname (const char *name)
{
    char *p = strrchr (name, '\\');
    if (!p)
        return NULL;
    return p+1;
}


static int CALLBACK
fm_cmp_cb (LPARAM first, LPARAM second, LPARAM sortby)
{
    fm_model_t a, b;
    int cmpres = 0;

    a = (fm_model_t)first;
    b = (fm_model_t)second;
    if (!a || !b)
        return 0;

    switch ((int)sortby) {
    case FM_COL_STAT:
        cmpres = stricmp (a->status, b->status);
        break;

    case FM_COL_NAME:
        cmpres = stricmp (a->name, b->name);
        break;

    case FM_COL_OP:
        if (a->op && b->op)
            cmpres = stricmp (a->op, b->op);
        break;
    }
    return cmpres;
}


/* Sort the list items from @lv with the mode given by @sortby. */
int
fm_sort (listview_ctrl_t lv, int sortby)
{
    return ListView_SortItems (lv->ctrl, fm_cmp_cb, (LPARAM)sortby);
}


/* Send the selected file in @lv via MAPI to a mail recipient. */
int
fm_send_file (listview_ctrl_t lv)
{
    char name[MAX_PATH+1];

    int rc = listview_get_item_text (lv, -1, FM_COL_NAME, name, DIM (name)-1);
    if (rc != -1)
        mapi_send_ascfile (name);
    return 0;
}