trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2007 Timo Schulz
 *
 * 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 <windows.h>
#include <shlobj.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptGPG.h"
#include "wptRegistry.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptNLS.h"
#include "wptKeyserver.h"
#include "wptCard.h"
#include "wptFileManager.h"
#include "wptContext.h"
#include "wptCardEdit.h"
#include "wptCrypto.h"
#include "wptUTF8.h"

void remove_crit_file_attrs (const char *fname, int force);
BOOL user_is_admin (void);
int  pcsc_available (void);

/* Global variables. */
HINSTANCE glob_hinst;   /* global instance for the dialogs */
HWND glob_hwnd;         /* global window handle for the dialogs */
int scard_support = 0;
int debug = 0;
int gpg_read_only = 0;
int admin_user = 0;
char gpgver[3];
/* End */


/* Load the key cache and rebuild the signature cache. */
int
update_keycache (HWND hwnd)
{
    int err;
    refresh_cache_s rcs;

    /* no need to rebuild the sig cache each time. */
    memset (&rcs, 0, sizeof (rcs));
    rcs.kring_update = 1;
    err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
    if (err) {
        char *cfgf = get_gnupg_config ();
        if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
            msg_box (NULL, _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
        free_if_alloc (cfgf);
        return -1;
    }
    return 0;
}


/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
void
gpg_set_debug_mode (int val)
{
    static char buf[256];
    char tmp[128];
    
    /* XXX: no gpgme.dbg is created. */
    if (val > 0) {
        GetTempPath (DIM (tmp)-1, tmp);
        _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
        putenv (buf);
    }
    else
        putenv ("GPGME_DEBUG=");
}


/* Initialize the gettext sub system. */
static void
load_gettext (void)
{
    char *nls;

    /* Return the name of the gettext language file. */
    nls = get_reg_entry_mo ();
    if (nls != NULL) {
        gettext_set_file ("winpt", nls);
        free_if_alloc (nls);
    }
}


/* Return true if the GPG environment is useable. */
static bool
gpg_prefs_ok (void)
{
    char *p;

    p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p || file_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("gpgProgram");
        if (!p || file_exist_check (p) != 0) {
            free_if_alloc (p);
            log_debug ("gpg_prefs_ok: could not locate gpg.exe");
            return false;
        }
    }
    free_if_alloc (p);
    p = get_reg_entry_gpg4win (NULL);
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("HomeDir");
        if (!p || dir_exist_check (p) != 0) {
            free_if_alloc (p);
            log_debug ("gpg_prefs_ok: could not determine home directory");
            return false;
        }
    }
    free_if_alloc (p);
    return true;
}


/* Check gpg files if they are read-only and ask the user
   if this should be corrected. */
static void
check_readonly_attr (const char *homedir)
{
    const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
    char *file;
    int i;

    for (i=0; files[i] != NULL; i++) {
        file = make_filename (homedir, files[i], NULL);
        remove_crit_file_attrs (file, 0);
        free_if_alloc (file);
    }
}


/* Load the GPG environment. On the first start, some
   checks are performed to find out in what state GPG is.
   Return value: 0  everything OK.
                 >0  fatal error.
                 -1 public keyring is empty or does not exist. */
static int
load_gpg_env (void)
{
    SECURITY_ATTRIBUTES sec_attr;
    char *p;
    char *pkr;
    int err = 0;

    p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p)
        return (1);
    if (file_exist_check (p)) {
        free_if_alloc (p);
        return (1);
    }
    free_if_alloc (p);

    p = get_reg_entry_gpg ("HomeDir");
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = multi_gnupg_path (0);
    }
    if (p && dir_exist_check (p)) {
        memset (&sec_attr, 0, sizeof (sec_attr));
        sec_attr.nLength = sizeof (sec_attr);
        if (!CreateDirectory (p, &sec_attr)) {
            msg_box (NULL, _("Could not create GPG home directory"), 
                     _("WinPT Error"), MB_ERR);
            free_if_alloc (p);
            return (2);
        }
    }
    check_readonly_attr (p);
    pkr = make_filename (p, "pubring", "gpg");
    free_if_alloc (p);
    if (get_file_size (pkr) == 0)
        err = -1;
    free_if_alloc (pkr);
    return err;
}


