trunk/Src/WinPT.cpp

/* WinPT.cpp - Windows Privacy Tray (WinPT)
 *      Copyright (C) 2000-2009 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.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <shlobj.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptGPG.h"
#include "wptRegistry.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptNLS.h"
#include "wptKeyserver.h"
#include "wptCard.h"
#include "wptFileManager.h"
#include "wptContext.h"
#include "wptCardEdit.h"
#include "wptCrypto.h"
#include "wptUTF8.h"

void remove_crit_file_attrs (const char *fname, int force);

/* Global variables. */
HINSTANCE glob_hinst;   /* global instance for the dialogs */
HWND glob_hwnd;         /* global window handle for the dialogs */
int scard_support = 0;
int debug = 0;
int gpg_read_only = 0;
int emulate_utf8_bug = 0;
char gpgver[3];
/* End */


/* Load the key cache and rebuild the signature cache. */
int
update_keycache (HWND hwnd)
{
    int err;
    refresh_cache_s rcs;

    /* no need to rebuild the sig cache each time. */
    memset (&rcs, 0, sizeof (rcs));
    rcs.kring_update = 1;
    err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
                    keycache_dlg_proc, (LPARAM)&rcs);
    if (err) {
        char *cfgf = get_gnupg_config ();
        if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
            msg_box (GetDesktopWindow (), 
                     _("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
        free_if_alloc (cfgf);
        return -1;
    }
    return 0;
}


/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
void
gpg_set_debug_mode (int val)
{
    static char buf[MAX_PATH+1];
    char tmp[128];
    
    /* XXX: no gpgme.dbg is created. */
    if (val > 0) {
        GetTempPath (DIM (tmp)-1, tmp);
        _snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
        putenv (buf);
    }
    else
        putenv ("GPGME_DEBUG=");
}


/* Return true if the GPG environment is useable. */
static bool
gpg_prefs_ok (void)
{
    char *p = get_reg_entry_gpg4win ("gpg.exe");
    if (!p || file_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("gpgProgram");
        if (!p || file_exist_check (p) != 0) {
            free_if_alloc (p);
            log_debug ("gpg_prefs_ok: could not locate gpg.exe");
            return false;
        }
    }
    free_if_alloc (p);
    p = get_reg_entry_gpg4win (NULL);
    if (!p || dir_exist_check (p) != 0) {
        free_if_alloc (p);
        p = get_reg_entry_gpg ("HomeDir");
        if (!p || dir_exist_check (p) != 0) {
            free_if_alloc (p);
            log_debug ("gpg_prefs_ok: could not determine home directory");
            return false;
        }
    }
    free_if_alloc (p);
    return true;
}


/* Check gpg files if they are read-only and ask the user
   if this should be corrected. */
static void
check_readonly_attr (const char *homedir)
{
    const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};

    for (int i=0; files[i] != NULL; i++) {
        char *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;
    int err = 0;

    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 (GetDesktopWindow (), 
                     _("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 (get_file_size (pkr) == 0)
        err = -1;
    free_if_alloc (pkr);
    return err;
}


/* 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 (void)
{
    gpgme_key_t key;
    gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
    gpg_keycache_t kc;
    char *defkey;

    kc = keycache_get_ctx (0);
    defkey = get_gnupg_default_key ();
    if (defkey != NULL) {
        err = gpg_keycache_find_key (kc, defkey, 0, &key);
        if (err) {
            free_if_alloc (defkey);
            return -1;
        }
    }
    else {
        /* Actually this is just a warning but we still continue. */
        msg_box (GetDesktopWindow (), _("No useable secret key found."), 
                 _("WinPT Warning"), MB_WARN);
        return 0;
    }

    /* Because the secret key listing has no information
       about the validity/status, we need to check the public key. */
    kc = keycache_get_ctx (1);
    if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
        (key->revoked || key->expired)) {
        msg_box (GetDesktopWindow (), _("Default secret key is unuseable"), 
                 _("WinPT Warning"), MB_ERR);
        free_if_alloc (defkey);
        return -1;
    }
    free_if_alloc (defkey);
    return 0;
}


/* 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 (GetDesktopWindow (), _("Could not read GnuPG version."), 
                 _("WinPT Error"), MB_ERR);
        return false;
    }
    else if (rc) {
        log_box (_("WinPT Error"), MB_ERR,
                 _("A newer GPG version is needed.\n"
                   "Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
                   ma, mi, pa);
        return false;
    }
    
    // TODO: smart card support needs to be revamped
    // and adjusted according to newer OpenPGP cards.
    /*
    if ((ma > 1 || pa >= 4) && pcsc_available ())
        scard_support = 1;
    */
    scard_support = 0;
    
    gpgver[0] = ma;
    gpgver[1] = mi;
    gpgver[2] = pa;
    return true;
}


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

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


