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"

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 = 0;
int gpg_read_only = 0;
char gpgver[3];


/* Load the key cache and rebuild the signature cache. */
static 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)
{       
    if (val)
        putenv ("GPGME_DEBUG=5:gpgme.dbg");
    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);
            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);
            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 void
enable_mobile_mode (void)
{
    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.keylist_mode = 1;
    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 */
}


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

    set_default_kserver ();
    load_gettext (winpt_inst_found);

    if (!mobile) {
        regist_inst_gnupg (1);
        regist_inst_winpt (1, &created);
    }
    else {
        enable_mobile_mode ();
        /* XXX: ask for GPG path */
        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);
        if (!reg_prefs.no_hotkeys)
            hotkeys_modify ();
        gnupg_load_config ();
    }
    else { /* default settings. */
        reg_prefs.keylist_mode = 1;
    }

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