/* check if the default key from the gpg.conf file is available in the
   keyring. if not, bail out because encryption won't work properly then. */
static int
check_default_key (void)
{
    gpgme_key_t key;
    gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
    gpg_keycache_t kc;
    char *defkey;

    kc = keycache_get_ctx (0);
    defkey = get_gnupg_default_key ();
    if (defkey) {
        err = gpg_keycache_find_key (kc, defkey, 0, &key);
        if (err) {
            free_if_alloc (defkey);
            return -1;
        }
    }
    else {
        /* Actually this is just a warning but we still continue. */
        msg_box (NULL, _("No useable secret key found."), 
                 _("WinPT Warning"), MB_WARN);
        free_if_alloc (defkey);
        return 0;
    }

    /* Because the secret key listing has no information
       about the validity/status, we need to check the public key. */
    kc = keycache_get_ctx (1);
    if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
        (key->revoked || key->expired)) {
        msg_box (NULL, _("Default secret key is unuseable"), 
                 _("WinPT Warning"), MB_ERR);
        free_if_alloc (defkey);
        return -1;
    }
    free_if_alloc (defkey);
    return 0;
}


/* Return the WinPT program file name (with full pathname). */
static const char*
get_prog_part (const char *fname, int use_cwd)
{
    static char program[2*MAX_PATH+1];
    char currdir[MAX_PATH+1];
    char *cmd;
    int j;
        
    memset (currdir, 0, DIM (currdir));
    memset (program, 0, DIM (program));
        
    if (use_cwd) {
        GetCurrentDirectory (DIM (currdir)-1, currdir);
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
    } 
    else {
        cmd = GetCommandLine ();
        if (!cmd)
            return NULL;
        strncpy (currdir, cmd, DIM (currdir)-1);
        j = strlen (currdir);
        while (j--) {
            if (currdir[j] == '\\')
                break;
        }
        currdir[j] = 0;
        _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
    }
    return program;
}


/* Check that the underlying crypto engine fullfills the minimal
   requirements so all commands work properly. */
static bool
check_crypto_engine (void)
{
    int ma = 0, mi = 0, pa = 0;
    int rc;

    rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
    if (rc == -1) {
        msg_box (NULL, _("Could not read GnuPG version."), 
                 _("WinPT Error"), MB_ERR);
        return false;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("A newer GPG version is needed.\n"
                   "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
                   ma, mi, pa);
        return false;
    }
    /* Enable smart card support for GPG 2 or >= 1.4 */
    if ((ma > 1 || pa >= 4) && pcsc_available ())
        scard_support = 1;

    gpgver[0] = ma;
    gpgver[1] = mi;
    gpgver[2] = pa;
    return true;
}


/* Try to load the keyserver config file. If @quiet is 1
   do not show any errors. */
static int
load_keyserver_conf (int quiet)
{    
    const char *t, *conf;
    char *buf;
    int rc;

    #ifdef WINPT_MOBILE
    /* In mobile mode we automatically assume the config file
       in the current directory. */
    return kserver_load_conf ("keyserver.conf");
    #endif

    /* Create $APPDATA\winpt if needed. */
    buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
    if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
        MessageBox (NULL, _("Failed to create WinPT directory"), 
                    _("Keyserver"), MB_ERR);
        free_if_alloc (buf);
        return -1;
    }
    free_if_alloc (buf);

    /* Check for $APPDATA\winpt\keyserver.conf */
    buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);

    conf = get_prog_part ("keyserver.conf", 0);
    if (!file_exist_check (conf))
        t = conf;
    else
        t = "keyserver.conf";
    if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
        if (!CopyFile (t, buf, FALSE)) {
            MessageBox (NULL, _("Failed to copy the keyserver.conf"), 
                        _("Keyserver"), MB_ERR);
            free_if_alloc (buf);
            return -1;
        }
        t = buf;
    }
    else
        t = buf;
    
    rc = kserver_load_conf (t);
    if (rc && !quiet)
        msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
    else {
        free_if_alloc (reg_prefs.kserv_conf);
        reg_prefs.kserv_conf = m_strdup (t);
    }
    free_if_alloc (buf);
    return rc;
}


