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 ();
    }
    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;
        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	twoaday	168	else { /* default settings. */
459			reg_prefs.keylist_mode = 1;
460			}
461	werner	36
462	twoaday	128	if (is_gpg4win_installed ())
463			load_gpg_env (); /* XXX: check return code. */
464
465	werner	36	rc = gnupg_check_homedir ();
466			if (rc) {
467			log_box (_("WinPT Error"), MB_ERR,
468			_("GPG home directory is not set correctly.\n"
469			"Please check the GPG registry settings:\n%s."),
470			winpt_strerror (rc));
471	werner	48	s = get_fileopen_dlg (GetActiveWindow (),
472	twoaday	121	_("Select GPG Public Keyring"),
473	twoaday	167	"GPG Keyrings (.gpg)\0.gpg\0\0",
474	twoaday	121	NULL);
475	werner	36	if (s != NULL) {
476			size_t n;
477	twoaday	121	char *p = strrchr (s, '\\');
478	werner	36	if (!p)
479			BUG (0);
480			n = p - s;
481			if (n) {
482	twoaday	121	char *file = new char[n+1];
483	werner	36	if (!file)
484			BUG (NULL);
485			memset (file, 0, n);
486			memcpy (file, s, n);
487			file[n] = '\0';
488			set_reg_entry_gpg ("HomeDir", file);
489			free_if_alloc (file);
490			gnupg_check_homedir (); /* change gpgProgram if needed */
491			}
492			}
493			else {
494			msg_box (NULL, _("GPG home directory could not be determited."),
495			_("WinPT Error"), MB_ERR);
496			goto start;
497			}
498			}
499
500			rc = check_gnupg_prog ();
501			if (rc) {
502			if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
503			"Do you want to start the GPG preferences to "
504			"correct this problem?"), _("WinPT Error"),
505			MB_INFO\|MB_YESNO) == IDYES)
506			start_gpgprefs = 1;
507	twoaday	121	else {
508	werner	36	msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
509			return 0;
510			}
511			}
512
513			rc = gnupg_access_files ();
514			if (!start_gpgprefs && rc) {
515			if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS) {
516			ec = msg_box (NULL,
517			_("Could not access and/or find the public and secret keyring.\n"
518			"If this is an accident, quit the program and fix it.\n\n"
519			"Continue if you want that WinPT offers you more choices.\n"),
520			"WinPT", MB_INFO\|MB_YESNO);
521			if (ec == IDYES)
522			first_start = 1;
523			}
524			if (!first_start) {
525			msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
526			return 0;
527			}
528			}
529	twoaday	133	if (check_for_empty_keyrings (false))
530			first_start = 1;
531	werner	36
532			if (!first_start) {
533			rc = gpg_check_permissions (1);
534			if (rc && rc == 2)
535			gpg_read_only = 1;
536			else if (rc)
537			return 0;
538			}
539	twoaday	121
540	werner	36	init_gnupg_table ();
541
542	twoaday	121	if (fm_parse_command_line (cmdline) > 0) {
543	werner	36	free_gnupg_table ();
544			return 0;
545			}
546
547			if (cmdline && stristr (cmdline, "--wipe-freespace")) {
548			dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
549	twoaday	73	GetDesktopWindow(), space_wipefrees_dlg_proc, 0,
550	werner	36	_("Wipe Free Space"), IDS_WINPT_SPACE_SECDEL);
551			free_gnupg_table ();
552			return 0;
553			}
554
555			load_keyserver_conf (cmdline? 1 : 0);
556
557			if (cmdline && (stristr (cmdline, "--keymanager")
558			\|\| stristr (cmdline, "--cardmanager"))) {
559	twoaday	102	/* If an instance of WinPT is running, just send the command
560			to open the key manager. Otherwise start a new instance.
561			*/
562			HWND tray = FindWindow ("WinPT", "WinPT");
563	twoaday	121	if (stristr (cmdline, "keymanager"))
564			start_manager = ID_WINPT_KEY;
565			else
566			start_manager = ID_WINPT_CARD;
567	twoaday	102	if (tray != NULL) {
568	twoaday	121	PostMessage (tray, WM_COMMAND, start_manager, 0);
569	twoaday	102	free_gnupg_table ();
570			return 0;
571			}
572	werner	36	}
573
574			/* If we found another WinPT instance, just quit to avoid it
575			will be executed twice. */
576			if (winpt_inst_found) {
577			log_debug ("%s", "WinMain: WinPT is already running.");
578			free_gnupg_table ();
579			return 0;
580			}
581
582			if (cmdline) {
583	twoaday	121	if (stristr (cmdline, "--enable-debug") \|\|
584			stristr (cmdline, "--debug")) {
585	werner	36	gpg_set_debug_mode (1);
586			winpt_debug_msg ();
587			debug = 1;
588			}
589			}
590
591			wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
592			rc = RegisterClass (&wc);
593			if (rc == FALSE) {
594			msg_box (NULL, _("Could not register window class"),
595			_("WinPT Error"), MB_ERR);
596			free_gnupg_table ();
597			return 0;
598			}
599
600			hwnd = CreateWindow (PGM_NAME,
601			PGM_NAME,
602			0, 0, 0, 0, 0,
603			NULL,
604			NULL,
605			hinst,
606			NULL);
607			if (hwnd == NULL) {
608			msg_box (NULL, _("Could not create window"), _("WinPT Error"), MB_ERR);
609			free_gnupg_table ();
610			return 0;
611			}
612			glob_hwnd = hwnd;
613			UpdateWindow (hwnd);
614
615			if (!first_start && !start_gpgprefs) {
616			gnupg_backup_options ();
617	twoaday	128	if (!check_crypto_engine ()) {
618	werner	36	DestroyWindow (hwnd);
619			free_gnupg_table ();
620			return 0;
621			}
622			}
623
624			if (start_gpgprefs) {
625			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
626	twoaday	41	gpgprefs_dlg_proc, 0);
627	twoaday	133	if (check_for_empty_keyrings (true))
628			first_start = 1; /* The public keyring is empty! */
629	werner	36	}
630
631			if (first_start) {
632			struct genkey_s c;
633	twoaday	167	int choice;
634	werner	36	HWND h;
635			start:
636			h = GetDesktopWindow ();
637	twoaday	167	if (!gpg_prefs_ok ())
638			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
639	twoaday	41	gpgprefs_dlg_proc, 0);
640	twoaday	167	choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
641			first_run_dlg_proc, 0);
642			switch (choice) {
643	werner	36	case SETUP_KEYGEN:
644			c.interactive = 1;
645			c.first_start = 1;
646			rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
647			h, keygen_wizard_dlg_proc, (LPARAM)&c);
648			if (!rc)
649			goto start;
650			break;
651
652			case SETUP_IMPORT:
653			rc = gnupg_copy_keyrings ();
654			if (rc) {
655			msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
656			goto start;
657			}
658			break;
659
660	twoaday	167	case 0: /* Cancel/Abort. */
661			default:
662	werner	36	DestroyWindow (hwnd);
663			free_gnupg_table ();
664			return 0;
665			}
666			update_keycache (hwnd);
667	twoaday	167	if (!check_crypto_engine ()) {
668			DestroyWindow (hwnd);
669			free_gnupg_table ();
670			return 0;
671			}
672	werner	36	}
673			else {
674			gpg_keycache_t c;
675			update_keycache (hwnd);
676			c = keycache_get_ctx (1);
677			if (!c \|\| !gpg_keycache_get_size (c)) {
678			gnupg_display_error ();
679			msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
680			"Please check your GPG config (keyrings, pathes...)"),
681			_("WinPT Error"), MB_ERR);
682			ec = msg_box (NULL, _("It seems that GPG is not set properly.\n"
683			"Do you want to start the GPG preferences dialog?"),
684			"WinPT", MB_INFO\|MB_YESNO);
685			if (ec == IDYES) {
686			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
687	twoaday	41	gpgprefs_dlg_proc, 0);
688	werner	36	update_keycache (hwnd);
689			}
690			else {
691			DestroyWindow (hwnd);
692			free_gnupg_table ();
693			return 0;
694			}
695			}
696			if (check_default_key (c)) {
697	twoaday	121	char *p = get_gnupg_default_key ();
698	werner	36	log_box (_("WinPT Error"), MB_ERR,
699			_("Default key from the GPG options file could not be found.\n"
700			"Please check your gpg.conf (options) to correct this:\n\n"
701			"%s: public key not found."), p? p : "[null]");
702			free_if_alloc (p);
703			DestroyWindow (hwnd);
704			free_gnupg_table ();
705			return 0;
706			}
707			if (count_insecure_elgkeys ())
708			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
709	twoaday	41	elgamal_warn_dlg_proc, 0);
710	werner	36	}
711
712	twoaday	121	if (start_manager)
713			PostMessage (hwnd, WM_COMMAND, start_manager, 0);
714
715	werner	36	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
716			keyring_check_last_access (); /* init */
717			while (GetMessage (&msg, hwnd, 0, 0)) {
718			if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
719			TranslateMessage (&msg);
720			DispatchMessage (&msg);
721			}
722			}
723
724			return 0;
725			}