trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2006 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
#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);


HINSTANCE glob_hinst;   /* global instance for the dialogs */
HWND glob_hwnd;         /* global window handle for the dialogs */
HWND activ_hwnd;
int scard_support = 0;
int debug = 0;
int mobile_mode_active = 0;
int gpg_read_only = 0;
char gpgver[3];


/* Load the key cache and rebuild the signature cache. */
void
update_keycache (HWND hwnd)
{
    refresh_cache_s rcs = {0};
    rcs.kr_reload = 0; 
    rcs.kr_update = 1;
    rcs.tr_update = 1;
    DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
}


/* 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 (sizeof (tmp)-1, tmp);
        _snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
        putenv (buf);
    }
    else
        putenv ("GPGME_DEBUG=");
}


/* Return the name of the gettext language file. */
static char*
get_gettext_lang (void)
{    
    char *fname;
    fname = get_reg_entry_mo ();
    if (!fname)
        return NULL;
    return fname;
}


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

    nls = get_gettext_lang ();
    if (nls != NULL) {
        set_gettext_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;

    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 (!pkr)
        return -1;
    if (get_file_size (pkr) == 0) {
        free_if_alloc (pkr);
        return -1;
    }
    return 0;
}


/* 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 (gpg_keycache_t kc)
{
    gpgme_key_t key;
    gpgme_error_t err = GPG_ERR_NO_ERROR;
    char *defkey;

    defkey = get_gnupg_default_key ();
    if (defkey)
        err = gpg_keycache_find_key (kc, defkey, 0, &key);
    else
        msg_box (NULL, _("No useable secret key found."), 
                 _("WinPT Error"), MB_ERR);
    free_if_alloc (defkey);
    return err? -1 : 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[512];
    char currdir[256];
    char *cmd = NULL;
    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 == NULL)
            return NULL;
        strncpy (currdir, cmd, sizeof (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,
                 _("Sorry, you need a newer GPG version.\n"
                   "GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
                   ma, mi, pa);
        return false;
    }
    /* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
    if (ma > 1 || pa >= 3)    
        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)
{
    char *buf;
    const char *t;
    int rc;

    /* 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);

    if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
        t = get_prog_part ("keyserver.conf", 0);
    else
        t = "keyserver.conf";
    if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
        //log_box (_("Keyserver"), MB_INFO, 
        //       _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
        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;
}


/* Enable the mobility mode. */
static int
enable_mobile_mode (void)
{
    if (dir_exist_check ("temp") != 0) {
        if (!CreateDirectory ("temp", NULL)) {
            MessageBox (NULL, "Could not create mobile temp directory",
                        "WinPT Mobile Error", MB_ERR);
            return -1;
        }
    }

    memset (&reg_prefs, 0, sizeof (reg_prefs));
    reg_prefs.always_trust = 0;
    reg_prefs.auto_backup = 0;
    reg_prefs.cache_time = 0;
    reg_prefs.expert = 0;
    reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
    reg_prefs.no_zip_mmedia = 1;
    reg_prefs.use_tmpfiles = 1;
    reg_prefs.word_wrap = 80;
    reg_prefs.use_viewer = 0; /* XXX */
    return 0;
}


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 (sizeof temp -1, temp);
    _snprintf (output, sizeof 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);
}


