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"


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


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

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