/* Check if both keyrings are empty. This indicates that
   WinPT should offer to generate a key pair. */
static bool
check_for_empty_keyrings (bool pub_only)
{
    char *p;
    int n = 0;

    p = get_gnupg_keyring (1, 0);
    if (file_exist_check (p) == 0 && get_file_size (p) == 0)
        n++;
    free_if_alloc (p);
    if (pub_only)
        return n == 1? true : false;
    p = get_gnupg_keyring (0, 0);
    if (file_exist_check (p) == 0 && get_file_size (p) == 0)
        n++;
    free_if_alloc (p);
    return n==2? true : false;
}


#ifdef WINPT_MOBILE
/* Enable the mobile mode if possible. 
   There are some constraints which must be fullfilled.
   Return value: 0 on success. */
static int
enable_mobile_mode (void)
{
    static const char *test_fname = "winpt_mobile_test.txt";
    FILE *fp;
    char *pubring;
    ULARGE_INTEGER caller, total;
    DWORD temp_size;

    fp = fopen (test_fname, "wb");
    if (fp == NULL) {
        MessageBox (NULL, "Mobile mode cannot be used without write permission\n"
                          "for the current directory", "WinPT Error", MB_ERR);
            
        return -1;
    }
    fclose (fp);
    DeleteFile (test_fname);
    if (file_exist_check ("gpg.exe")) {
        MessageBox (NULL, "The GnuPG program needs to be in the same directory\n"
                          "as the WinPT program", "WinPT Error", MB_ERR);
        return -1;
    }
    
    /* Because write operations to the keyring result in a temporary
       file, we need at least 2 MB plus the size of the keyring for
       free space. */
    pubring = get_gnupg_keyring (1);
    temp_size = get_file_size (pubring) + 2097152;
    free_if_alloc (pubring);

    if (!GetDiskFreeSpaceEx (NULL, &caller, &total, NULL) ||
        caller.LowPart < temp_size) {
        log_box ("WinPT Error", MB_ERR, 
                 "The mobile mode needs at least %lu KB for temporary files",
                 temp_size/1024);
        return -1;
    }

    /* XXX: shall we check for 'temp-directory' in the gpg.conf? */

    return 0;
}
#endif


/* Set the default keyserver for this instance. */
void
set_default_keyserver (void)
{
    char *host = get_reg_entry_keyserver ("Default");
    char *str_port = get_reg_entry_keyserver ("Default_Port");
    WORD port = HKP_PORT;

    if (!host)
        keyserver_set_default (NULL, 0);
    else {
        if (str_port && *str_port)
            port = atoi (str_port);
        keyserver_set_default (host, port);
    }
    free_if_alloc (host);
    free_if_alloc (str_port);
}


/* Display info message that WinPT is now in debug mode. */
void
winpt_debug_msg (void)
{       
    char output[512];
    char temp[128];
        
    GetTempPath (DIM (temp) -1, temp);
    _snprintf (output, DIM (output)-1,
        "The GPGME output file is %sgpgme.dbg\n"
        "The WinPT output file is %swinpt.log\n", temp, temp);
    MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
}


/* Search for insecure ElGamal keys and return the
   number of founded keys. */
static int
count_insecure_elgkeys (void)
{
    gpg_keycache_t pc;
    gpgme_key_t key;
    int n = 0;

    pc = keycache_get_ctx (1);
    while (!gpg_keycache_next_key (pc, 0, &key)) {
        if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
            n++;
    }
    gpg_keycache_rewind (pc);
    return n;
}