/* 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];
    int rc, ec, created = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    int start_manager = 0;
    const char *s;

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

    /*
    OSVERSIONINFO osinf;
    memset (&osinf, 0, sizeof (osinf));
    if (GetVersionEx (&osinf) && 
        osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
        osinf.dwMinorVersion == 0) {
        msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
                 "WinPT Warning", MB_INFO);
    }
    */

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

    get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
    get_file_version ("PTD.dll", &ptdver[0], &ptdver[1], 
                                 &ptdver[2], &ptdver[3]);
    /* XXX
    if (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;

    if (cmdline && stristr (cmdline, "--mobile")) {
        msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!", 
                 "WinPT", MB_INFO);
        mobile_mode_active = 1;
    }
    
    set_default_keyserver ();
    load_gettext (winpt_inst_found);

    if (!mobile_mode_active) {
        regist_inst_gnupg (1);
        regist_inst_winpt (1, &created);
    }
    else {
        if (enable_mobile_mode ())
            return 0;
        created = 1; /* Disable registry writing */
    }

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        reg_prefs.use_tmpfiles = 1; /* default */
        reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
        get_reg_winpt_prefs (&reg_prefs);
        gnupg_load_config ();
    }

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

    rc = gnupg_check_homedir ();
    if (rc) {
        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) {
            size_t n;
            char *p = strrchr (s, '\\');
            if (!p)
                BUG (0);
            n = p - s;
            if (n) {
                char *file = new char[n+1];
                if (!file)
                    BUG (NULL);
                memset (file, 0, n);
                memcpy (file, s, n);
                file[n] = '\0';         
                set_reg_entry_gpg ("HomeDir", file);
                free_if_alloc (file);
                gnupg_check_homedir (); /* change gpgProgram if needed */
            }
        }
        else {
            msg_box (NULL, _("GPG home directory could not be determited."),
                     _("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 that WinPT offers 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)
            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;
    }

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

    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 0: /* Cancel/Abort. */
        default:
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        update_keycache (hwnd);
        if (!check_crypto_engine ()) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
    }
    else {
        gpg_keycache_t c, sec_c;
        update_keycache (hwnd);
        c = keycache_get_ctx (1);
        if (!c || !gpg_keycache_get_size (c)) {
            gnupg_display_error ();
            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 set 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 ();
                return 0;
            }
        }
        sec_c = keycache_get_ctx (0);
        if (check_default_key (sec_c)) {
            char *p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR, 
                     _("Default key (from the GPG config file) could not be found.\n"
                       "Please check your gpg.conf or set a new default key to correct it:\n\n"
                       "%s: public key not found."), p? p : "[null]");
            free_if_alloc (p);
            DestroyWindow (hwnd);
            free_gnupg_table ();
            return 0;
        }
        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;
}
1	/* WinPT.cpp - Windows Privacy Tray (WinPT)
2	* Copyright (C) 2000-2006 Timo Schulz
3	*
4	* This file is part of WinPT.
5	*
6	* WinPT is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* WinPT is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with WinPT; if not, write to the Free Software Foundation,
18	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	*/
20	#ifdef HAVE_CONFIG_H
21	#include <config.h>
22	#endif
23
24	#include <windows.h>
25	#include <shlobj.h>
26
27	#include "resource.h"
28	#include "wptTypes.h"
29	#include "wptW32API.h"
30	#include "wptVersion.h"
31	#include "wptErrors.h"
32	#include "wptGPG.h"
33	#include "wptRegistry.h"
34	#include "wptCommonCtl.h"
35	#include "wptDlgs.h"
36	#include "wptNLS.h"
37	#include "wptKeyserver.h"
38	#include "wptCard.h"
39	#include "wptFileManager.h"
40	#include "wptContext.h"
41	#include "wptCardEdit.h"
42	#include "wptCrypto.h"
43	#include "wptUTF8.h"
44
45	void remove_crit_file_attrs (const char *fname, int force);
46
47
48	HINSTANCE glob_hinst; /* global instance for the dialogs */
49	HWND glob_hwnd; /* global window handle for the dialogs */
50	HWND activ_hwnd;
51	int scard_support = 0;
52	int debug = 0;
53	int mobile_mode_active = 0;
54	int gpg_read_only = 0;
55	char gpgver[3];
56
57
58	/* Load the key cache and rebuild the signature cache. */
59	void
60	update_keycache (HWND hwnd)
61	{
62	refresh_cache_s rcs = {0};
63	rcs.kr_reload = 0;
64	rcs.kr_update = 1;
65	rcs.tr_update = 1;
66	DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
67	keycache_dlg_proc, (LPARAM)&rcs);
68	}
69
70
71	/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
72	void
73	gpg_set_debug_mode (int val)
74	{
75	static char buf[256];
76	char tmp[128];
77
78	/* XXX: no gpgme.dbg is created. */
79	if (val > 0) {
80	GetTempPath (sizeof (tmp)-1, tmp);
81	_snprintf (buf, sizeof (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
82	putenv (buf);
83	}
84	else
85	putenv ("GPGME_DEBUG=");
86	}
87
88
89	/* Return the name of the gettext language file. */
90	static char*
91	get_gettext_lang (void)
92	{
93	char *fname;
94	fname = get_reg_entry_mo ();
95	if (!fname)
96	return NULL;
97	return fname;
98	}
99
100
101	/* Initialize the gettext sub system. */
102	static void
103	load_gettext (int prev_inst)
104	{
105	char *nls = NULL;
106
107	nls = get_gettext_lang ();
108	if (nls != NULL) {
109	set_gettext_file ("winpt", nls);
110	free_if_alloc (nls);
111	}
112	}
113
114
115	/* Return true if the GPG environment is useable. */
116	static bool
117	gpg_prefs_ok (void)
118	{
119	char *p;
120
121	p = get_reg_entry_gpg4win ("gpg.exe");
122	if (!p \|\| file_exist_check (p) != 0) {
123	free_if_alloc (p);
124	p = get_reg_entry_gpg ("gpgProgram");
125	if (!p \|\| file_exist_check (p) != 0) {
126	free_if_alloc (p);
127	log_debug ("gpg_prefs_ok: could not locate gpg.exe");
128	return false;
129	}
130	}
131	free_if_alloc (p);
132	p = get_reg_entry_gpg4win (NULL);
133	if (!p \|\| dir_exist_check (p) != 0) {
134	free_if_alloc (p);
135	p = get_reg_entry_gpg ("HomeDir");
136	if (!p \|\| dir_exist_check (p) != 0) {
137	free_if_alloc (p);
138	log_debug ("gpg_prefs_ok: could not determine home directory");
139	return false;
140	}
141	}
142	free_if_alloc (p);
143	return true;
144	}
145
146
147	/* Check gpg files if they are read-only and ask the user
148	if this should be corrected. */
149	static void
150	check_readonly_attr (const char *homedir)
151	{
152	const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
153	char *file;
154	int i;
155
156	for (i=0; files[i] != NULL; i++) {
157	file = make_filename (homedir, files[i], NULL);
158	remove_crit_file_attrs (file, 0);
159	free_if_alloc (file);
160	}
161	}
162
163
164	/* Load the GPG environment. On the first start, some
165	checks are performed to find out in what state GPG is.
166	Return value: 0 everything OK.
167	>0 fatal error.
168	-1 public keyring is empty or does not exist. */
169	static int
170	load_gpg_env (void)
171	{
172	SECURITY_ATTRIBUTES sec_attr;
173	char *p;
174	char *pkr;
175
176	p = get_reg_entry_gpg4win ("gpg.exe");
177	if (!p)
178	return (1);
179	if (file_exist_check (p)) {
180	free_if_alloc (p);
181	return (1);
182	}
183	free_if_alloc (p);
184
185	p = get_reg_entry_gpg ("HomeDir");
186	if (!p \|\| dir_exist_check (p) != 0) {
187	free_if_alloc (p);
188	p = multi_gnupg_path (0);
189	}
190	if (p && dir_exist_check (p)) {
191	memset (&sec_attr, 0, sizeof (sec_attr));
192	sec_attr.nLength = sizeof (sec_attr);
193	if (!CreateDirectory (p, &sec_attr)) {
194	msg_box (NULL, _("Could not create GPG home directory"),
195	_("WinPT Error"), MB_ERR);
196	free_if_alloc (p);
197	return (2);
198	}
199	}
200	check_readonly_attr (p);
201	pkr = make_filename (p, "pubring", "gpg");
202	free_if_alloc (p);
203	if (!pkr)
204	return -1;
205	if (get_file_size (pkr) == 0) {
206	free_if_alloc (pkr);
207	return -1;
208	}
209	return 0;
210	}
211
212
213	/* check if the default key from the gpg.conf file is available in the
214	keyring. if not, bail out because encryption won't work properly then. */
215	static int
216	check_default_key (gpg_keycache_t kc)
217	{
218	gpgme_key_t key;
219	gpgme_error_t err = GPG_ERR_NO_ERROR;
220	char *defkey;
221
222	defkey = get_gnupg_default_key ();
223	if (defkey)
224	err = gpg_keycache_find_key (kc, defkey, 0, &key);
225	else
226	msg_box (NULL, _("No useable secret key found."),
227	_("WinPT Error"), MB_ERR);
228	free_if_alloc (defkey);
229	return err? -1 : 0;
230	}
231
232
233	/* Return the WinPT program file name (with full pathname). */
234	static const char*
235	get_prog_part (const char * fname, int use_cwd)
236	{
237	static char program[512];
238	char currdir[256];
239	char *cmd = NULL;
240	int j;
241
242	memset (currdir, 0, DIM (currdir));
243	memset (program, 0, DIM (program));
244
245	if (use_cwd) {
246	GetCurrentDirectory (DIM (currdir)-1, currdir);
247	_snprintf (program, DIM (program)-1, "%s\\%s", currdir, fname);
248	}
249	else {
250	cmd = GetCommandLine ();
251	if (cmd == NULL)
252	return NULL;
253	strncpy (currdir, cmd, sizeof (currdir)-1);
254	j = strlen (currdir);
255	while (j--) {
256	if (currdir[j] == '\\')
257	break;
258	}
259	currdir[j] = 0;
260	_snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
261	}
262	return program;
263	}
264
265
266	/* Check that the underlying crypto engine fullfills the minimal
267	requirements so all commands work properly. */
268	static bool
269	check_crypto_engine (void)
270	{
271	int ma=0, mi=0, pa=0;
272	int rc;
273
274	rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
275	if (rc == -1) {
276	msg_box (NULL, _("Could not read GnuPG version."),
277	_("WinPT Error"), MB_ERR);
278	return false;
279	}
280	else if (rc) {
281	log_box (_("WinPT Error"), MB_ERR,
282	_("Sorry, you need a newer GPG version.\n"
283	"GPG version %d.%d.%d required GPG version "NEED_GPG_VERSION),
284	ma, mi, pa);
285	return false;
286	}
287	/* We enable smartcard support for GPG: >= 2 or >= 1.4.3 */
288	if (ma > 1 \|\| pa >= 3)
289	scard_support = 1;
290
291	gpgver[0] = ma;
292	gpgver[1] = mi;
293	gpgver[2] = pa;
294	return true;
295	}
296
297
298	/* Try to load the keyserver config file. If @quiet is 1
299	do not show any errors. */
300	static int
301	load_keyserver_conf (int quiet)
302	{
303	char *buf;
304	const char *t;
305	int rc;
306
307	/* Create $APPDATA\winpt if needed. */
308	buf = make_special_filename (CSIDL_APPDATA, "winpt", NULL);
309	if (buf && dir_exist_check (buf) && !CreateDirectory (buf, NULL)) {
310	MessageBox (NULL, _("Failed to create WinPT directory"),
311	_("Keyserver"), MB_ERR);
312	free_if_alloc (buf);
313	return -1;
314	}
315	free_if_alloc (buf);
316
317	/* Check for $APPDATA\winpt\keyserver.conf */
318	buf = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
319
320	if (!file_exist_check (get_prog_part ("keyserver.conf", 0)))
321	t = get_prog_part ("keyserver.conf", 0);
322	else
323	t = "keyserver.conf";
324	if (file_exist_check (t) == 0 && file_exist_check (buf) != 0) {
325	//log_box (_("Keyserver"), MB_INFO,
326	// _("keyserver.conf will be copied to \"%s\"\r\n"), buf);
327	if (!CopyFile (t, buf, FALSE)) {
328	MessageBox (NULL, _("Failed to copy the keyserver.conf"),
329	_("Keyserver"), MB_ERR);
330	free_if_alloc (buf);
331	return -1;
332	}
333	t = buf;
334	}
335	else
336	t = buf;
337
338	rc = kserver_load_conf (t);
339	if (rc && !quiet)
340	msg_box (NULL, winpt_strerror (rc), _("Keyserver"), MB_ERR);
341	else {
342	free_if_alloc (reg_prefs.kserv_conf);
343	reg_prefs.kserv_conf = m_strdup (t);
344	}
345	free_if_alloc (buf);
346	return rc;
347	}
348
349
350	/* Check if both keyrings are empty. This indicates that
351	WinPT should offer to generate a key pair. */
352	static bool
353	check_for_empty_keyrings (bool pub_only)
354	{
355	char *p;
356	int n = 0;
357
358	p = get_gnupg_keyring (1, 0);
359	if (file_exist_check (p) == 0 && get_file_size (p) == 0)
360	n++;
361	free_if_alloc (p);
362	if (pub_only)
363	return n == 1? true : false;
364	p = get_gnupg_keyring (0, 0);
365	if (file_exist_check (p) == 0 && get_file_size (p) == 0)
366	n++;
367	free_if_alloc (p);
368	return n==2? true : false;
369	}
370
371
372	/* Enable the mobility mode. */
373	static int
374	enable_mobile_mode (void)
375	{
376	if (dir_exist_check ("temp") != 0) {
377	if (!CreateDirectory ("temp", NULL)) {
378	MessageBox (NULL, "Could not create mobile temp directory",
379	"WinPT Mobile Error", MB_ERR);
380	return -1;
381	}
382	}
383
384	memset (&reg_prefs, 0, sizeof (reg_prefs));
385	reg_prefs.always_trust = 0;
386	reg_prefs.auto_backup = 0;
387	reg_prefs.cache_time = 0;
388	reg_prefs.expert = 0;
389	reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
390	reg_prefs.no_zip_mmedia = 1;
391	reg_prefs.use_tmpfiles = 1;
392	reg_prefs.word_wrap = 80;
393	reg_prefs.use_viewer = 0; /* XXX */
394	return 0;
395	}
396
397
398	void
399	set_default_keyserver (void)
400	{
401	char *host = get_reg_entry_keyserver ("Default");
402	char *str_port = get_reg_entry_keyserver ("Default_Port");
403	WORD port = HKP_PORT;
404
405	if (!host)
406	keyserver_set_default (NULL, 0);
407	else {
408	if (str_port && *str_port)
409	port = atoi (str_port);
410	keyserver_set_default (host, port);
411	}
412	free_if_alloc (host);
413	free_if_alloc (str_port);
414	}
415
416
417	/* Display info message that WinPT is now in debug mode. */
418	void
419	winpt_debug_msg (void)
420	{
421	char output[512];
422	char temp[128];
423
424	GetTempPath (sizeof temp -1, temp);
425	_snprintf (output, sizeof output - 1,
426	"The GPGME output file is %sgpgme.dbg\n"
427	"The WinPT output file is %swinpt.log\n", temp, temp);
428	MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
429	}
430
431
432	/* Main entry point. */
433	int WINAPI
434	WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
435	{
436	WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
437	HACCEL accel_tab;
438	MSG msg;
439	HWND hwnd = NULL;
440	WORD ver[3], ptdver[4];
441	int rc, ec, created = 0;
442	int first_start = 0, start_gpgprefs = 0;
443	int winpt_inst_found = 0;
444	int start_manager = 0;
445	const char *s;
446
447	glob_hinst = hinst;
448	if (cmdline && stristr (cmdline, "--stop")) {
449	hwnd = FindWindow ("WinPT", "WinPT");
450	if (hwnd != NULL)
451	PostMessage (hwnd, WM_DESTROY, 0, 0);
452	return 0;
453	}
454
455	/*
456	OSVERSIONINFO osinf;
457	memset (&osinf, 0, sizeof (osinf));
458	if (GetVersionEx (&osinf) &&
459	osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
460	osinf.dwMinorVersion == 0) {
461	msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
462	"WinPT Warning", MB_INFO);
463	}
464	*/
465
466	#ifdef _DEBUG
467	gpg_set_debug_mode (1);
468	debug = 1;
469	#endif
470
471	get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
472	get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
473	&ptdver[2], &ptdver[3]);
474	/* XXX
475	if (ptdver[0] != ver[0] \|\| ptdver[1] != ver[1]\|\| ptdver[2] != ver[2]) {
476	log_box (_("WinPT Error"), MB_ERR,
477	_("The PTD.dll file has a different version than WinPT.exe\n"
478	"Please update the PTD.dll to version %d.%d.%d"),
479	ver[0], ver[1], ver[2]);
480	return 0;
481	}
482	*/
483
484	if (gpg_md_selftest ()) {
485	msg_box (NULL, _("Cryptographic selftest failed."),
486	_("WinPT Error"), MB_ERR);
487	return 0;
488	}
489
490	s = gpgme_check_version (NEED_GPGME_VERSION);
491	if (!s \|\| !*s) {
492	msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
493	_("WinPT Error"), MB_ERR);
494	return 0;
495	}
496
497	CreateMutex (NULL, TRUE, PGM_NAME);
498	if (GetLastError () == ERROR_ALREADY_EXISTS)
499	winpt_inst_found = 1;
500
501	if (cmdline && stristr (cmdline, "--mobile")) {
502	msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
503	"WinPT", MB_INFO);
504	mobile_mode_active = 1;
505	}
506
507	set_default_keyserver ();
508	load_gettext (winpt_inst_found);
509
510	if (!mobile_mode_active) {
511	regist_inst_gnupg (1);
512	regist_inst_winpt (1, &created);
513	}
514	else {
515	if (enable_mobile_mode ())
516	return 0;
517	created = 1; /* Disable registry writing */
518	}
519
520	if (!created) {
521	memset (&reg_prefs, 0, sizeof (reg_prefs));
522	reg_prefs.use_tmpfiles = 1; /* default */
523	reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
524	get_reg_winpt_prefs (&reg_prefs);
525	gnupg_load_config ();
526	}
527
528	if (is_gpg4win_installed ())
529	load_gpg_env (); /* XXX: check return code. */
530
531	rc = gnupg_check_homedir ();
532	if (rc) {
533	log_box (_("WinPT Error"), MB_ERR,
534	_("GPG home directory is not set correctly.\n"
535	"Please check the GPG registry settings:\n%s."),
536	winpt_strerror (rc));
537	s = get_fileopen_dlg (GetActiveWindow (),
538	_("Select GPG Public Keyring"),
539	"GPG Keyrings (.gpg)\0.gpg\0\0",
540	NULL);
541	if (s != NULL) {
542	size_t n;
543	char *p = strrchr (s, '\\');
544	if (!p)
545	BUG (0);
546	n = p - s;
547	if (n) {
548	char *file = new char[n+1];
549	if (!file)
550	BUG (NULL);
551	memset (file, 0, n);
552	memcpy (file, s, n);
553	file[n] = '\0';
554	set_reg_entry_gpg ("HomeDir", file);
555	free_if_alloc (file);
556	gnupg_check_homedir (); /* change gpgProgram if needed */
557	}
558	}
559	else {
560	msg_box (NULL, _("GPG home directory could not be determited."),
561	_("WinPT Error"), MB_ERR);
562	goto start;
563	}
564	}
565
566	rc = check_gnupg_prog ();
567	if (rc) {
568	if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
569	"Do you want to start the GPG preferences to "
570	"correct this problem?"), _("WinPT Error"),
571	MB_INFO\|MB_YESNO) == IDYES)
572	start_gpgprefs = 1;
573	else {
574	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
575	return 0;
576	}
577	}
578
579	rc = gnupg_access_files ();
580	if (!start_gpgprefs && rc) {
581	if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS) {
582	ec = msg_box (NULL,
583	_("Could not access and/or find the public and secret keyring.\n"
584	"If this is an accident, quit the program and fix it.\n\n"
585	"Continue if you want that WinPT offers you more choices.\n"),
586	"WinPT", MB_INFO\|MB_YESNO);
587	if (ec == IDYES)
588	first_start = 1;
589	}
590	if (!first_start) {
591	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
592	return 0;
593	}
594	}
595	if (check_for_empty_keyrings (false))
596	first_start = 1;
597
598	if (!first_start) {
599	rc = gpg_check_permissions (1);
600	if (rc && rc == 2)
601	gpg_read_only = 1;
602	else if (rc)
603	return 0;
604	}
605
606	init_gnupg_table ();
607
608	if (fm_parse_command_line (cmdline) > 0) {
609	free_gnupg_table ();
610	return 0;
611	}
612
613	if (cmdline && stristr (cmdline, "--wipe-freespace")) {
614	dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
615	GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
616	_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
617	free_gnupg_table ();
618	return 0;
619	}
620
621	load_keyserver_conf (cmdline? 1 : 0);
622
623	if (cmdline && (stristr (cmdline, "--keymanager")
624	\|\| stristr (cmdline, "--cardmanager"))) {
625	/* If an instance of WinPT is running, just send the command
626	to open the key manager. Otherwise start a new instance.
627	*/
628	HWND tray = FindWindow ("WinPT", "WinPT");
629	if (stristr (cmdline, "keymanager"))
630	start_manager = ID_WINPT_KEY;
631	else
632	start_manager = ID_WINPT_CARD;
633	if (tray != NULL) {
634	PostMessage (tray, WM_COMMAND, start_manager, 0);
635	free_gnupg_table ();
636	return 0;
637	}
638	}
639
640	/* If we found another WinPT instance, just quit to avoid it
641	will be executed twice. */
642	if (winpt_inst_found) {
643	log_debug ("%s", "WinMain: WinPT is already running.");
644	free_gnupg_table ();
645	return 0;
646	}
647
648	if (cmdline && (stristr (cmdline, "--enable-debug") \|\|
649	stristr (cmdline, "--debug"))) {
650	gpg_set_debug_mode (1);
651	winpt_debug_msg ();
652	debug = 1;
653	}
654
655	wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
656	rc = RegisterClass (&wc);
657	if (rc == FALSE) {
658	msg_box (NULL, _("Could not register window class"),
659	_("WinPT Error"), MB_ERR);
660	free_gnupg_table ();
661	return 0;
662	}
663
664	hwnd = CreateWindow (PGM_NAME,
665	PGM_NAME,
666	0, 0, 0, 0, 0,
667	NULL,
668	NULL,
669	hinst,
670	NULL);
671	if (hwnd == NULL) {
672	msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
673	free_gnupg_table ();
674	return 0;
675	}
676	glob_hwnd = hwnd;
677	UpdateWindow (hwnd);
678
679	if (!first_start && !start_gpgprefs) {
680	gnupg_backup_options ();
681	if (!check_crypto_engine ()) {
682	DestroyWindow (hwnd);
683	free_gnupg_table ();
684	return 0;
685	}
686	}
687
688	if (start_gpgprefs) {
689	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
690	gpgprefs_dlg_proc, 0);
691	if (check_for_empty_keyrings (true))
692	first_start = 1; /* The public keyring is empty! */
693	}
694
695	if (first_start) {
696	struct genkey_s c;
697	int choice;
698	HWND h;
699	start:
700	h = GetDesktopWindow ();
701	if (!gpg_prefs_ok ())
702	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
703	gpgprefs_dlg_proc, 0);
704	choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
705	first_run_dlg_proc, 0);
706	switch (choice) {
707	case SETUP_KEYGEN:
708	c.interactive = 1;
709	c.first_start = 1;
710	rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
711	h, keygen_wizard_dlg_proc, (LPARAM)&c);
712	if (!rc)
713	goto start;
714	break;
715
716	case SETUP_IMPORT:
717	rc = gnupg_copy_keyrings ();
718	if (rc) {
719	msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
720	goto start;
721	}
722	break;
723
724	case 0: /* Cancel/Abort. */
725	default:
726	DestroyWindow (hwnd);
727	free_gnupg_table ();
728	return 0;
729	}
730	update_keycache (hwnd);
731	if (!check_crypto_engine ()) {
732	DestroyWindow (hwnd);
733	free_gnupg_table ();
734	return 0;
735	}
736	}
737	else {
738	gpg_keycache_t c, sec_c;
739	update_keycache (hwnd);
740	c = keycache_get_ctx (1);
741	if (!c \|\| !gpg_keycache_get_size (c)) {
742	gnupg_display_error ();
743	msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
744	"Please check your GPG config (keyrings, pathes...)"),
745	_("WinPT Error"), MB_ERR);
746	ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
747	"Do you want to start the GPG preferences dialog?"),
748	"WinPT", MB_INFO\|MB_YESNO);
749	if (ec == IDYES) {
750	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
751	gpgprefs_dlg_proc, 0);
752	update_keycache (hwnd);
753	}
754	else {
755	DestroyWindow (hwnd);
756	free_gnupg_table ();
757	return 0;
758	}
759	}
760	sec_c = keycache_get_ctx (0);
761	if (check_default_key (sec_c)) {
762	char *p = get_gnupg_default_key ();
763	log_box (_("WinPT Error"), MB_ERR,
764	_("Default key (from the GPG config file) could not be found.\n"
765	"Please check your gpg.conf or set a new default key to correct it:\n\n"
766	"%s: public key not found."), p? p : "[null]");
767	free_if_alloc (p);
768	DestroyWindow (hwnd);
769	free_gnupg_table ();
770	return 0;
771	}
772	if (count_insecure_elgkeys ())
773	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
774	elgamal_warn_dlg_proc, 0);
775	}
776
777	if (start_manager)
778	PostMessage (hwnd, WM_COMMAND, start_manager, 0);
779
780	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
781	keyring_check_last_access (); /* init */
782	while (GetMessage (&msg, hwnd, 0, 0)) {
783	if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
784	TranslateMessage (&msg);
785	DispatchMessage (&msg);
786	}
787	}
788
789	return 0;
790	}