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);
BOOL user_is_admin (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 mobile_mode_active = 0;
int gpg_read_only = 0;
int admin_user = 0;
char gpgver[3];
/* End */


/* 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);
    /* XXX: the dialog return 0 when an error occurs.
            in this case figure out if the gpg env is OK
            and supress dialogs to configure gpg. */
}


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


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

    /* Return the name of the gettext language file. */
    nls = get_reg_entry_mo ();
    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_error (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 Warning"), MB_WARN);
    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, *conf;
    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);

    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;
}


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


/* 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];*/
    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;
    }

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

    /* XXX
    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]);
    
    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 ();
    admin_user = user_is_admin ();

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