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.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);
        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) {
        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.kserv_conf = m_strdup ("keyserver.conf");
372			reg_prefs.no_zip_mmedia = 1;
373			reg_prefs.use_tmpfiles = 1;
374			reg_prefs.word_wrap = 80;
375			reg_prefs.use_viewer = 0; /* XXX */
376			}
377
378
379			/* Main entry point. */
380			int WINAPI
381			WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
382			{
383			WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
384			HACCEL accel_tab;
385	twoaday	121	MSG msg;
386			HWND hwnd = NULL;
387			WORD ver[3], ptdver[4];
388			int rc, ec, created = 0;
389	werner	36	int first_start = 0, start_gpgprefs = 0;
390			int winpt_inst_found = 0;
391	twoaday	121	int start_manager = 0;
392	werner	36	const char *s;
393
394			glob_hinst = hinst;
395	twoaday	87	if (cmdline && stristr (cmdline, "--stop")) {
396			hwnd = FindWindow ("WinPT", "WinPT");
397			if (hwnd != NULL)
398			PostMessage (hwnd, WM_DESTROY, 0, 0);
399			return 0;
400			}
401	twoaday	121
402			/*
403			OSVERSIONINFO osinf;
404			memset (&osinf, 0, sizeof (osinf));
405			if (GetVersionEx (&osinf) &&
406			osinf.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
407			osinf.dwMinorVersion == 0) {
408			msg_box (NULL, "WinPT propably does not work on Windows 95 without restrictions",
409			"WinPT Warning", MB_INFO);
410			}
411			*/
412
413			#ifdef _DEBUG
414	werner	36	gpg_set_debug_mode (1);
415			debug = 1;
416	twoaday	121	#endif
417	werner	36
418	twoaday	121	get_file_version ("WinPT.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
419			get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
420			&ptdver[2], &ptdver[3]);
421			/* XXX
422			if (ptdver[0] != ver[0] \|\| ptdver[1] != ver[1]\|\| ptdver[2] != ver[2]) {
423			log_box (_("WinPT Error"), MB_ERR,
424			_("The PTD.dll file has a different version than WinPT.exe\n"
425			"Please update the PTD.dll to version %d.%d.%d"),
426			ver[0], ver[1], ver[2]);
427			return 0;
428			}
429			*/
430	twoaday	128
431	werner	36	if (gpg_md_selftest ()) {
432			msg_box (NULL, _("Cryptographic selftest failed."),
433			_("WinPT Error"), MB_ERR);
434			return 0;
435			}
436
437	twoaday	137	s = gpgme_check_version (NEED_GPGME_VERSION);
438	werner	36	if (!s \|\| !*s) {
439	twoaday	137	msg_box (NULL, _("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
440	werner	36	_("WinPT Error"), MB_ERR);
441			return 0;
442			}
443
444			CreateMutex (NULL, TRUE, PGM_NAME);
445			if (GetLastError () == ERROR_ALREADY_EXISTS)
446			winpt_inst_found = 1;
447
448			if (cmdline && stristr (cmdline, "--mobile")) {
449			msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
450			"WinPT", MB_INFO);
451			mobile = 1;
452			}
453
454			set_default_kserver ();
455	twoaday	121	load_gettext (winpt_inst_found);
456	werner	36
457			if (!mobile) {
458			regist_inst_gnupg (1);
459			regist_inst_winpt (1, &created);
460			}
461			else {
462			enable_mobile_mode ();
463			/* XXX: ask for GPG path */
464			created = 1; /* Disable registry writing */
465			}
466
467			if (!created) {
468			memset (&reg_prefs, 0, sizeof (reg_prefs));
469			reg_prefs.use_tmpfiles = 1; /* default */
470			reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
471			get_reg_winpt_prefs (&reg_prefs);
472	twoaday	41	gnupg_load_config ();
473	werner	36	}
474
475	twoaday	128	if (is_gpg4win_installed ())
476			load_gpg_env (); /* XXX: check return code. */
477
478	werner	36	rc = gnupg_check_homedir ();
479			if (rc) {
480			log_box (_("WinPT Error"), MB_ERR,
481			_("GPG home directory is not set correctly.\n"
482			"Please check the GPG registry settings:\n%s."),
483			winpt_strerror (rc));
484	werner	48	s = get_fileopen_dlg (GetActiveWindow (),
485	twoaday	121	_("Select GPG Public Keyring"),
486	twoaday	167	"GPG Keyrings (.gpg)\0.gpg\0\0",
487	twoaday	121	NULL);
488	werner	36	if (s != NULL) {
489			size_t n;
490	twoaday	121	char *p = strrchr (s, '\\');
491	werner	36	if (!p)
492			BUG (0);
493			n = p - s;
494			if (n) {
495	twoaday	121	char *file = new char[n+1];
496	werner	36	if (!file)
497			BUG (NULL);
498			memset (file, 0, n);
499			memcpy (file, s, n);
500			file[n] = '\0';
501			set_reg_entry_gpg ("HomeDir", file);
502			free_if_alloc (file);
503			gnupg_check_homedir (); /* change gpgProgram if needed */
504			}
505			}
506			else {
507			msg_box (NULL, _("GPG home directory could not be determited."),
508			_("WinPT Error"), MB_ERR);
509			goto start;
510			}
511			}
512
513			rc = check_gnupg_prog ();
514			if (rc) {
515			if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
516			"Do you want to start the GPG preferences to "
517			"correct this problem?"), _("WinPT Error"),
518			MB_INFO\|MB_YESNO) == IDYES)
519			start_gpgprefs = 1;
520	twoaday	121	else {
521	werner	36	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
522			return 0;
523			}
524			}
525
526			rc = gnupg_access_files ();
527			if (!start_gpgprefs && rc) {
528			if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS) {
529			ec = msg_box (NULL,
530			_("Could not access and/or find the public and secret keyring.\n"
531			"If this is an accident, quit the program and fix it.\n\n"
532			"Continue if you want that WinPT offers you more choices.\n"),
533			"WinPT", MB_INFO\|MB_YESNO);
534			if (ec == IDYES)
535			first_start = 1;
536			}
537			if (!first_start) {
538			msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
539			return 0;
540			}
541			}
542	twoaday	133	if (check_for_empty_keyrings (false))
543			first_start = 1;
544	werner	36
545			if (!first_start) {
546			rc = gpg_check_permissions (1);
547			if (rc && rc == 2)
548			gpg_read_only = 1;
549			else if (rc)
550			return 0;
551			}
552	twoaday	121
553	werner	36	init_gnupg_table ();
554
555	twoaday	121	if (fm_parse_command_line (cmdline) > 0) {
556	werner	36	free_gnupg_table ();
557			return 0;
558			}
559
560			if (cmdline && stristr (cmdline, "--wipe-freespace")) {
561			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
562	twoaday	73	GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
563	werner	36	_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
564			free_gnupg_table ();
565			return 0;
566			}
567
568			load_keyserver_conf (cmdline? 1 : 0);
569
570			if (cmdline && (stristr (cmdline, "--keymanager")
571			\|\| stristr (cmdline, "--cardmanager"))) {
572	twoaday	102	/* If an instance of WinPT is running, just send the command
573			to open the key manager. Otherwise start a new instance.
574			*/
575			HWND tray = FindWindow ("WinPT", "WinPT");
576	twoaday	121	if (stristr (cmdline, "keymanager"))
577			start_manager = ID_WINPT_KEY;
578			else
579			start_manager = ID_WINPT_CARD;
580	twoaday	102	if (tray != NULL) {
581	twoaday	121	PostMessage (tray, WM_COMMAND, start_manager, 0);
582	twoaday	102	free_gnupg_table ();
583			return 0;
584			}
585	werner	36	}
586
587			/* If we found another WinPT instance, just quit to avoid it
588			will be executed twice. */
589			if (winpt_inst_found) {
590			log_debug ("%s", "WinMain: WinPT is already running.");
591			free_gnupg_table ();
592			return 0;
593			}
594
595			if (cmdline) {
596	twoaday	121	if (stristr (cmdline, "--enable-debug") \|\|
597			stristr (cmdline, "--debug")) {
598	werner	36	gpg_set_debug_mode (1);
599			winpt_debug_msg ();
600			debug = 1;
601			}
602			}
603
604			wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
605			rc = RegisterClass (&wc);
606			if (rc == FALSE) {
607			msg_box (NULL, _("Could not register window class"),
608			_("WinPT Error"), MB_ERR);
609			free_gnupg_table ();
610			return 0;
611			}
612
613			hwnd = CreateWindow (PGM_NAME,
614			PGM_NAME,
615			0, 0, 0, 0, 0,
616			NULL,
617			NULL,
618			hinst,
619			NULL);
620			if (hwnd == NULL) {
621			msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
622			free_gnupg_table ();
623			return 0;
624			}
625			glob_hwnd = hwnd;
626			UpdateWindow (hwnd);
627
628			if (!first_start && !start_gpgprefs) {
629			gnupg_backup_options ();
630	twoaday	128	if (!check_crypto_engine ()) {
631	werner	36	DestroyWindow (hwnd);
632			free_gnupg_table ();
633			return 0;
634			}
635			}
636
637			if (start_gpgprefs) {
638			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
639	twoaday	41	gpgprefs_dlg_proc, 0);
640	twoaday	133	if (check_for_empty_keyrings (true))
641			first_start = 1; /* The public keyring is empty! */
642	werner	36	}
643
644			if (first_start) {
645			struct genkey_s c;
646	twoaday	167	int choice;
647	werner	36	HWND h;
648			start:
649			h = GetDesktopWindow ();
650	twoaday	167	if (!gpg_prefs_ok ())
651			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
652	twoaday	41	gpgprefs_dlg_proc, 0);
653	twoaday	167	choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
654			first_run_dlg_proc, 0);
655			switch (choice) {
656	werner	36	case SETUP_KEYGEN:
657			c.interactive = 1;
658			c.first_start = 1;
659			rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
660			h, keygen_wizard_dlg_proc, (LPARAM)&c);
661			if (!rc)
662			goto start;
663			break;
664
665			case SETUP_IMPORT:
666			rc = gnupg_copy_keyrings ();
667			if (rc) {
668			msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
669			goto start;
670			}
671			break;
672
673	twoaday	167	case 0: /* Cancel/Abort. */
674			default:
675	werner	36	DestroyWindow (hwnd);
676			free_gnupg_table ();
677			return 0;
678			}
679			update_keycache (hwnd);
680	twoaday	167	if (!check_crypto_engine ()) {
681			DestroyWindow (hwnd);
682			free_gnupg_table ();
683			return 0;
684			}
685	werner	36	}
686			else {
687	twoaday	174	gpg_keycache_t c, sec_c;
688	werner	36	update_keycache (hwnd);
689			c = keycache_get_ctx (1);
690			if (!c \|\| !gpg_keycache_get_size (c)) {
691			gnupg_display_error ();
692			msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
693			"Please check your GPG config (keyrings, pathes...)"),
694			_("WinPT Error"), MB_ERR);
695			ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
696			"Do you want to start the GPG preferences dialog?"),
697			"WinPT", MB_INFO\|MB_YESNO);
698			if (ec == IDYES) {
699			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
700	twoaday	41	gpgprefs_dlg_proc, 0);
701	werner	36	update_keycache (hwnd);
702			}
703			else {
704			DestroyWindow (hwnd);
705			free_gnupg_table ();
706			return 0;
707			}
708			}
709	twoaday	174	sec_c = keycache_get_ctx (0);
710			if (check_default_key (sec_c)) {
711	twoaday	121	char *p = get_gnupg_default_key ();
712	werner	36	log_box (_("WinPT Error"), MB_ERR,
713	twoaday	174	_("Default key (from the GPG config file) could not be found.\n"
714			"Please check your gpg.conf or set a new default key to correct it:\n\n"
715	werner	36	"%s: public key not found."), p? p : "[null]");
716			free_if_alloc (p);
717			DestroyWindow (hwnd);
718			free_gnupg_table ();
719			return 0;
720			}
721			if (count_insecure_elgkeys ())
722			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
723	twoaday	41	elgamal_warn_dlg_proc, 0);
724	werner	36	}
725
726	twoaday	121	if (start_manager)
727			PostMessage (hwnd, WM_COMMAND, start_manager, 0);
728
729	werner	36	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
730			keyring_check_last_access (); /* init */
731			while (GetMessage (&msg, hwnd, 0, 0)) {
732			if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
733			TranslateMessage (&msg);
734			DispatchMessage (&msg);
735			}
736			}
737
738			return 0;
739			}