/* Display info message that WinPT is now in debug mode. */
void
winpt_debug_msg (void)
{       
    char output[512];
    char temp[MAX_PATH+1];
        
    GetTempPath (DIM (temp) -1, temp);
    _snprintf (output, DIM (output)-1,
        "The GPGME output file is %sgpgme.dbg\n"
        "The WinPT output file is %swinpt.log\n", temp, temp);
    MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
}


/* Search for insecure ElGamal keys and return the
   number of founded keys. */
static int
count_insecure_elgkeys (void)
{
    gpg_keycache_t pc;
    gpgme_key_t key;
    int n;

    n=0;
    pc = keycache_get_ctx (1);
    while (!gpg_keycache_next_key (pc, 0, &key)) {
        if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
            n++;
    }
    gpg_keycache_rewind (pc);
    return n;
}


/* Main entry point. */
int WINAPI
WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
{
    WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
    HACCEL accel_tab;
    MSG msg;
    HWND hwnd = NULL;
    WORD ver[3], ptdver[4];
    OSVERSIONINFOA osver;
    const char *s;
    int rc, ec, created = 0;
    int first_start = 0, start_gpgprefs = 0;
    int winpt_inst_found = 0;
    int start_manager = 0;    

    memset (&osver, 0, sizeof (osver));
    osver.dwOSVersionInfoSize = sizeof (osver);
    if (!GetVersionEx (&osver)) {
        MessageBox (NULL, _("Could not read the OS version."),
                    _("WinPT Error"), MB_ERR);
        return 0;
    }
    /*
    if (osver.dwMajorVersion < 5) {
        MessageBox (NULL, _("WinPT requires Windows XP or higher."),
                    _("WinPT Warning"), MB_INFO);
        return 0;
    }*/
        
    glob_hinst = hinst;
    if (cmdline && stristr (cmdline, "--stop")) {
        hwnd = FindWindow ("WinPT", "WinPT");
        if (hwnd != NULL)
            PostMessage (hwnd, WM_DESTROY, 0, 0);
        return 0;
    }    

    get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
    ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],   
                                 &ptdver[2], &ptdver[3]);
    
    if (!ec && (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 (GetDesktopWindow (), _("Cryptographic selftest failed."),
                 _("WinPT Error"), MB_ERR);
        return 0;
    }

    s = gpgme_check_version (NEED_GPGME_VERSION);
    if (!s || !*s) {
        msg_box (GetDesktopWindow (), 
                 _("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;
    
    gettext_set_user_domain ();

    regist_inst_gnupg (1);
    regist_inst_winpt (1, &created);

    if (!created) {
        memset (&reg_prefs, 0, sizeof (reg_prefs));
        get_reg_winpt_prefs (&reg_prefs);
        reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
        if (gnupg_load_config () == -2)
            msg_box (GetDesktopWindow (), 
                     _("The gpg.conf file contains the 'textmode' option\n"
                       "which leads to broken binary output during decryption.\n"
                       "If this is on purpose, just continue otherwise the option should be disabled."),
                     _("WinPT Error"), MB_ERR);
    }

    if (is_gpg4win_installed ())
        load_gpg_env (); /* TODO: check return code. */

    rc = gnupg_check_homedir ();
    if (rc) {
        char *p;

        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 && (p=strrchr (s, '\\'))) {
            char *path = substr (s, 0, (p-s));

            set_reg_entry_gpg ("HomeDir", path);
            free_if_alloc (path);
        }
        else {
            msg_box (GetDesktopWindow (), 
                     _("GPG home directory could not be determined."),
                     _("WinPT Error"), MB_ERR);
            goto start;
        }
    }

    rc = check_gnupg_prog ();
    if (rc) {
        if (msg_box (GetDesktopWindow (), 
                     _("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 (GetDesktopWindow (), 
                     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 (GetDesktopWindow (),
                _("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 WinPT to offer you more choices.\n"),
                  "WinPT", MB_INFO|MB_YESNO);
            if (ec == IDYES)
                first_start = 1;
        }
        if (!first_start) {
            msg_box (GetDesktopWindow (), 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) /* 2 means read-only mode. */
            gpg_read_only = 1;
        else if (rc)
            return 0;
    }
    
    init_gnupg_table ();

    if (fm_parse_command_line (cmdline) > 0) {
        free_gnupg_table ();
        return 0;
    }

    rc = kserver_load_conf ();
    if (rc)
        msg_box (GetDesktopWindow (), winpt_strerror (rc), 
                 _("Keyserver"), MB_ERR);

    if (cmdline && (stristr (cmdline, "--keymanager")
                || stristr (cmdline, "--cardmanager"))) {
        /* If an instance of WinPT is running, just send the command
           to open the key manager. Otherwise start a new instance. */
        HWND tray = FindWindow ("WinPT", "WinPT");
        if (stristr (cmdline, "keymanager"))
            start_manager = ID_WINPT_KEY;
        else
            start_manager = ID_WINPT_CARD;
        if (tray != NULL) {
            PostMessage (tray, WM_COMMAND, start_manager, 0);
            free_gnupg_table ();
            return 0;
        }
    }

    /* If we found another WinPT instance, just quit to avoid it
       will be executed twice. */
    if (winpt_inst_found) {
        log_debug ("%s", "WinMain: WinPT is already running."); 
        free_gnupg_table ();
        return 0;
    }

    if (cmdline && (stristr (cmdline, "--enable-debug") || 
                    stristr (cmdline, "--debug"))) {
        gpg_set_debug_mode (1);
        winpt_debug_msg ();
        debug = 1;
    }

    wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    rc = RegisterClass (&wc);
    if (rc == FALSE) {
        msg_box (GetDesktopWindow (), 
                 _("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 (GetDesktopWindow (), 
                 _("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 SETUP_CARDGEN:
            rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
                                 h, card_keygen_dlg_proc, 0);
            if (!rc)
                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 ();
            keycache_release (1);
            return 0;
        }
    }
    else {
        gpg_keycache_t c;
        if (update_keycache (hwnd)) {
            DestroyWindow (hwnd);
            free_gnupg_table ();
            keycache_release (1);
            return 0;
        }
        /* XXX: rewrite this part. */
        c = keycache_get_ctx (1);
        if (!gpg_keycache_get_size (c)) {
            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 (GetDesktopWindow (), 
                          _("It seems that GPG is not configured 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 ();
                keycache_release (1);
                return 0;
            }
        }       
        if (check_default_key ()) {
            char *p = get_gnupg_default_key ();
            log_box (_("WinPT Error"), MB_ERR,
                     _("Default key (from the GPG config file) could not be found or is unuseable.\n"
                       "The default key will be resetted and can be set later in the Key Manager again.\n\n"
                       "%s: secret key not found."), p? p : "?");
            set_gnupg_default_key (NULL);
            free_if_alloc (p);
        }
        if (count_insecure_elgkeys ())
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
                            elgamal_warn_dlg_proc, 0);
    }
   
    if (strstr (cmdline, "--emulate-utf8-bug")) {
        MessageBox (NULL, "Please use this mode only for resetting your passphrase to a non-utf8 form.",
                    "WinPT Warning", MB_WARN);
        emulate_utf8_bug = 1;
    }
    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	328	* Copyright (C) 2000-2009 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	werner	42	#ifdef HAVE_CONFIG_H
17			#include <config.h>
18			#endif
19
20	werner	36	#include <windows.h>
21	twoaday	154	#include <shlobj.h>
22	werner	36
23	werner	47	#include "resource.h"
24	werner	36	#include "wptTypes.h"
25			#include "wptW32API.h"
26			#include "wptVersion.h"
27			#include "wptErrors.h"
28			#include "wptGPG.h"
29			#include "wptRegistry.h"
30			#include "wptCommonCtl.h"
31			#include "wptDlgs.h"
32			#include "wptNLS.h"
33			#include "wptKeyserver.h"
34			#include "wptCard.h"
35			#include "wptFileManager.h"
36			#include "wptContext.h"
37			#include "wptCardEdit.h"
38	werner	48	#include "wptCrypto.h"
39	twoaday	190	#include "wptUTF8.h"
40	werner	36
41	twoaday	172	void remove_crit_file_attrs (const char *fname, int force);
42	twoaday	154
43	twoaday	208	/* Global variables. */
44	werner	36	HINSTANCE glob_hinst; /* global instance for the dialogs */
45			HWND glob_hwnd; /* global window handle for the dialogs */
46			int scard_support = 0;
47			int debug = 0;
48			int gpg_read_only = 0;
49	twoaday	328	int emulate_utf8_bug = 0;
50	werner	36	char gpgver[3];
51	twoaday	208	/* End */
52	werner	36
53
54			/* Load the key cache and rebuild the signature cache. */
55	twoaday	255	int
56	werner	36	update_keycache (HWND hwnd)
57			{
58	twoaday	255	int err;
59	twoaday	273	refresh_cache_s rcs;
60	twoaday	255
61	twoaday	273	/* no need to rebuild the sig cache each time. */
62			memset (&rcs, 0, sizeof (rcs));
63			rcs.kring_update = 1;
64	twoaday	255	err = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
65	werner	36	keycache_dlg_proc, (LPARAM)&rcs);
66	twoaday	255	if (err) {
67	twoaday	270	char *cfgf = get_gnupg_config ();
68			if (cfgf && check_gnupg_options (cfgf, 0) == WPTERR_FILE_EXIST)
69	twoaday	328	msg_box (GetDesktopWindow (),
70			_("The gpg.conf contains at least one argument which points to a non-existing file."), "WinPT", MB_ERR);
71	twoaday	270	free_if_alloc (cfgf);
72	twoaday	255	return -1;
73			}
74			return 0;
75	werner	36	}
76
77
78			/* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
79			void
80			gpg_set_debug_mode (int val)
81	twoaday	181	{
82	twoaday	328	static char buf[MAX_PATH+1];
83	twoaday	190	char tmp[128];
84
85			/* XXX: no gpgme.dbg is created. */
86			if (val > 0) {
87	twoaday	271	GetTempPath (DIM (tmp)-1, tmp);
88			_snprintf (buf, DIM (buf)-1, "GPGME_DEBUG=5:%sgpgme.dbg", tmp);
89	twoaday	190	putenv (buf);
90			}
91	werner	36	else
92			putenv ("GPGME_DEBUG=");
93			}
94
95
96	twoaday	167	/* Return true if the GPG environment is useable. */
97			static bool
98			gpg_prefs_ok (void)
99			{
100	twoaday	328	char *p = get_reg_entry_gpg4win ("gpg.exe");
101	twoaday	167	if (!p \|\| file_exist_check (p) != 0) {
102			free_if_alloc (p);
103			p = get_reg_entry_gpg ("gpgProgram");
104			if (!p \|\| file_exist_check (p) != 0) {
105			free_if_alloc (p);
106	twoaday	190	log_debug ("gpg_prefs_ok: could not locate gpg.exe");
107	twoaday	167	return false;
108			}
109			}
110			free_if_alloc (p);
111	twoaday	270	p = get_reg_entry_gpg4win (NULL);
112	twoaday	167	if (!p \|\| dir_exist_check (p) != 0) {
113			free_if_alloc (p);
114			p = get_reg_entry_gpg ("HomeDir");
115			if (!p \|\| dir_exist_check (p) != 0) {
116			free_if_alloc (p);
117	twoaday	190	log_debug ("gpg_prefs_ok: could not determine home directory");
118	twoaday	167	return false;
119			}
120			}
121			free_if_alloc (p);
122			return true;
123			}
124
125
126	twoaday	172	/* Check gpg files if they are read-only and ask the user
127			if this should be corrected. */
128			static void
129			check_readonly_attr (const char *homedir)
130			{
131			const char *files[] = {"pubring.gpg", "secring.gpg", "trustdb.gpg", NULL};
132	twoaday	167
133	twoaday	328	for (int i=0; files[i] != NULL; i++) {
134			char *file = make_filename (homedir, files[i], NULL);
135	twoaday	172	remove_crit_file_attrs (file, 0);
136			free_if_alloc (file);
137			}
138			}
139
140
141	twoaday	128	/* Load the GPG environment. On the first start, some
142			checks are performed to find out in what state GPG is.
143			Return value: 0 everything OK.
144			>0 fatal error.
145			-1 public keyring is empty or does not exist. */
146			static int
147			load_gpg_env (void)
148			{
149			SECURITY_ATTRIBUTES sec_attr;
150			char *p;
151			char *pkr;
152	twoaday	270	int err = 0;
153	twoaday	128
154			p = get_reg_entry_gpg4win ("gpg.exe");
155			if (!p)
156			return (1);
157			if (file_exist_check (p)) {
158			free_if_alloc (p);
159			return (1);
160			}
161			free_if_alloc (p);
162	twoaday	167
163			p = get_reg_entry_gpg ("HomeDir");
164			if (!p \|\| dir_exist_check (p) != 0) {
165			free_if_alloc (p);
166			p = multi_gnupg_path (0);
167			}
168	twoaday	128	if (p && dir_exist_check (p)) {
169			memset (&sec_attr, 0, sizeof (sec_attr));
170			sec_attr.nLength = sizeof (sec_attr);
171			if (!CreateDirectory (p, &sec_attr)) {
172	twoaday	328	msg_box (GetDesktopWindow (),
173			_("Could not create GPG home directory"),
174	twoaday	128	_("WinPT Error"), MB_ERR);
175			free_if_alloc (p);
176			return (2);
177			}
178			}
179	twoaday	172	check_readonly_attr (p);
180	twoaday	128	pkr = make_filename (p, "pubring", "gpg");
181			free_if_alloc (p);
182	twoaday	270	if (get_file_size (pkr) == 0)
183			err = -1;
184			free_if_alloc (pkr);
185			return err;
186	twoaday	128	}
187
188	twoaday	133
189	werner	36	/* check if the default key from the gpg.conf file is available in the
190			keyring. if not, bail out because encryption won't work properly then. */
191			static int
192	twoaday	273	check_default_key (void)
193	werner	36	{
194			gpgme_key_t key;
195	twoaday	193	gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
196	twoaday	273	gpg_keycache_t kc;
197	twoaday	128	char *defkey;
198	werner	36
199	twoaday	273	kc = keycache_get_ctx (0);
200	werner	36	defkey = get_gnupg_default_key ();
201	twoaday	328	if (defkey != NULL) {
202	werner	36	err = gpg_keycache_find_key (kc, defkey, 0, &key);
203	twoaday	273	if (err) {
204			free_if_alloc (defkey);
205			return -1;
206			}
207			}
208			else {
209			/* Actually this is just a warning but we still continue. */
210	twoaday	328	msg_box (GetDesktopWindow (), _("No useable secret key found."),
211	twoaday	217	_("WinPT Warning"), MB_WARN);
212	twoaday	273	return 0;
213			}
214
215			/* Because the secret key listing has no information
216			about the validity/status, we need to check the public key. */
217			kc = keycache_get_ctx (1);
218			if (!gpg_keycache_find_key (kc, defkey, 0, &key) &&
219			(key->revoked \|\| key->expired)) {
220	twoaday	328	msg_box (GetDesktopWindow (), _("Default secret key is unuseable"),
221	twoaday	273	_("WinPT Warning"), MB_ERR);
222			free_if_alloc (defkey);
223			return -1;
224			}
225	werner	36	free_if_alloc (defkey);
226	twoaday	273	return 0;
227	werner	36	}
228
229
230			/* Check that the underlying crypto engine fullfills the minimal
231			requirements so all commands work properly. */
232	twoaday	128	static bool
233	werner	36	check_crypto_engine (void)
234			{
235	twoaday	193	int ma = 0, mi = 0, pa = 0;
236	werner	36	int rc;
237
238	twoaday	137	rc = check_gnupg_engine (NEED_GPG_VERSION, &ma, &mi, &pa);
239	werner	36	if (rc == -1) {
240	twoaday	328	msg_box (GetDesktopWindow (), _("Could not read GnuPG version."),
241	werner	36	_("WinPT Error"), MB_ERR);
242	twoaday	128	return false;
243	werner	36	}
244			else if (rc) {
245			log_box (_("WinPT Error"), MB_ERR,
246	twoaday	278	_("A newer GPG version is needed.\n"
247			"Current GPG version %d.%d.%d, required "NEED_GPG_VERSION),
248	werner	36	ma, mi, pa);
249	twoaday	128	return false;
250	werner	36	}
251	twoaday	328
252			// TODO: smart card support needs to be revamped
253			// and adjusted according to newer OpenPGP cards.
254			/*
255	twoaday	262	if ((ma > 1 \|\| pa >= 4) && pcsc_available ())
256	werner	36	scard_support = 1;
257	twoaday	328	*/
258			scard_support = 0;
259
260	werner	36	gpgver[0] = ma;
261			gpgver[1] = mi;
262			gpgver[2] = pa;
263	twoaday	128	return true;
264	werner	36	}
265
266
267
268	twoaday	133	/* Check if both keyrings are empty. This indicates that
269			WinPT should offer to generate a key pair. */
270			static bool
271			check_for_empty_keyrings (bool pub_only)
272			{
273			char *p;
274	twoaday	328	int n;
275	twoaday	133
276	twoaday	328	n=0;
277	twoaday	133	p = get_gnupg_keyring (1, 0);
278			if (file_exist_check (p) == 0 && get_file_size (p) == 0)
279			n++;
280			free_if_alloc (p);
281			if (pub_only)
282			return n == 1? true : false;
283			p = get_gnupg_keyring (0, 0);
284			if (file_exist_check (p) == 0 && get_file_size (p) == 0)
285			n++;
286			free_if_alloc (p);
287			return n==2? true : false;
288			}
289
290
291	twoaday	271
292	twoaday	190	/* Display info message that WinPT is now in debug mode. */
293			void
294			winpt_debug_msg (void)
295			{
296			char output[512];
297	twoaday	328	char temp[MAX_PATH+1];
298	twoaday	190
299	twoaday	271	GetTempPath (DIM (temp) -1, temp);
300			_snprintf (output, DIM (output)-1,
301	twoaday	190	"The GPGME output file is %sgpgme.dbg\n"
302			"The WinPT output file is %swinpt.log\n", temp, temp);
303			MessageBox (NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO);
304			}
305
306
307	twoaday	217	/* Search for insecure ElGamal keys and return the
308			number of founded keys. */
309			static int
310			count_insecure_elgkeys (void)
311			{
312			gpg_keycache_t pc;
313			gpgme_key_t key;
314	twoaday	328	int n;
315	twoaday	208
316	twoaday	328	n=0;
317	twoaday	217	pc = keycache_get_ctx (1);
318			while (!gpg_keycache_next_key (pc, 0, &key)) {
319			if (key->subkeys->pubkey_algo == GPGME_PK_ELG)
320			n++;
321			}
322			gpg_keycache_rewind (pc);
323			return n;
324			}
325
326
327	werner	36	/* Main entry point. */
328			int WINAPI
329			WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
330			{
331			WNDCLASS wc = {0, winpt_main_proc, 0, 0, hinst, 0, 0, 0, 0, PGM_NAME};
332			HACCEL accel_tab;
333	twoaday	121	MSG msg;
334			HWND hwnd = NULL;
335	twoaday	248	WORD ver[3], ptdver[4];
336	twoaday	328	OSVERSIONINFOA osver;
337	twoaday	248	const char *s;
338	twoaday	121	int rc, ec, created = 0;
339	werner	36	int first_start = 0, start_gpgprefs = 0;
340			int winpt_inst_found = 0;
341	twoaday	248	int start_manager = 0;
342	werner	36
343	twoaday	328	memset (&osver, 0, sizeof (osver));
344			osver.dwOSVersionInfoSize = sizeof (osver);
345			if (!GetVersionEx (&osver)) {
346			MessageBox (NULL, _("Could not read the OS version."),
347			_("WinPT Error"), MB_ERR);
348	twoaday	271	return 0;
349	twoaday	328	}
350			/*
351			if (osver.dwMajorVersion < 5) {
352			MessageBox (NULL, _("WinPT requires Windows XP or higher."),
353			_("WinPT Warning"), MB_INFO);
354			return 0;
355			}*/
356
357	werner	36	glob_hinst = hinst;
358	twoaday	87	if (cmdline && stristr (cmdline, "--stop")) {
359			hwnd = FindWindow ("WinPT", "WinPT");
360			if (hwnd != NULL)
361			PostMessage (hwnd, WM_DESTROY, 0, 0);
362			return 0;
363	twoaday	328	}
364	twoaday	121
365	twoaday	328	get_file_version ("winpt.exe", &ver[0], &ver[1], &ver[2], &ver[3]);
366	twoaday	271	ec = get_file_version ("PTD.dll", &ptdver[0], &ptdver[1],
367	twoaday	121	&ptdver[2], &ptdver[3]);
368	twoaday	193
369	twoaday	270	if (!ec && (ptdver[0] != ver[0] \|\|
370			ptdver[1] != ver[1] \|\|
371			ptdver[2] != ver[2])) {
372	twoaday	121	log_box (_("WinPT Error"), MB_ERR,
373			_("The PTD.dll file has a different version than WinPT.exe\n"
374			"Please update the PTD.dll to version %d.%d.%d"),
375			ver[0], ver[1], ver[2]);
376			return 0;
377			}
378	twoaday	128
379	werner	36	if (gpg_md_selftest ()) {
380	twoaday	328	msg_box (GetDesktopWindow (), _("Cryptographic selftest failed."),
381	werner	36	_("WinPT Error"), MB_ERR);
382			return 0;
383			}
384
385	twoaday	137	s = gpgme_check_version (NEED_GPGME_VERSION);
386	werner	36	if (!s \|\| !*s) {
387	twoaday	328	msg_box (GetDesktopWindow (),
388			_("A newer GPGME version is needed; at least "NEED_GPGME_VERSION),
389	werner	36	_("WinPT Error"), MB_ERR);
390			return 0;
391			}
392
393			CreateMutex (NULL, TRUE, PGM_NAME);
394			if (GetLastError () == ERROR_ALREADY_EXISTS)
395			winpt_inst_found = 1;
396	twoaday	190
397	twoaday	328	gettext_set_user_domain ();
398	werner	36
399	twoaday	271	regist_inst_gnupg (1);
400			regist_inst_winpt (1, &created);
401	werner	36
402			if (!created) {
403			memset (&reg_prefs, 0, sizeof (reg_prefs));
404	twoaday	271	get_reg_winpt_prefs (&reg_prefs);
405	twoaday	328	reg_prefs.fm.progress = 0; /* TODO: fix the bug and enable it again */
406	twoaday	273	if (gnupg_load_config () == -2)
407	twoaday	328	msg_box (GetDesktopWindow (),
408			_("The gpg.conf file contains the 'textmode' option\n"
409			"which leads to broken binary output during decryption.\n"
410			"If this is on purpose, just continue otherwise the option should be disabled."),
411			_("WinPT Error"), MB_ERR);
412	werner	36	}
413
414	twoaday	128	if (is_gpg4win_installed ())
415	twoaday	328	load_gpg_env (); /* TODO: check return code. */
416	twoaday	128
417	werner	36	rc = gnupg_check_homedir ();
418			if (rc) {
419	twoaday	271	char *p;
420
421	werner	36	log_box (_("WinPT Error"), MB_ERR,
422			_("GPG home directory is not set correctly.\n"
423			"Please check the GPG registry settings:\n%s."),
424			winpt_strerror (rc));
425	werner	48	s = get_fileopen_dlg (GetActiveWindow (),
426	twoaday	121	_("Select GPG Public Keyring"),
427	twoaday	167	"GPG Keyrings (.gpg)\0.gpg\0\0",
428	twoaday	121	NULL);
429	twoaday	271	if (s != NULL && (p=strrchr (s, '\\'))) {
430			char *path = substr (s, 0, (p-s));
431
432			set_reg_entry_gpg ("HomeDir", path);
433			free_if_alloc (path);
434	werner	36	}
435			else {
436	twoaday	328	msg_box (GetDesktopWindow (),
437			_("GPG home directory could not be determined."),
438	werner	36	_("WinPT Error"), MB_ERR);
439			goto start;
440			}
441			}
442
443			rc = check_gnupg_prog ();
444			if (rc) {
445	twoaday	328	if (msg_box (GetDesktopWindow (),
446			_("Could not find the GPG binary (gpg.exe).\n"
447			"Do you want to start the GPG preferences to "
448			"correct this problem?"), _("WinPT Error"),
449			MB_INFO\|MB_YESNO) == IDYES)
450	werner	36	start_gpgprefs = 1;
451	twoaday	121	else {
452	twoaday	328	msg_box (GetDesktopWindow (),
453			winpt_strerror (rc), _("WinPT Error"), MB_ERR);
454	werner	36	return 0;
455			}
456			}
457
458			rc = gnupg_access_files ();
459			if (!start_gpgprefs && rc) {
460			if (rc == WPTERR_GPG_KEYRINGS \|\| rc == WPTERR_GPG_OPT_KEYRINGS) {
461	twoaday	328	ec = msg_box (GetDesktopWindow (),
462	werner	36	_("Could not access and/or find the public and secret keyring.\n"
463			"If this is an accident, quit the program and fix it.\n\n"
464	twoaday	248	"Continue if you want WinPT to offer you more choices.\n"),
465	werner	36	"WinPT", MB_INFO\|MB_YESNO);
466			if (ec == IDYES)
467			first_start = 1;
468			}
469			if (!first_start) {
470	twoaday	328	msg_box (GetDesktopWindow (), winpt_strerror (rc), _("WinPT Error"), MB_ERR);
471	werner	36	return 0;
472			}
473			}
474	twoaday	133	if (check_for_empty_keyrings (false))
475			first_start = 1;
476	werner	36
477			if (!first_start) {
478			rc = gpg_check_permissions (1);
479	twoaday	271	if (rc && rc == 2) /* 2 means read-only mode. */
480	werner	36	gpg_read_only = 1;
481			else if (rc)
482			return 0;
483			}
484	twoaday	121
485	werner	36	init_gnupg_table ();
486
487	twoaday	121	if (fm_parse_command_line (cmdline) > 0) {
488	werner	36	free_gnupg_table ();
489			return 0;
490			}
491
492	twoaday	328	rc = kserver_load_conf ();
493			if (rc)
494			msg_box (GetDesktopWindow (), winpt_strerror (rc),
495			_("Keyserver"), MB_ERR);
496	werner	36
497			if (cmdline && (stristr (cmdline, "--keymanager")
498			\|\| stristr (cmdline, "--cardmanager"))) {
499	twoaday	102	/* If an instance of WinPT is running, just send the command
500	twoaday	270	to open the key manager. Otherwise start a new instance. */
501	twoaday	102	HWND tray = FindWindow ("WinPT", "WinPT");
502	twoaday	121	if (stristr (cmdline, "keymanager"))
503			start_manager = ID_WINPT_KEY;
504			else
505			start_manager = ID_WINPT_CARD;
506	twoaday	102	if (tray != NULL) {
507	twoaday	121	PostMessage (tray, WM_COMMAND, start_manager, 0);
508	twoaday	102	free_gnupg_table ();
509			return 0;
510			}
511	werner	36	}
512
513			/* If we found another WinPT instance, just quit to avoid it
514			will be executed twice. */
515			if (winpt_inst_found) {
516			log_debug ("%s", "WinMain: WinPT is already running.");
517			free_gnupg_table ();
518			return 0;
519			}
520
521	twoaday	190	if (cmdline && (stristr (cmdline, "--enable-debug") \|\|
522			stristr (cmdline, "--debug"))) {
523			gpg_set_debug_mode (1);
524			winpt_debug_msg ();
525			debug = 1;
526	werner	36	}
527
528			wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
529			rc = RegisterClass (&wc);
530			if (rc == FALSE) {
531	twoaday	328	msg_box (GetDesktopWindow (),
532			_("Could not register window class"),
533	werner	36	_("WinPT Error"), MB_ERR);
534			free_gnupg_table ();
535			return 0;
536			}
537
538			hwnd = CreateWindow (PGM_NAME,
539			PGM_NAME,
540			0, 0, 0, 0, 0,
541			NULL,
542			NULL,
543			hinst,
544			NULL);
545			if (hwnd == NULL) {
546	twoaday	328	msg_box (GetDesktopWindow (),
547			_("Could not create window"),
548			_("WinPT Error"), MB_ERR);
549	werner	36	free_gnupg_table ();
550			return 0;
551			}
552			glob_hwnd = hwnd;
553			UpdateWindow (hwnd);
554
555			if (!first_start && !start_gpgprefs) {
556			gnupg_backup_options ();
557	twoaday	128	if (!check_crypto_engine ()) {
558	werner	36	DestroyWindow (hwnd);
559			free_gnupg_table ();
560			return 0;
561			}
562			}
563
564			if (start_gpgprefs) {
565			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
566	twoaday	41	gpgprefs_dlg_proc, 0);
567	twoaday	133	if (check_for_empty_keyrings (true))
568	twoaday	271	first_start = 1; /* The public keyring is empty. */
569	werner	36	}
570
571			if (first_start) {
572			struct genkey_s c;
573	twoaday	167	int choice;
574	werner	36	HWND h;
575			start:
576			h = GetDesktopWindow ();
577	twoaday	167	if (!gpg_prefs_ok ())
578			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
579	twoaday	41	gpgprefs_dlg_proc, 0);
580	twoaday	167	choice = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
581			first_run_dlg_proc, 0);
582			switch (choice) {
583	werner	36	case SETUP_KEYGEN:
584			c.interactive = 1;
585			c.first_start = 1;
586			rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
587			h, keygen_wizard_dlg_proc, (LPARAM)&c);
588			if (!rc)
589			goto start;
590			break;
591
592			case SETUP_IMPORT:
593			rc = gnupg_copy_keyrings ();
594			if (rc) {
595			msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
596			goto start;
597			}
598			break;
599
600	twoaday	260	case SETUP_CARDGEN:
601			rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN,
602			h, card_keygen_dlg_proc, 0);
603			if (!rc)
604			goto start;
605			break;
606
607	twoaday	167	case 0: /* Cancel/Abort. */
608			default:
609	werner	36	DestroyWindow (hwnd);
610			free_gnupg_table ();
611			return 0;
612			}
613			update_keycache (hwnd);
614	twoaday	167	if (!check_crypto_engine ()) {
615			DestroyWindow (hwnd);
616			free_gnupg_table ();
617	twoaday	255	keycache_release (1);
618	twoaday	167	return 0;
619			}
620	werner	36	}
621			else {
622	twoaday	273	gpg_keycache_t c;
623	twoaday	255	if (update_keycache (hwnd)) {
624			DestroyWindow (hwnd);
625			free_gnupg_table ();
626			keycache_release (1);
627			return 0;
628			}
629	twoaday	271	/* XXX: rewrite this part. */
630	werner	36	c = keycache_get_ctx (1);
631	twoaday	255	if (!gpg_keycache_get_size (c)) {
632	werner	36	msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
633			"Please check your GPG config (keyrings, pathes...)"),
634			_("WinPT Error"), MB_ERR);
635	twoaday	328	ec = msg_box (GetDesktopWindow (),
636			_("It seems that GPG is not configured properly.\n"
637			"Do you want to start the GPG preferences dialog?"),
638			"WinPT", MB_INFO\|MB_YESNO);
639	werner	36	if (ec == IDYES) {
640			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
641	twoaday	41	gpgprefs_dlg_proc, 0);
642	werner	36	update_keycache (hwnd);
643			}
644			else {
645			DestroyWindow (hwnd);
646			free_gnupg_table ();
647	twoaday	255	keycache_release (1);
648	werner	36	return 0;
649			}
650	twoaday	273	}
651			if (check_default_key ()) {
652	twoaday	121	char *p = get_gnupg_default_key ();
653	twoaday	273	log_box (_("WinPT Error"), MB_ERR,
654			_("Default key (from the GPG config file) could not be found or is unuseable.\n"
655			"The default key will be resetted and can be set later in the Key Manager again.\n\n"
656			"%s: secret key not found."), p? p : "?");
657	twoaday	197	set_gnupg_default_key (NULL);
658	twoaday	273	free_if_alloc (p);
659	werner	36	}
660			if (count_insecure_elgkeys ())
661			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_ELGWARN, glob_hwnd,
662	twoaday	41	elgamal_warn_dlg_proc, 0);
663	werner	36	}
664	twoaday	328
665			if (strstr (cmdline, "--emulate-utf8-bug")) {
666			MessageBox (NULL, "Please use this mode only for resetting your passphrase to a non-utf8 form.",
667			"WinPT Warning", MB_WARN);
668			emulate_utf8_bug = 1;
669			}
670	twoaday	121	if (start_manager)
671			PostMessage (hwnd, WM_COMMAND, start_manager, 0);
672
673	werner	36	accel_tab = LoadAccelerators (glob_hinst, (LPCTSTR)IDR_WINPT_ACCELERATOR);
674			keyring_check_last_access (); /* init */
675			while (GetMessage (&msg, hwnd, 0, 0)) {
676			if (!TranslateAccelerator (msg.hwnd, accel_tab, &msg)) {
677			TranslateMessage (&msg);
678			DispatchMessage (&msg);
679			}
680			}
681	twoaday	328
682	werner	36	return 0;
683			}