/* Main entry point. */
int WINAPI
WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
{
    WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
    HACCEL accel_tab;
    MSG msg;
    HWND hwnd = NULL;
    WORD ver[3], ptdver[4];
    const char *s;
    int rc, ec, created = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    int start_manager = 0;    

#ifdef WINPT_MOBILE
    /* Do not continue in case of problems. */
    if (enable_mobile_mode ())
        return 0;
#endif

    glob_hinst = hinst;
    if (cmdline && stristr (cmdline, "--stop")) {
        hwnd = FindWindow ("WinPT", "WinPT");
        if (hwnd != NULL)
            PostMessage (hwnd, WM_DESTROY, 0, 0);
        return 0;
    }

#ifdef _DEBUG
    gpg_set_debug_mode (1);
    debug = 1;
#endif

    get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
    ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],   
                                 &ptdver[2], &ptdver[3]);
    
    if (!ec && (ptdver[0] != ver[0] || 
                ptdver[1] != ver[1] || 
                ptdver[2] != ver[2])) {
        log_box (_("WinPT Error"), MB_ERR, 
                 _("The PTD.dll file has a different version than WinPT.exe\n"
                   "Please update the PTD.dll to version %d.%d.%d"),
                   ver[0], ver[1], ver[2]);
        return 0;
    }

    if (gpg_md_selftest ()) {
        msg_box (NULL, _("Cryptographic selftest failed."),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    s = gpgme_check_version (NEED_GPGME_VERSION);
    if (!s || !*s) {
        msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    CreateMutex (NULL, TRUE, PGM_NAME);
    if (GetLastError () == ERROR_ALREADY_EXISTS)
        winpt_inst_found = 1;
    
    set_default_keyserver ();
    load_gettext ();
    admin_user = user_is_admin ();

    regist_inst_gnupg (1);
    regist_inst_winpt (1, &created);

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        get_reg_winpt_prefs (&reg_prefs);
        reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
        if (gnupg_load_config () == -2)
            msg_box (NULL, _("The gpg.conf file contains the 'textmode' option\n"
                             "which leads to broken binary output during decryption.\n"
                             "If this is on purpose, just continue otherwise the option should be disabled."),
                            _("WinPT Error"), MB_ERR);
    }

    if (is_gpg4win_installed ())
        load_gpg_env (); /* XXX: check return code. */

    rc = gnupg_check_homedir ();
    if (rc) {
        char *p;

        log_box (_("WinPT Error"), MB_ERR, 
                 _("GPG home directory is not set correctly.\n"
                   "Please check the GPG registry settings:\n%s."),
                 winpt_strerror (rc));
        s = get_fileopen_dlg (GetActiveWindow (),
                              _("Select GPG Public Keyring"),
                              "GPG Keyrings (*.gpg)\0*.gpg\0\0",
                              NULL);
        if (s != NULL && (p=strrchr (s, '\\'))) {
            char *path = substr (s, 0, (p-s));

            set_reg_entry_gpg ("HomeDir", path);
            free_if_alloc (path);
        }
        else {
            msg_box (NULL, _("GPG home directory could not be determined."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

    rc = check_gnupg_prog ();
    if (rc) {
        if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
                             "Do you want to start the GPG preferences to "
                             "correct  this problem?"), _("WinPT Error"),
                             MB_INFO|MB_YESNO) == IDYES)
            start_gpgprefs = 1;
        else {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }

    rc = gnupg_access_files ();
    if (!start_gpgprefs && rc) {
        if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
            ec = msg_box (NULL,
                _("Could not access and/or find the public and secret keyring.\n"
                  "If this is an accident, quit the program and fix it.\n\n"
                  "Continue if you want WinPT to offer you more choices.\n"),
                  "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES)
                first_start = 1;
        }
        if (!first_start) {
            msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
            return 0;
        }
    }
    if (check_for_empty_keyrings (false))
        first_start = 1;

    if (!first_start) {
        rc = gpg_check_permissions (1);
        if (rc && rc == 2) /* 2 means read-only mode. */
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }
    
    init_gnupg_table ();

    if (fm_parse_command_line (cmdline) > 0) {
        free_gnupg_table ();
        return 0;
    }

    if (cmdline && stristr (cmdline, "--wipe-freespace")) {
        dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
                            GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
                            _("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
        free_gnupg_table ();
        return 0;
    }

    load_keyserver_conf (cmdline? 1 : 0);

    if (cmdline && (stristr (cmdline, "--keymanager")
                || stristr (cmdline, "--cardmanager"))) {
        /* If an instance of WinPT is running, just send the command
           to open the key manager. Otherwise start a new instance. */
        HWND tray = FindWindow ("WinPT", "WinPT");
        if (stristr (cmdline, "keymanager"))
            start_manager = ID_WINPT_KEY;
        else
            start_manager = ID_WINPT_CARD;
        if (tray != NULL) {
            PostMessage (tray, WM_COMMAND, start_manager, 0);
            free_gnupg_table ();
            return 0;
        }
    }

    /* If we found another WinPT instance, just quit to avoid it
       will be executed twice. */
    if (winpt_inst_found) {
        log_debug ("%s", "WinMain: WinPT is already running."); 
        free_gnupg_table ();
        return 0;
    }

#ifndef WINPT_MOBILE
    if (cmdline && (stristr (cmdline, "--enable-debug") || 
                    stristr (cmdline, "--debug"))) {
        gpg_set_debug_mode (1);
        winpt_debug_msg ();
        debug = 1;
    }
#endif

    wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    rc = RegisterClass (&wc);
    if (rc == FALSE) {
        msg_box (NULL, _("Could not register window class"), 
                 _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }

    hwnd = CreateWindow (PGM_NAME, 
                         PGM_NAME, 
                         0, 0, 0, 0, 0, 
                         NULL, 
                         NULL, 
                         hinst, 
                         NULL);
    if (hwnd == NULL) {
        msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
        free_gnupg_table ();
        return 0;
    }
    glob_hwnd = hwnd;
    UpdateWindow (hwnd);

    if (!first_start && !start_gpgprefs) {
        gnupg_backup_options ();        
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    
    if (start_gpgprefs) {
        DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                        gpgprefs_dlg_proc, 0);
        if (check_for_empty_keyrings (true))
            first_start = 1; /* The public keyring is empty. */
    }

    if (first_start) {
        struct genkey_s c;
        int choice;
        HWND h;
start:
        h = GetDesktopWindow ();
        if (!gpg_prefs_ok ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
                            gpgprefs_dlg_proc, 0);
        choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
                                 first_run_dlg_proc, 0);
        switch (choice) {
        case SETUP_KEYGEN:
            c.interactive = 1;
            c.first_start = 1;
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
                                 h, keygen_wizard_dlg_proc, (LPARAM)&c);
            if (!rc)
                goto start;
            break;

        case SETUP_IMPORT:
            rc = gnupg_copy_keyrings ();
            if (rc) {
                msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
                goto start;
            }
            break;

        case SETUP_CARDGEN:
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
                                 h, card_keygen_dlg_proc, 0);
            if (!rc)
                goto start;
            break;

        case 0: /* Cancel/Abort. */
        default:
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        update_keycache (hwnd);
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            keycache_release (1);
            return 0;
        }
        if (!is_gpg4win_installed ()) {
            select_language ();
            load_gettext ();
        }
    }
    else {
        gpg_keycache_t c;
        if (update_keycache (hwnd)) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            keycache_release (1);
            return 0;
        }
        /* XXX: rewrite this part. */
        c = keycache_get_ctx (1);
        if (!gpg_keycache_get_size (c)) {
            msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
                             "Please check your GPG config (keyrings, pathes...)"),
                             _("WinPT Error"), MB_ERR);
            ec = msg_box (NULL, _("It seems that GPG is not configured properly.\n"
                                  "Do you want to start the GPG preferences dialog?"),
                            "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES) {
                DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
                                gpgprefs_dlg_proc, 0);
                update_keycache (hwnd);
            }
            else {
                DestroyWindow (hwnd);
                free_gnupg_table ();
                keycache_release (1);
                return 0;
            }
        }       
        if (check_default_key ()) {
            char *p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR,
                     _("Default key (from the GPG config file) could not be found or is unuseable.\n"
                       "The default key will be resetted and can be set later in the Key Manager again.\n\n"
                       "%s: secret key not found."), p? p : "?");
            set_gnupg_default_key (NULL);
            free_if_alloc (p);
        }
        if (count_insecure_elgkeys ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
                            elgamal_warn_dlg_proc, 0);
    }

    if (start_manager)
        PostMessage (hwnd, WM_COMMAND, start_manager, 0);

    accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
    keyring_check_last_access (); /* init */
    while (GetMessage (&msg, hwnd, 0, 0)) {
        if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
            TranslateMessage (&msg);
            DispatchMessage (&msg);
        }
    }
        
    return 0;
}